1607064222陈帅宇

[chenshuaiyu]

import java.util.Scanner;

class BaseSort{
    public void sort(int[] a){
        System.out.println("排序算法");
        for (int b : a) {
            System.out.print(b+" ");
        }
        System.out.println();
    }
}
class InsertSort extends BaseSort{
    @Override
    public void sort(int[] a) {
        System.out.println("插入排序：");
        int i,j,temp;
        for(i = 1; i < a.length; i++)
        {
            j=i-1;
            temp=a[i];//存储插入值
            while(j>=0 && a[j]>temp)//寻找要插入的位置
            {
                a[j+1]=a[j];
                j--;
            }
            a[j+1]=temp;//将其插入
        }
    }
}
class SelectSort extends BaseSort{
    @Override
    public void sort(int[] a) {
        System.out.println("选择排序：");
        int i,j,k,temp;
        for (i = 0; i < a.length; i++) {
            temp=a[i];
            j=i+1;k=i;
            while (j<a.length){     //找到 i 位置上该放的值
                if(a[j]<temp)
                    k=j;
                j++;
            }
            if(k != i)      //将找到的值放在指定位置
            {
                a[i]=a[i] ^ a[k];
                a[k]=a[i] ^ a[k];
                a[i]=a[i] ^ a[k];
            }
        }
    }
}
class QuickSort extends BaseSort{

    public void sort(int[] a,int l,int r) {
        int i=l,j=r,temp;
        if(i<j)
        {
            temp=a[i];
            do
            {
                while(i<j && a[j]>temp)//从后往前找到小于 temp 的值
                    j--;
                if(i<j)
                {
                    a[i]=a[j];i++;//放到左边空缺位置上
                }
                while(i<j && a[i]<temp)//从前往后找到大于 temp 的值
                    i++;
                if(i<j)
                {
                    a[j]=a[i];j--;//放到右边空缺位置上
                }
            }while(i!=j);
            a[i]=temp;//将 temp 放到中间空缺位置（最终位置）
            sort(a,l,i-1);
            sort(a,i+1,r);
                //利用递归找到其他值的最终位置
        }
    }
}

class Factory{
    private BaseSort baseSort;
    public void setSort(BaseSort baseSort){
        this.baseSort=baseSort;
    }
    public void doSort(int[] a){
        if(baseSort instanceof QuickSort) {     //判断是否为快速排序
            System.out.println("快速排序：");
            ((QuickSort) baseSort).sort(a,0,a.length-1);
        }

        else
            baseSort.sort(a);
        for (int b : a) {
            System.out.print(b+" ");
        }
        System.out.println();
    }
}
//测试类
public class Test {
    public static void main(String[] args) {
        int[] arr=new int[10];
        Scanner scanner=new Scanner(System.in);
        for (int i = 0; i < 10; i++) {
            arr[i]= scanner.nextInt();
        }
        Factory factory=new Factory();

        InsertSort insertSort=new InsertSort();
        factory.setSort(insertSort);
        factory.doSort(arr);

        SelectSort selectSort=new SelectSort();
        factory.setSort(selectSort);
        factory.doSort(arr);

        QuickSort quickSort=new QuickSort();
        factory.setSort(quickSort);
        factory.doSort(arr);
    }
}

[chenshuaiyu]

1.为什么有了接口还要是使用抽象类?

抽象类：

可以有构造方法

变量 四个权限都可有

方法 四个权限都可有

接口：

方法 public abstract

变量 public static final

java8 新增default和static方法

java9 新增private方法（在java9之前，变量和方法都只能为public）

接口并不能完全取代抽象类，接口中不能有构造方法，也不能有private变量。可有实例方法，但不可有实例变量。

接口默认方法的优点：可以在其他类实现时免于复写其方法，减少代码量。

2.设计模式

工厂设计模式:

Product:(产品类接口) 用于规范产品 ConcreteProduct:(具体产品类) 作为具体产品类 Factory:(工厂类接口) 用于与管理者进行交互 ConcreteFactory:(具体工厂类) 用于生产产品 产品类接口

    public interface Product {
        void show();
    }

工厂类接口

    public interface Factory {
        Product createProduct();
    }

具体产品类

    public class ConcreteProduct implements Product {
        @Override
        public void show() {
            System.out.println("This is a concreteproduct.");
        }
    }

具体工厂类

    public class ConcreteFactory implements Factory {
        @Override
        public Product createProduct() {
            return new ConcreteProduct();
        }
    }

测试类

    public class FactoryTest {
        public static void main(String[] args) {
            Factory factory=new ConcreteFactory();
            Product product=factory.createProduct();
            product.show();
        }
    }

测试结果

This is a concreteproduct.

当产品种类繁多的时候，会出现很多具体工厂类，导致代码冗余。运用反射可以很好的解决这个问题。这时，需要对工厂类接口进行修改。

工厂类接口

    public interface Factory2 {
        <T extends Product> T createProduct(Class<T> t);
    }

具体工厂类

    public class ConcreteFactory2 implements Factory2 {

        //反射暂时未学习，只是初步了解
        @Override
        public <T extends Product> T createProduct(Class<T> t) {
            Product product=null;
            try{
                product = (Product) Class.forName(t.getName()).newInstance();
            }catch(Exception e){
                e.printStackTrace();
            }
            return (T) product;
        }
    }

通过反射，只要将具体产品类的类名传入，即可获得相应实例。

测试类

    public class FactoryTest2 {
        public static void main(String[] args) {
            Factory2 factory=new ConcreteFactory2();
            Product product=factory.createProduct(ConcreteProduct.class);
            product.show();

            Product product2=factory.createProduct(ConcreteProduct2.class);
            product2.show();
        }
    }

测试结果 This is a concreteproduct. This is a concreteproduct2.

[chenshuaiyu]

public class Test {
    public static void main(String[] args) {
        List<String> list=new ArrayList<String>();
        list.add("java01");
        list.add("java02");
        list.add("java03");
        list.add("java04");
        list.add("java05");
        list.add("java06");
        list.add("java07");
        list.add("java08");
        list.add("java09");
        list.add("java10");
        //fori
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
        //foreach
        for (String s: list) {
            System.out.println(s);
        }
        //Iterator
        Iterator<String> iterator=list.iterator();
        while(iterator.hasNext()){
            System.out.println(iterator.next());
        }
        //Stream
        list.stream().forEach(s -> System.out.println(s));
        list.stream().forEach(new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        });

    }
}

测试结果 java01 java02 java03 java04 java05 java06 java07 java08 java09 java10