Java-08

1. Lambda

1.1 函数式编程思想概述

• 在数学中，函数就是有输入量、输出量的一套计算方案，也就是“数据做操作“
• 面向对象思想强调“必须通过对象的形式来做事情”
• 函数式思想则尽量忽略面向对像的复杂语法：“强调做什么，而不是以什么形式去做”
• 而我们要学习的Lambda表达式就是函数式思想的体现

1.2 体验lambda表达式

需求：启动一个线程，在控制台输出一句话：多线程程序启动了

方式1：

• 定义一个类MyRunnable:实现Runnable接口，重写run() 方法
• 创建MyRunnable类的对象
• 创建Thread类的对象，把MyRunnable的对象作为构造参数传递
• 启动线程

方式2：

• 匿名内部类的方式改进

方式3：

• Lambda表达式的方式改进

//1.创建MyRunnable类
package demo_01;

public class MyRunnable implements Runnable{
    @Override
    public void run() {
        System.out.println("多线程启动了");
    }
}

//2.实现类
package demo_01;
//需求：启动一个线程，在控制台输出一句话：多线程程序启动了
public class LambdaDemo {
    public static void main(String[] args) {
        //实现类的方式实现需求
       /* MyRunnable my = new MyRunnable();
        Thread th = new Thread(my);
        th.start();*/

        //匿名内部类的方式改进
        /*new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("多线程启动了");
            }
        }).start();*/

        //Lambda表达式的方式改进
        new Thread(() -> {
            System.out.println("多线程启动");
        }).start();
    }
}

1.3 Lambda表达式的标准格式

匿名内部类中重写run() 方法的代码分析：

• 方法形式参数为空，说明调用方法时不需要传递参数
• 方法返回值类型为void,说明方法执行没有结果返回
• 方法体中的内容，是我们具体要做的事情

//匿名内部类的方式改进
new Thread(new Runnable() {
    @Override
    public void run() {
        System.out.println("多线程启动了");
    }
}).start();

Lambda表达式的代码分析:

• () :里面没有内容，可以看成是方法形式参数为空
• -> :用箭头指向后面要做的事情
• {}:包含一段代码，我们称之为代码块，可以看成是方法体中的内容

组成Lambda表达式的三要素：形式参数，箭头，代码块

//Lambda表达式的方式改进
new Thread(() -> {
	System.out.println("多线程启动");
}).start();

Lambda表达式的格式：

• 格式：（形式参数）-> {代码块}
• 形式参数：如果有多个参数，参数之间用逗号隔开；如果没有参数，留空即可
• ->：由英文中画线和大于符号组成，固定写法。代表指向动作
• 代码块：是我们具体要做的事情，也就是以前我们写的方法体内容

1.4 Lambda表达式的使用

Lambda表达式的使用前提：

1. 有一个接口
2. 接口中有且仅有一个抽象方法

练习1：

• 定义一个接口(Eatable),里面定义一个抽象方法：void eat();
• 定义一个测试类(EatableDemo),在测试类中提供两个方法:
  一个方法是：useEatable(Eatable e)
  一个方法是主方法，在主方法中调用useEatable方法

//1.创建接口
package demo_02;

public interface Eatable {
    void eat();
}

//2.接口实现类
package demo_02;

public class EatableLmpl implements Eatable{
    @Override
    public void eat() {
        System.out.println("吃水果");
    }
}

//3.测试类
package demo_02;
/*
- 定义一个接口(Eatable),里面定义一个抽象方法：void eat();
        - 定义一个测试类(EatableDemo),在测试类中提供两个方法:
        一个方法是：useEatable(Eatable e)
        一个方法是主方法，在主方法中调用useEatable方法
*/
public class EatableDemo {
    public static void main(String[] args) {
        //接口实现类方法
        Eatable el = new EatableLmpl();
        useEatable(el);

        //匿名内部类
        useEatable(new Eatable() {
            @Override
            public void eat() {
                System.out.println("吃水果");
            }
        });

        //lambda表达式
        useEatable(()->{
            System.out.println("吃水果");
        });

    }
    public static void useEatable(Eatable e){
        e.eat();
    }
}

练习2：

• 定义一个接口(Flyable),里面定义一个抽象方法：void fly(String s):
• 定义一个测试类(FlyableDemo),在测试类中提供两个方法
  一个方法是：useFlyable(Flyable f)
  一个方法是主方法，在主方法中调用useFlyable方法

//1.创建Flyable接口
package demo_03;

public interface Flyable {
    void fly(String s);
}

//测试类
package demo_03;
/*
- 定义一个接口(Flyable),里面定义一个抽象方法：void fly(String s):
        - 定义一个测试类(FlyableDemo),在测试类中提供两个方法
        一个方法是：useFlyable(Flyable f)
        一个方法是主方法，在主方法中调用useFlyable方法
 */
public class FlyableDemo {
    public static void main(String[] args) {
        //匿名内部类
        useFlyable(new Flyable() {
            @Override
            public void fly(String s) {
                System.out.println(s);
                System.out.println("万物复苏");
            }
        });

        //lanbada表达式
        useFlyable((s -> {
            System.out.println("lambada引用");
        }));

    }
    public static void useFlyable(Flyable f){
        f.fly("出暖花开，生机勃勃");
    }
}

练习3：

• 定义一个接口(Addable),里面定义一个抽象方法：int add(intx, inty);
• 定义一个测试类(AddableDemo),在测试类中提供两个方法:
  一个方法是：useAddable(Addable a
  一个方法是主方法，在主方法中调用useAddable方法

//1.创建接口
package demo_04;

public interface AddAble {
    int add(int x,int y);
}

//2.测试类
package demo_04;
/*
- 定义一个接口(Addable),里面定义一个抽象方法：int  add(intx, inty);
        - 定义一个测试类(AddableDemo),在测试类中提供两个方法:
        一个方法是：useAddable(Addable a
        一个方法是主方法，在主方法中调用useAddable方法
        */
public class AddAbleDemo {
    public static void main(String[] args) {
        //调用useAddable方法
        useAddable(((x, y) -> {
            return x + y;
        }));
    }
    public static void useAddable(AddAble a){
        int sum = a.add(10,20);
        System.out.println(sum);
    }
}

1.5 Lambda表达式的省略模式

省略规则：

• 参数类型可以省略。但是有多个参数的情况下，不能只省略一个
• 如果参数有且仅有一个，那么小括号可以省略
• 如果代码块的语句只有一条，可以省略大括号和分号，甚至是return

//1.定义Addable接口
package demo_05;

public interface Addable {
    int add(int x, int y);
}

//2.创建Flyanle接口
package demo_05;

public interface Flyable {
    void fly(String s);
}

//3.测试类
package demo_05;

import demo_03.Flyable;
import demo_04.AddAble;

public class LambdaDemo {
    public static void main(String[] args) {
        //参数类型可以省略
        useAddable((x,y)->{
            return x + y;
        });

        useFlyable((s) -> {
            System.out.println(s);
        });

        //如果参数有且仅有一个，那么小括号也可以省略
        useFlyable(s -> System.out.println(s));

        //如果代码语句只有一条，可以省略大括号和分号
        useFlyable(s -> System.out.println(s));

        //如果代码语句只有一条，可以省略大括号和分号,如果有return，也可以省略掉
        useAddable((x,y)-> x + y);
    }
    public static void useFlyable(Flyable f){
        f.fly("春暖花开，万物复苏");
    }

    public static void useAddable(AddAble a){
        int sum = a.add(20,30);
        System.out.println(sum);
    }
}

1.6 Lambda表达式的注意事项

注意事项：

• 使用Lambda必须要有接口，并且要求接口中有且仅有一个抽像方法
• 必须有上下文环境，才能推导出Lambda对应的接口
  根据局部变量的赋值得知Lambda对应的接口：Runnable r=()->System.out.println(“Lambda表达式”)；
  根据调用方法的参数得知Lambda对应的接口：new Thread(()->System.out.println(“Lambda表达式”).start();

1.7 Lambda表达式和匿名内部类的区别

1.所需类型不同

• 匿名内部类：可以是接口，也可以是抽象类，还可以是具体类
• Lambda表达式：只能是接口

2.使用限制不同

• 如果接口中有且仅有一个抽象方法，可以使用Lambda表达式，也可以使用匿名内部类
• 如果接口中多于一个抽像方法，只能使用匿名内部类，而不能使用Lambda表达式

3.实现原理不同

• 匿名内部类：编译之后，产生一个单独的.class字节码文件
• Lambda表达式：编译之后，没有一个单独的.class字节码文件。对应的字节码会在运行的时候动态生成

2.接口组成更新概述

2.1接口组成

• 常量 public static final
• 抽象方法 public abstract
• 默认方法（Java8）
• 静态方法（Java9）
• 私有方法（Java9）

2.2接口中默认方法

接口中默认方法的定义格式：

• 格式：public default 返回值类型方法名（参数列表）{}
• 范例：public default void show(){}

接口中默认方法的注意事项：

• 默认方法不是抽象方法，所以不强制被重写。但是可以被重写，重写的时候去掉default关键字
• public可以省略，default不能省略

package demo_01;

public interface MyInterface {
    void show1();
    void show2();
    //接口中默认方法
    public default void show3(){
        System.out.println("MyInterface的私有方法");
    }
}

2.3接口中静态方法

接口中静态方法的定义格式：

• 格式：public static 返回值类型方法名（参数列表）{}
• 范例：public static void show(){}

接口中静态方法的注意事项：

• 静态方法只能通过接口名调用，不能通过实现类名或者对象名调用
• public可以省略，static不能省略

package demo_01;

public interface MyInterface {
    void show1();
    void show2();
    
    //接口中的静态方法(静态方法只能通过接口名调用 MyInterface.show4())
    public static void show4(){
        System.out.println("MyInterface的静态方法");
    }
}

2.4接口中的私有方法

接口中私有方法的定义格式：

• 格式1：private返回值类型方法名（参数列表）{}
• 范例1：private void show() {}
• 格式2：private static 返回值类型方法名（参数列表）{}
• 范例2：private static void method(){}

接口中私有方法的注意事项：

• 默认方法可以调用私有的静态方法和非静态方法
• 静态方法只能调用私有的静态方法

package demo_01;

public interface MyInterface {
    void show1();
    void show2();

    public default void show3(){
//        System.out.println("初级程序员");
//        System.out.println("中级程序员");
//        System.out.println("高级程序员");
        show5();
    }

    public static void show4(){
//        System.out.println("初级程序员");
//        System.out.println("中级程序员");
//        System.out.println("高级程序员");
        show5();
    }
    //接口中的私有方法
    private static void show5(){
        System.out.println("初级程序员");
        System.out.println("中级程序员");
        System.out.println("高级程序员");
    }
}

3.方法引用

3.1方法引用符

**方法引用符::**该符号为引用运算符，而它所在的表达式被称为方法引用

体验方法引用中的代码:

• Lambda表达式：usePrintable(s->System.out.println(s));
• 分析：拿到参数s之后通过Lambda表达式，传递给System.out.println方法去处理
• 方法引用：usePrintable(System.out::printIn);
• 分析：直接使用System.out中的println方法来取代Lambda,代码更加的简洁推导与省略
• 如果使用Lambda,那么根据“可推导就是可省略”的原则侧，无需指定参数类型，也无需指定的重载形式，它们都将被自动推导
• 如果使用方法引用，也是同样可以根据上下文进行推导
• 方法引用是Lambda的李生兄弟

//1.创建接口
package demo_01;

public interface Printable {
    void printInt(int i);
}

//2.测试类
package demo_01;

public class PrintableDemo {
    public static void main(String[] args) {
        //Lambda表达式调用
        usePrintable(i -> System.out.println(i));

        //方法引用
        usePrintable(System.out::println);
    }
    private static void usePrintable(Printable p){
        p.printInt(666);
    }
}

3.2 引用类方法

引用类方法，其实就是引用类的静态方法

• 格式：类名::静态方法

• 范例：Integer::parselnt

  Integer类的方法：public static int parselnt(String s)将此String转换为int类型数据

//1.
package demo_02;

public interface Converter {
    int convert(String s);
}

//2.
package demo_02;

public class ConverterDemo {
    public static void main(String[] args) {
    //Lambda表达式调用
        useConvert(s -> Integer.parseInt(s));

        useConvert((String s)->{
            int i = Integer.parseInt(s);
            return i;
        });

        //引用类方法
        useConvert(Integer::parseInt);

        //Lambda表达式被类方法替代的时候，他的形式参数全部传递给静态方法作为参数
    }
    private static void useConvert(Converter c){
        int result = c.convert("666");
        System.out.println(result);
    }
}

3.3引用对象的实例方法

引用对象的实例方法，其实就引用类中的成员方法

• 格式：对象::成员方法
• 范例：”HelloWorld”::toUpperCase
  String类中的方法：public String toUpperCase0将此String.所有字符转换为大写

//1.创建对象
package demo_03;

public class PrintString {
    public void printUpper(String s){
        //toUpperCase()把字符转化为大写
        String s1 = s.toUpperCase();
        System.out.println(s1);
    }
}
//2.创建接口
package demo_03;

public interface Printer {
    void printUpperCase(String s);
}
//3.测试类
package demo_03;

public class PrinterDemo {
    public static void main(String[] args) {
        //Lambda表达式
        usePrinter(s -> System.out.println(s.toUpperCase()));

        //引用对象的实例方法
        PrintString ps = new PrintString();
        usePrinter(ps::printUpper);

    }
    private static void usePrinter(Printer p){
        p.printUpperCase("helloword");
    }
}

3.4 引用类的实例方法

引用类的实例方法，其实就是引用类中的成员方法

• 格式：类::成员方法
• 范例：String::substring

//1.创建接口
package demo_04;

public interface MyString {
    String mySubString(String s,int x,int y);
}

//2.测试类
package demo_04;

public class MyStringDemo {
    public static void main(String[] args) {
        /*useMyString((String s,int x, int y)->{
             return s.substring(x, y);
        });*/

//        useMyString((s,x,y)->s.substring(x,y));

        //引用类的实例方法
        useMyString(String::substring);

    }
    private static void useMyString(MyString my){
        String s = my.mySubString("helloword", 2, 5);
        System.out.println(s);
    }
}

3.5 引用构造器

引用构造器，其实就是引用构造方法

• 格式：类::new
• 范例：Student::new

//1.创建接口
package demo_05;

public interface StudentBuilder {
    Student build(String name,int age);
}
//2.创建学生类
//3.测试类
package demo_05;

public class StudentDemo {
    public static void main(String[] args) {
        useStudentBuilder((name, age) -> new Student(name,age));

        //引用构造器
        useStudentBuilder(Student::new);

    }
    private static void useStudentBuilder(StudentBuilder sb){
        Student s1 = sb.build("张三", 18);
        System.out.println(s1.getName()+s1.getAge());
    }
}