1607084132郭朕

[wowGZ]

//code
public class baseSort {
    public void sort(int[] a){
        System.out.println("排序算法");
    }
}
public class choiceSort extends baseSort{
    @Override
    public void sort(int[] a) {
        for (int i = 0; i < a.length; i++) {
            int min = i;
            for (int j = i + 1; j < a.length; j++) {
                if(a[min] > a[j]){
                    min = j;
                }
            }
            if(i != min){
                int temp = a[min];
                a[min] = a[i];
                a[i] = temp;
            }
        }
        for (int i = 0; i < a.length; i++) {
            System.out.print(a[i] + " ");
        }
    }
}
public class insertSort extends baseSort{
    @Override
    public void sort(int[] a) {
        int i, j, insertNote;
        for (i = 1; i < a.length; i++) {
            insertNote = a[i];
            j = i - 1;
            while (j >= 0 && insertNote < a[j]) {
                a[j + 1] = a[j];
                j--;
            }
            a[j + 1] = insertNote;
        }
        for (int k = 0; k < a.length; k++) {
            System.out.print(a[k] + " ");
        }
    }
}
public class quickSort extends baseSort{
    @Override
    public void sort(int[] a) {
        QuickSort(a, 0, a.length - 1);
        for (int i = 0; i < a.length; i++) {
            System.out.print(a[i] + " ");
        }
    }
    public void QuickSort(int[] a, int low, int hight){
        int i, j, index;
        if (low > hight) {
            return;
        }
        i = low;
        j = hight;
        index = a[i];
        while (i < j) {
            while (i < j && a[j] >= index) {
                j--;
            }
            if (i < j) {
                a[i++] = a[j];
            }
            while (i < j && a[i] < index) {
                i++;
            }
            if (i < j) {
                a[j--] = a[i];
            }
        }
        a[i] = index;
        QuickSort(a, low, i - 1);
        QuickSort(a, i + 1, hight);
    }
}
public class factory {
    private baseSort sort;
    //依赖注入
    public void setSort(baseSort sort){
        this.sort = sort;
    }
    public void doSort(int[] a){
        sort.sort(a);
    }
}
import java.util.Scanner
public class Test {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int[] a = new int[5];

//        数组初始化
        for (int i = 0; i < a.length; i++) {
            a[i] = scanner.nextInt();
        }

//        输出数组排序前的顺序
        System.out.println("数组排序前顺序如下：");
        for (int i = 0; i < a.length; i++) {
            System.out.print(a[i] + " ");
        }
        System.out.println();
//        数组选择排序后的顺序
        System.out.println("选择排序后的顺序如下:");
        factory f = new factory();
        baseSort selectsort = new choiceSort();
        f.setSort(selectsort);
        f.doSort(a);
        System.out.println();
//        数组快速排序后的顺序
        System.out.println("快速排序后的顺序如下:");
        baseSort quicksort = new quickSort();
        f.setSort(quicksort);
        f.doSort(a);
        System.out.println();
//        数组插入排序后的顺序
        System.out.println("插入排序后的顺序如下:");
        baseSort insertsort = new insertSort();
        f.setSort(insertsort);
        f.doSort(a);
        System.out.println();
    }
}

[wowGZ]

抽象类和借口的相同点

• 抽象类和接口中都可以定义属性和方法
• 抽象类和接口中的方法在大多时候，都需要在子类中重写来实现它的功能。
• 抽象类和接口中都可以不包含抽象方法。接口没有方法，就像是一种标志，被称为空接口。抽象类没有方法......不知道有什么用处......但是编译不会报错。
• 不可以创建抽象类和接口的对象
• 抽象类和接口都可以利用多态性的原理使用抽象类引用指向子类对象（本条摘自博客，理解的还不是很清楚）
• 继承抽象类或者实现接口的子类必须实现接口和抽象类的所有方法，若抽象类或接口有未实现的方法，则该子类也需为抽象类，需要加abstract修饰

  抽象类和接口的不同点

• 一个类可以实现多个接口，但是一个类只能继承一个抽象类
• 抽象类中的属性可以用多种修饰符，而接口的属性默认的为public static final
• 抽象类中有构造方法，接口中没有构造方法
• 抽象类中不一定有抽象方法，有抽象方法必须为抽象类；接口中的方法都为抽象方法
• Java8中的接口的默认方法使得接口可以像抽象类一样可以自己带集体方法，所以说如果要加一个实现类都有的方法，则可以直接在其中写出并实现就好（参考自博客，还未尝试）
• 接口只能继承接口，而抽象类既可以继承抽象类也可以继承接口。

[wowGZ]

设计模式：策略模式

设计一个抽象策略类，以及若干个实现具体功能的抽象策略类的具体策略类。这样，在主函数中可以通过向上转型来实现具体功能，而且以后如果需要增加更多的具体策略类，不需要重新写主函数以及抽象策略类的代码，只需要按照要求增加对应的具体策略类，就可以对其进行调用。 以第一次写的排序算法作为例子：

首先，设计好一个策略抽象类——BaseSort类

abstract class BaseSort {
    public void sort(int[] a){
    }
}

然后设计对应的具体策略类，比如：选择排序、快速排序、插入排序等等（以下以这三种为例）

• SelectSort类（具体策略类）继承BaseSort类（抽象策略类）

  public class SelectSort extends BaseSort{               //继承BaseSort抽象策略类
  @Override
  public void sort(int[] a) {
      for (int i = 0; i < a.length; i++) {
          int min = i;
          for (int j = i + 1; j < a.length; j++) {
              if(a[min] > a[j]){
                  min = j;
              }
          }
          if(i != min){
              int temp = a[min];
              a[min] = a[i];
              a[i] = temp;
          }
      }
      for (int i = 0; i < a.length; i++) {
          System.out.print(a[i] + " ");
      }
  }
  }

• InsertSort类（具体策略类）继承BaseSort类（抽象策略类）

  public class InsertSort extends BaseSort{                      //继承BaseSort抽象策略类
  @Override
  public void sort(int[] a) {
      int i, j, insertNote = 0;// 要插入的数据
      for (i = 1; i < a.length; i++) {// 从数组的第二个元素开始循环将数组中的元素插入
          insertNote = a[i];// 设置数组中的第2个元素为第一次循环要插入的数据
          j = i - 1;
          while (j >= 0 && insertNote < a[j]) {
              a[j + 1] = a[j];// 如果要插入的元素小于第j个元素,就将第j个元素向后移动
              j--;
          }
          a[j + 1] = insertNote;// 直到要插入的元素不小于第j个元素,将insertNote插入到数组中
      }
      for (int k = 0; k < a.length; k++) {
          System.out.print(a[k] + " ");
      }
  }
  }

• QuickSort类（具体策略类）继承BaseSort类（抽象策略类）

  public class QuickSort extends BaseSort{                //继承BaseSort抽象策略类
  @Override
  public void sort(int[] a) {                           //对抽象策略类的方法进行重写
      quicksort(a, 0, a.length - 1);              //因为要被调用的是sort()方法，所以QuickSort的
      for (int i = 0; i < a.length; i++) {            //具体实现需要另外定义一个方法进行设计
          System.out.print(a[i] + " ");               //然后在sort()中进行调用
      }
  }
  public void quicksort(int[] a, int low, int height){ //实现快速排序的具体方法
      int i, j, index;
      if (low > height) {
          return;
      }
      i = low;
      j = height;
      index = a[i];
      while (i < j) {
          while (i < j && a[j] >= index) {
              j--;
          }
          if (i < j) {
              a[i++] = a[j];
          }
          while (i < j && a[i] < index) {
              i++;
          }
          if (i < j) {
              a[j--] = a[i];
          }
      }
      a[i] = index;
      quicksort(a, low, i - 1);
      quicksort(a, i + 1, height);
  }
  }

  最后，所需要的策略类已经都写好了，现在就需要一个使用这些方法的“人”了。现在，创建一个类，对这些排序方法进行调用。

  
  import java.util.Scanner;

public class Person { private BaseSort sort;

public void setSort(BaseSort sort){
    this.sort = sort;
}

public void doSort(int[] a){
    sort.sort(a);
}

public static void main(String[] args) {
    Scanner scanner = new Scanner(System.in);
    Person person = new Person();
    int[] a = new int[5];

// 数组初始化 for (int i = 0; i < a.length; i++) { a[i] = scanner.nextInt(); }

// 输出数组排序前的顺序 System.out.println("数组排序前顺序如下："); for (int i = 0; i < a.length; i++) { System.out.print(a[i] + " "); } System.out.println();

    System.out.println("请问您想要使用什么排序方法对此数组进行排序？");
    System.out.println("1、选择排序；");
    System.out.println("2、快速排序；");
    System.out.println("3、插入排序；");

    int i = scanner.nextInt();
    switch (i) {
        case 1:
            person.setSort(new SelectSort());              //向上转型调用子类重写的方法
            person.doSort(a);
        case 2:
            person.setSort(new QuickSort());              //向上转型调用子类重写的方法
            person.doSort(a);
        case 3:
            person.setSort(new InsertSort());              //向上转型调用子类重写的方法
            person.doSort(a);
        default:
            System.out.println("您输入的数据有误！");
    }
}

}

### 优点：
- 对于子类数据的封装更彻底；
- 使得整个代码的结构更加清晰明了
### 缺点：
- 随着具体策略类的增加子类会越来越多，个人感觉会不那么容易管理，而且所占空间会越来越多。

[wowGZ]

遍历集合的一些操作

• 设置了一个Traversal类来存储各种遍历集合的方式，fori、foreach、iterator三种遍历方式被设计为了Traversal类中的三种方法。通过在其他类中对Traversal类对象的调用，进行三种集合遍历方式的调用。

  
  import java.util.ArrayList;
  import java.util.Iterator;

public class Traversal{

public void  traversal_fori(ArrayList<Person> t){            //fori遍历
    System.out.println("使用fori循环遍历集合结果如下：");
    for (int i = 0; i < t.size(); i++) {
        System.out.println("年龄：" + t.get(i).getAge() + "姓名："+ t.get(i).getName());
    }
}

public void  traversal_foreach(ArrayList<Person> t){                 //foreach遍历
    System.out.println("使用foreach循环遍历集合结果如下：");
    for (Person s:
            t) {
        System.out.println("年龄：" + s.getAge() + "姓名："+ s.getName());
    }
}

public void traversal_iterator(ArrayList<Person> t){
    Iterator<Person> personIterator = t.iterator();
    System.out.println("使用迭代器遍历集合结果如下：");
    while(personIterator.hasNext()){
        Person person = (Person)personIterator.next();
        System.out.println("年龄：" + person.getAge() + "姓名："+ person.getName());
    }
}

}

- 以上是设计的Traversal类的代码，下面让我们设计一个Test类对以上Traversal类进行一下测试
```java
import java.util.ArrayList;

public class Test {
    public static void main(String[] args) {

        ArrayList<Person> students = new ArrayList<>();
        students.add(new Person(2 , "b"));
        students.add(new Person(1 , "a"));
        students.add(new Person(3 , "c"));
        students.add(new Person(4 , "d"));
        students.add(new Person(5 , "e"));
        students.add(new Person(6 , "f"));
        students.add(new Person(7 , "g"));
        students.add(new Person(8 , "h"));
        students.add(new Person(9 , "i"));
        students.add(new Person(10, "j"));

        Traversal traversal = new Traversal();
        traversal.traversal_fori(students);
        traversal.traversal_foreach(students);
        traversal.traversal_iterator(students);
    }
}

• 测试结果如下： 使用fori循环遍历集合结果如下： 年龄：2姓名：b 年龄：1姓名：a 年龄：3姓名：c 年龄：4姓名：d 年龄：5姓名：e 年龄：6姓名：f 年龄：7姓名：g 年龄：8姓名：h 年龄：9姓名：i 年龄：10姓名：j 使用foreach循环遍历集合结果如下： 年龄：2姓名：b 年龄：1姓名：a 年龄：3姓名：c 年龄：4姓名：d 年龄：5姓名：e 年龄：6姓名：f 年龄：7姓名：g 年龄：8姓名：h 年龄：9姓名：i 年龄：10姓名：j 使用迭代器遍历集合结果如下： 年龄：2姓名：b 年龄：1姓名：a 年龄：3姓名：c 年龄：4姓名：d 年龄：5姓名：e 年龄：6姓名：f 年龄：7姓名：g 年龄：8姓名：h 年龄：9姓名：i 年龄：10姓名：j