1614010833-冯嘉兴

[aple521fjx]

public class BaseSort {
    public void sort(int []a){
        System.out.println("排序算法");
    }
}

public class Factory {
    private BaseSort sort;
    public void setSort(BaseSort sort){
        this.sort=sort;
    }
    public void doSort(int []a){
        sort.sort(a);
    }
}

public class InsterSort extends  BaseSort {
    @Override
    public void sort(int[] a) {
        for (int i = 1; i <a.length ; i++) {
            if(a[i-1]>a[i]){
                int t=a[i];
                int j=i;
                while(j>0&&a[j-1]>t){
                    a[j]=a[j-1];
                    j--;
                }
                a[j]=t;
            }
        }
        for (int x:
                a ) {
            System.out.print(x+" ");
        }
    }
}

public class QuickSort extends BaseSort{
    @Override
    public void sort(int[] a) {
        int [] b=a;
          quicksort(b,0,a.length-1);
        for (int x:
                b ) {
            System.out.print(x+" ");
        }
    }
    public void quicksort(int []a,int left,int right){
        int i,j,t,k;
        if(left>right) return ;
        t=a[left];
        i=left;
        j=right;
        while(i!=j){
            while(a[j]>=t&&i<j)  //  右边比左边大跳过,循环结束找到一个小于t的
                j--;
            while(a[i]<=t&&i<j)  //  从左往右找到第一个比t大的
                i++;
            if(i<j){
                k=a[i];
                a[i]=a[j];
                a[j]=k;
            }
        }
        a[left]=a[i];
        a[i]=t;
        quicksort(a,left,i-1);
        quicksort(a,i+1,right);
    }
}

public class SelectSort extends BaseSort{
    @Override
    public void sort(int[] a) {
        for (int i = 0; i <a.length-1 ; i++) {
            for (int j = i+1; j <a.length ; j++) {
                if(a[i]>a[j]){
                    int t;
                    t=a[i];
                    a[i]=a[j];
                    a[j]=t;
                }
            }
        }
        for (int x:
            a ) {
            System.out.print(x+" ");
        }
    }
}

import java.util.Scanner;

public class test {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        System.out.println("请随机输入10个数字");
        int []a = new int[10];
        for (int i = 0; i <10 ; i++) {
            a[i]=sc.nextInt();
        }
        Factory factory = new Factory();
        //选择排序
        System.out.println("选择排序:");
        BaseSort selectsort= new SelectSort();
        factory.setSort(selectsort);
        factory.doSort(a);
        //插入排序
        System.out.print("\n插入排序:\n");
        BaseSort instersort= new InsterSort();
        factory.setSort(instersort);
        factory.doSort(a);
        //快速排序
        System.out.print("\n快速排序:\n");
        BaseSort quick= new QuickSort();
        factory.setSort(quick);
        factory.doSort(a);
    }
}

[aple521fjx]

第二次作业（少写设计模式）

JDK1.8之后，接口与抽象类的区别

1.类只能单继承，而接口可以多实现 2.接口中的属性，方法都是默认public关键字修饰的，而抽象类里面可以用其他修饰关键字修饰 3.接口不用写默认的抽象方法

[aple521fjx]

补充设计模式

工厂设计模式，对于基本的对象创造一个专门生产的工厂，通过统一的一个工厂，传递不同的参数制造出不同的对象。

狗类的接口（含有两个抽象方法）

public interface dog {
    //说话的方法
    void say();

    //弹跳的方法
    void jump();
}

两个特定的对象（大狗和小狗）,都实现接口

public class BigDog implements dog {
    //大狗的类 实现接口dog里的方法

    @Override
    public void say() {
        System.out.println("我是大狗，我很凶");
    }

    @Override
    public void jump() {
        System.out.println("我能跳的非常高");
    }
}

public class SmallDog implements  dog {
 //这是小狗的类 实现接口方法

    @Override
    public void say() {
        System.out.println("我是小狗，我很温柔");
    }

    @Override
    public void jump() {
        System.out.println("我跳的很低");
    }
}

抽象工厂类，包含一个造狗的方法

public abstract class Factor {
    public abstract <T extends  dog> T Creatdog(Class<T> clz);
}

具体的一个狗工厂，继承基本工厂类，重写父类方法

public class Dogfactor extends Factor {
    //继承工厂类 重写父类方法

    @Override
    public <T extends dog> T Creatdog(Class<T> clz) {
        dog dog1=null;
        try {
            dog1=(dog)Class.forName(clz.getName()).newInstance();
        }catch(Exception e){
            e.printStackTrace();
        }
        return (T) dog1;
    }

}

主函数

public class main {

    public static void  main(String args[]){
      //创建造狗工厂
        Factor factor=new Dogfactor();

      //制作小狗
      SmallDog smalldog=factor.Creatdog(SmallDog.class);
      smalldog.jump();
      smalldog.say();
        System.out.println();
        //制作大狗
      BigDog bigdog=factor.Creatdog(BigDog.class);
      bigdog.jump();
      bigdog.say();
    }

}

输出结果

我跳的很低 我是小狗，我很温柔

我能跳的非常高 我是大狗，我很凶

[aple521fjx]

第三次作业 几种集合遍历的方式

写了一个主类，在主方法中创建集合并初始化，在类中写了五种集合遍历方法，主方法中调用

主方法

public static void main(String[] args) {
        //创建要遍历的集合,并初始化
        List <String> list=new ArrayList<>();
        list.add("hello");
        list.add("world");
        list.add("JAVA");
        list.add("fjx");

        //第一种遍历
        System.out.println("第一种遍历（fori）:");
        show1(list);
        System.out.println("第二种遍历（foreach）:");
        show2(list);
        System.out.println("第三种遍历（迭代器）:");
        show3(list);
        System.out.println("第四种遍历（Stream）:");
        show4(list);
        System.out.println("第五种遍历（lamdb表达式）:");
        show5(list);
    }

fori语句遍历集合

public static void show1(List<String> list){
        for (int i = 0; i <list.size() ; i++) {
            System.out.println(list.get(i));
        }
    }

foreach语句遍历集合

public static void show2(List<String> list){
        for (String s:
            list ) {
            System.out.println(s);
        }
    }

Iterator语句遍历集合

`public static void show3(List<String> list){
        Iterator<String> ite= list.iterator();
        while(ite.hasNext()){
            System.out.println(ite.next());
        }
    }

Stream流语句遍历集合

public static void show4(List<String> list){
         list.stream().forEach(System.out::println);
    }

Lambd流语句遍历集合

public  static void show5(List<String> list){
        list.forEach((s)-> System.out.println(s));
    }

输出结果

第一种遍历（fori）: hello world JAVA fjx 第二种遍历（foreach）: hello world JAVA fjx 第三种遍历（迭代器）: hello world JAVA fjx 第四种遍历（Stream）: hello world JAVA fjx 第五种遍历（lamdb表达式）: hello world JAVA fjx

了解的Stream流的常用方法

简述Stream Java 8引入了全新的Stream API。这里的Stream和I/O流不同，它更像具有Iterable的集合类，但行为和集合类又有所不同。 最新添加的Stream API（java.util.stream） 把真正的函数式编程风格引入到Java中。这是目前为止对Java类库最好的补充，因为Stream API可以极大提供Java程序员的生产力，让程序员写出高效率、干净、简洁的代码。

中间操作： filter() --------排除所有与断言不匹配的元素 map() --------对元素执行一对一的转换 peek() --------对每个遇到的元素执行一些操作 limit() --------保证后续的操作所能看到的最大数量的元素

最终操作： forEach() -------对流中的每个元素执行一些操作 toArray() -------将流中的元素装进一个数组 count() ---------计算流中元素的数量 findFirst() ------查找流中的第一个元素，是一个短路操作