Lambda表达式

体验Lambda表达式
需求：启动一个线程，在控制台输出一句话：多线程程序启动了
方式1：

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

方式2：
匿名内部类的方式改进

方式3：
Lambda表达式的方式改进

Lambda表达式的标准格式
匿名内部类中重写run()方法的代码分析

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

Lambda表达式的代码分析

• ()：里面没有内容，可以看成是方法形式参数为空
• ->：用箭头指向后面要做的事情

new Thread(new Runnable(){
    @Override
    public void run(){
        System.out.println("多线程程序启动了")；
    }
}).start();
new Thread(()->{
    System.out.println("多线程程序启动了");
}).start();

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

Lambda表达式的格式：

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

Lambda表达式的练习
Lambda表达式的使用前提

• 有一个接口
• 接口中有且仅有一个抽象方法

练习1：

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

练习2：

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

练习3：

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

Lambda表达式的省略模式

package Java;

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

package Java;

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

package Java;

public class LambdaDemo {
    public static void main(String[] args){
    //    useAddable((int x,int y)->{
    //        return x+y;
    //    });
        //参数类型可以省略
        useAddable((x,y)->{
            return x+y;
        });
        //但是有多个参数的情况下，不能只省略一个
    }

    private static void useFlyable(Flyable f){
        f.fly("风和日丽，晴空万里");
    }

    private static void useAddable(Addable a){
        int sum=a.add(10,20); 
        System.out.println(sum);
    }
}

终端：
30

package Java;

public class LambdaDemo {
    public static void main(String[] args){
        //参数类型可以省略
        useAddable((x,y)->{
            return x+y;
        });
        //但是有多个参数的情况下，不能只省略一个
    
        //useFlyable((String s)->{
        //    System.out.println(s);
        //});
        //如果参数有且仅有一个，那么小括号可以省略
        //useFlyable(s->{
        //    System.out.println(s);
        //});
        //如果代码块的语句只有一条，可以省略大括号和分号，如果有return，return也要省略掉
        useFlyable(s-> System.out.println(s));
    }
    private static void useFlyable(Flyable f){
        f.fly("风和日丽，晴空万里");
    }

    private static void useAddable(Addable a){
        int sum=a.add(10,20); 
        System.out.println(sum);
    }
}

终端：
30
风和日丽，晴空万里

Lambda表达式的注意事项
注意事项：

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

Lambda表达式和匿名内部类的区别
所需类型不同

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

使用限制不同

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

实现原理不同

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