多个工厂方法模式


在普通工厂模式下改动SendFactory类就行.

1
2
3
4
5
6
7
8
9
10
public class SendFactory {
  // 自定义成员方法专门生产邮件发送者的对象
  public Sender produceMail() {
    return new MailSender();
  }
  // 自定义成员方法专门生产短信发送者的对象
  public Sender produceSms() {
    return new SmsSender();
  }
}

改动SendFactoryTest类

1
2
3
4
5
6
7
8
9
10
11
12
public class SendFactoryTest {
  public static void main(String[] args) {
    SendFactory factory = new SendFactory();
    /* 调用SmsSender的Send()方法
    Sender sender = factory.produceSms();
    sender.Send();
    */   
    // 调用Mailender的Send()方法
    Sender sender = factory.produceMail();
    sender.Send();
  }
}

静态工厂方法模式

将上面的多个工厂方法模式里的方法置为静态的，不需要创建实例，直接调用即可.

1
2
3
4
5
6
7
8
9
10
public class SendFactory {
  // 自定义成员方法专门生产邮件发送者的对象
  public static Sender produceMail() {
    return new MailSender();
  }
  // 自定义成员方法专门生产短信发送者的对象
  public static Sender produceSms() {
    return new SmsSender();
  }
}
1
2
3
4
5
6
7
8
9
10
11
public class FactoryTest {   
  public static void main(String[] args) { 
    /*直接调用SmsSender的Send()方法
    Sender sender = factory.produceSms();  
      sender.Send();
    */
    //直接调用MailSender的Send()方法
    Sender sender = SendFactory.produceMail();  
    sender.Send(); 
  }  
}

抽象工厂方法模式


在建好上述的sender接口、MailSender类和SmsSender类后，建以下接口和类：

1
2
3
4
public interface Provider {
  // 自定义抽象方法描述生产的行为
  public abstract Sender produce();
}
1
2
3
4
5
6
public class MailSendFactory implements Provider {
  @Override
  public Sender produce() {
    return new MailSender();
  }
}
1
2
3
4
5
6
public class SmsSendFactory implements Provider {
  @Override
  public Sender produce() {
    return new SmsSender();
  }
}

编写测试类：

1
2
3
4
5
6
7
8
9
10
11
12
13
public class Test {
  public static void main(String[] args) {
    /* 调用SmsSender的Send()方法
    Provider provider = new SmsSendFactory();
    Sender sender = provider.produce();
    sender.Send();
    */
    //调用MailSender的Send()方法
    Provider provider = new MailSendFactory();
    Sender sender = provider.produce();
    sender.Send();
  }  
} 

线性(顺序)查找算法

使用目标元素与样本数列中的第一个元素起依次比较。

若找到与目标元素相等的元素，则表示查找成功。

若目标元素与所有样本元素比较完毕也不相等，则表示查找失败。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
public class FindTest {
  // 自定义成员方法实现线性查找算法
  // 要求从参数指定的数组中查找参数指定的元素并返回对应的下标
  public static int find(int[] arr, int num) {
    for(int i = 0; i < arr.length; i++) {
      if(num == arr[i]) {
        return i; // 表示查找成功
      }
    }
    return -1; // 表示查找失败
  }

  public static void main(String[] args) {
    int[] brr = {10, 20, 30, 40, 50};
    int ia = 25;
    int res = FindTest.find(brr, ia);
    if(-1 == res) {
      System.out.println(ia + "不存在！");
    } else {
      System.out.println(ia + "在数组中的下标是：" + res); // 1
    }
  }
}

二分(折半)查找算法

假定样本数列中的元素是从小到大依次排序的.

使用目标元素与样本数列中的中间元素进行比较.

若目标元素与中间元素相等,则表示查找成功.

若目标元素小于中间元素,则去中间元素的左边进行查找.

若目标元素大于中间元素,则去中间元素的右边进行查找.

直到目标元素与所有该比较的元素比较完毕后也不相等,则表示查找失败.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
public class FindTest {
  public static int findBinary(int[] arr, int left, int right, int num) {
    if(left <= right) {
      // 1.计算中间元素的下标
      int p = (left + right) / 2;
      // 2.使用目标元素与中间元素比较是否相等，若相等则查找成功
      if(num == arr[p]) {
        return p;
      }
      // 3.若目标元素小于中间元素则去左边查找，使用递归的思想
      if(num < arr[p]) {
        return findBinary(arr, left, p-1, num);
      }
      // 4.若目标元素大于中间元素则去右边查找，使用递归的思想
      return findBinary(arr, p+1, right, num);
    }
    return -1; // 表示查找失败
  }

  public static void main(String[] args) {
    int[] brr = {10, 20, 30, 40, 50};
    int ia = 25;
    int res = FindTest.findBinary(brr, 0, 4, ia);
    if(-1 == res) {
      System.out.println(ia + "不存在！");
    } else {
      System.out.println(ia + "在数组中的下标是：" + res); // 1
    }
  }
}

冒泡排序算法(重中之重)


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
public class SortTest {
  // 自定义成员方法实现冒泡排序算法
  // 要求将参数指定数组中的所有元素从小到大依次排序
  public static void bubble(int[] arr) {
    // 1.使用外层for循环用于控制比较的轮数
    for(int i = 1; i < arr.length; i++) {
      // 声明一个boolean类型的变量，作为是否发生交换的标志
      boolean flag = true;
      // 2.使用内层for循环用于控制针对每一轮比较的次数，也就是下标范围
      for(int j = 0; j < arr.length-i; j++) {
        // 3.若第一个元素比第二个元素大，则交换两个元素的位置
        if(arr[j] > arr[j+1]) {
          int temp = arr[j];
          arr[j] = arr[j+1];
          arr[j+1] = temp;
          flag = false;
        }
      }
      // 代码执行到这里的时候，若flag还为true说明该轮比较中没有发生任何交换
      if(flag) {
        break; // 省略剩余轮数的比较，从而提高效率
      }
    }
  }

  public static void main(String[] args) {
    int[] brr = {10, 20, 5, 20, 15, 30, 8};
    SortTest.bubble(brr);
    System.out.print("排序后的结果是：");
    for(int i : brr) {
      System.out.print(i + " ");
    }
    System.out.println();
  }
}