1607064106-续溢男

[xyndameinv]

public class Basesort {
    public void sort(int[] a)
    {
        System.out.println("排序方法");
    }
}
public class SelectSort extends Basesort {
    public void sort(int[] a)
    {
        int i,j,k;
        for(i=0;i<9;i++)
        {
            k=i;
            for(j=i+1;j<10;j++)
            {
                if (a[k]>a[j])
                    k=j;
            }
            if(k!=i)
            {
                a[i]=a[i]+a[k];
                a[k]=a[i]-a[k];
                a[i]=a[i]-a[k];
            }
        }
        System.out.println("选择排序:");
        for (int num:
             a) {
            System.out.print(num+" ");
        }
        System.out.println();
    }
}
public class InsertSort extends Basesort {
    public void sort(int[] a)
    {
        int i,j,k,temp;
        for(i=1;i<10;i++)
        {
            j=0;
            while(j<i&&a[j]<a[i])
                j++;
            if(j<i)
            {
                temp=a[i];
                for(k=i-1;k>=j;k--)
                {
                    a[k+1]=a[k];
                }
                a[j]=temp;
            }
        }
        System.out.println("插入排序：");
        for (int num:
           a  ) {
            System.out.print(num+" ");
        }
        System.out.println();
    }
}
public class QuickSort extends Basesort {
    public void sort(int[] a) {
        System.out.println("快速排序：");
        quick(a);
        for (int i=0;i<10;i++)
            System.out.print(a[i]+" ");
        System.out.println();
    }
    public int getMiddle(int[] list,int low,int high) {
        int temp = list[low];
        while (low < high) {
            while (low < high && list[high] >= temp) {
                high--;
            }
            list[low] = list[high];
            while (low<high && list[low]<= temp) {
                low++;
            }
            list[high] = list[low];
        }
        list[low] = temp;
        return low;
    }
    public void quickSort(int[]list,int low,int high) {
        if (low < high) {
            int middle = getMiddle(list, low, high);
            quickSort(list, low, middle - 1);
            quickSort(list, middle + 1, high);
        }
    }
    public void quick(int[] a2) {
        if (a2.length > 0) {
            quickSort(a2,0,a2.length-1);
        }
    }
}
public class Factory {
    private Basesort sort;
    //依赖注入
    public void setSort(Basesort sort)
    {
        this.sort=sort;
    }
    public void sort(int[] a)
    {
        sort.sort(a);
    }
}
import java.util.Scanner;

public class Test {
    public static void main(String[] args) {
        Scanner input=new Scanner(System.in);
        //数组初始化
        int[] a=new int[10];
        for(int i=0;i<10;i++)
            a[i]=input.nextInt();
        Factory factory=new Factory();
        //选择排序结果
        Basesort basesort1=new SelectSort();
        factory.setSort(basesort1);
        factory.sort(a);
        //插入排序结果
        Basesort basesort2=new InsertSort();
        factory.setSort(basesort2);
        factory.sort(a);
        //快速排序结果
        Basesort basesort3=new QuickSort();
        basesort3.sort(a);
    }
}

[xyndameinv]

在java8以后为什么还有抽象类：

一、
在java8中接口有了默认方法，只要用default关键词修饰就可以。这样解决了在之前如果要向一个接口中增添一个方法就必须要修改所有的实现类的问题。这也说明接口的功能与抽象类越来越接近。但是他们仍有一些区别
二：接口的好处
接口是多继承的而抽象类是单继承的。并且使用接口只用考虑这个类有没有什么方法，而不用考虑它是不是谁的子类，比如人和草都呼吸我们可以用一个接口实现呼吸方法，但是他们有许多的属性都不同，使用抽象类就没有使用接口灵活了。
三：抽象类的好处
1、接口中不能有成员变量但是抽象类中可以有
2、接口中方法都是public修饰的，但是抽象类中可以有其他修饰符修饰的方法。如果想要严格控制访问还是要用抽象类。
3、接口只能继承接口，但是抽象类可以继承其他类并且实现接口
4、抽象类中可以有静态代码块但是接口中没有
5、抽象类有构造方法但是接口没有

2、设计模式之简单工厂模式

什么是简单工厂模式：用一个工厂去创建继承了同一个类（或者实现了同一个接口）的类的实例。实质是根据传入到工厂的参数的不同创建不同的实例。

代码实现：

产品抽象接口：

public interface Human {
    void ishuman();
}

具体的产品类：

public class Women implements Human{

    @Override
    public void ishuman() {
        System.out.println("是女人");
    }
}
public class Men implements Human {
    @Override
    public void ishuman() {
        System.out.println("是男人");
    }
}

简单工厂类：

public class SimpleFactory {
    private Human people=null;
//利用条件语句判断创建哪个对象的实例
    public Human creat(String type)
    {
        if(type.equals("women"))
        {
           people=new Women();
        }
        else if (type.equals("men"))
        {
            people=new Men();
        }
        else{
            System.out.println("不能创建");
        }
        return people;
    }
}

客户端

import java.util.Scanner;

public class Test {
    public static void main(String[] args) {
        Scanner input=new Scanner(System.in);
        String s;
        System.out.println("你想创建哪个类的实例");
        s=input.next();
        SimpleFactory simpleFactory=new SimpleFactory();
        Human people=simpleFactory.creat(s);
        if(people!=null) {
            people.ishuman();
        }
    }
}

运行结果：

1.你想要创建哪个类的实例
man
不能创建
2.你想要创建哪个类的实例
women
是女人

简单工厂模式的优点;

   用户不需要直接创建具体的产品对象，不需要知道工厂类中是怎么创建怎么组织的，明确了分工与职责。

缺点：

  把所有的逻辑都放在了工厂类中；只能创建事先知道的产品类的对象，如果要增添其他产品对象就需要改动工厂类；当具体的产品很多的时候，对条件的判断以及对具体创建的产品的判断交错在一起变得很麻烦。

[xyndameinv]

第三次作业：

创建一个序列

        List<String> list=new ArrayList<>();
        Scanner input=new Scanner(System.in);
        int num,i;
        String s;
        System.out.println("输入数据的个数");
        num=input.nextInt();
        for(i=0;i<num;i++)
        {
            System.out.println("输入第"+(i+1)+"个字符串");
            s=input.next();
            list.add(s);
        }

利用foreach进行遍历（比较推荐的遍历方法）

       for (String s1:list
             ) {
            System.out.println(s1);
        }

利用for语句进行遍历

       for (int j = 0; j <list.size(); j++) {
            System.out.println(list.get(j));
        }

利用迭代器进行遍历

Iterator<String >iterator=list.iterator();
        while(iterator.hasNext())
        {
            System.out.println(iterator.next());
        }

利用stream进行遍历

 list.stream().forEach(System.out::println);

运行结果

输入：
输入数据的个数
3
输入第1个字符串
zhang
输入第2个字符串
zhao
输入第3个字符串
chen
输出结果
zhang
zhao
chen