java进阶打卡20

函数式编程思想

• 面向对象的思想：
  做一件事情，找一个能解决这个事情的对象，调用对象的方法，完成事情
• 函数式编程思想：
  只要能获取到结果，怎么做的都不重要，重视的是结果，不重视过程

冗余的Runnable代码

使用实现Runnable接口的方式实现多线程程序
public class RunnableImpl implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + " 新线程创建了");
    }
}

public class Demo01Runnable {
    public static void main(String[] args) {
        RunnableImpl run = new RunnableImpl();
        Thread t = new Thread(run);
        t.start();

        // 简化代码，使用匿名内部类，实现多线程程序
        Runnable r = new Runnable(){
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + " 新线程创建了");
            }
        };
        new Thread(r).start();

        // 简化代码
        new Thread(new Runnable(){
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + " 新线程创建了");
            }
        }).start();

    }
}

代码分析：
对于Runnable的匿名内部类用法，可以分析出几点内容：
- Thread类需要Runnable接口作为参数，其中的抽象run方法是用来指定线程任务内容的核心；
- 为了指定run的方法体，【不得不】需要Runnable接口的实现类；
- 为了省去定义一个RunnableImpl实现类的麻烦，【不得不】使用匿名内部类；
- 必须覆盖重写抽象run方法，所以方法名称、方法参数、方法返回值【不得不】再写一遍，且不能写错；
- 而实际上，【似乎只有方法体才是关键所在】。

Lambda表达式

Lambda表达式的标准格式：
    由三部分组成：
        a. 一些参数
        b. 一个箭头
        c. 一段代码
    格式：
        (参数列表) -> {一些重写方法的代码};
    解释说明格式：
        ()：接口中抽象方法的参数列表，没有参数，就空着；有参数就写出参数，多个参数使用逗号分隔
        ->：传递的意思，把参数传递给方法体{}
        {}：重写接口的抽象方法的方法体

public class Demo02Lambda {
    public static void main(String[] args) {
        // 使用匿名内部类的方式，实现多线程
        new Thread(new Runnable(){
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + " 新线程创建了");
            }
        }).start();

        // 使用Lambda表达式，实现多线程
        new Thread(()-> {
                System.out.println(Thread.currentThread().getName() + " 新线程创建了");
            }
        ).start();
    }
}

Lambda表达式练习

• 无参数无返回值练习

需求：
    给定一个厨子Cook接口，内涵唯一的抽象方法makeFood，且无参数、无返回值。
    使用Lambda的标准格式调用invokeCook方法，打印输出“吃饭啦！”字样

public interface Cook {
    public abstract void makeFood();
}

public class Demo01Cook {
    public static void main(String[] args) {
        // 调用invokeCook方法，参数是Cook接口，传递Cook接口的匿名内部类对象
        invokeCook(new Cook() {
            @Override
            public void makeFood() {
                System.out.println("吃饭啦！");
            }
        });

        // 使用Lambda表达式，简化匿名内部类的书写
        invokeCook(() -> {
            System.out.println("吃饭啦！");
        });
    }

    // 定义一个方法，参数传递Cook接口，方法内部调用Cook接口中的方法makeFood
    public static void invokeCook(Cook cook) {
        cook.makeFood();
    }
}

• 有参数有返回值练习

需求：
    使用数组存储多个Person对象
    对数组中的Person对象使用Arrays的sort方法通过年龄进行升序排序

public class Person {
    private String name;
    private int age;
    无参构造、有参构造、重写toString方法、Getter/Setter方法省略
}

public class Demo01Arrays {
    public static void main(String[] args) {
        Person[] arr = {
                new Person("Xxx1",38),
                new Person("Xxx2",18),
                new Person("Xxx3",19)
        };

        // 对数组中的Person对象使用Arrays的sort方法通过年龄进行升序（前边 - 后边）排序
       /* Arrays.sort(arr, new Comparator<Person>() {
            @Override
            public int compare(Person o1, Person o2) {
                return o1.getAge() - o2.getAge();
            }
        });*/

        // 使用Lambda表达式，简化匿名内部类
        Arrays.sort(arr,(Person o1, Person o2)->{
            return o1.getAge() - o2.getAge();
        });

        // 遍历数组
        for (Person p : arr) {
            System.out.println(p);
        }
    }
}