正文

Lambda表达式的标准格式

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

方法形式参数为空，说明调用方法时不需要传递参数
方法返回值类型为void，说明方法执行没有结果返回

方法体中的内容，是我们具体要做的事情

Lambda表达式的代码分析

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

{}:包含一段代码，我们称之为代码块，可以看成是方法体中的内容

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

Lambda表达式的格式

格式:(形式参数)->{代码块}
形式参数:如果有多个参数，参数之间用逗号隔开;如果没有参数，留空即可

->:由英文中画线和大于符号组成，固定写法。代表指向动作
代码块:是我们具体要做的事情，也就是以前我们写的方法体内容

Lambda表达式的省略模式

省略规则:

参数类型可以省略。但是有多个参数的情况下，不能只省略一个
如果参数有且仅有一个，那么小括号可以省略

如果代码块的语句只有一条，可以省略大括号和分号，甚至是return

Lambda表达式的注意事项

注意事项:

使用Lambda必须要有接口，并且要求接口中有且仅有一个抽象方法
必须有上下文环境，才能推导出Lambda对应的接口

- 根据局部变量的赋值得知Lambda对应的接口: Runnabler = ) -> System.out.printIn("MLambda表达式");
- 根据调用方法的参数得知Lambda对应的接口: new Thread()->System.out.printIn("Lambda表达式")).start();

package Lambda;
//需求：启动一个线程，在控制台输出一句话：多线程程序启动了
/*
方式一
	1.定义一个MyRunnable实现Runnable接口，重写run（）方法
	2.创建MyRunnable类的对象
	3.创建Thead类的对象，把MyRunnable的对象作为构造参数来传递
	4.启动线程
方式二：匿名内部类的方式改进
方式三：Lambda表达式的方式改进
*/
public class LambdaDome {
    public static void main(String[] args) {

        //实现类方式实现需求
/*        MyRunnable mr = new MyRunnable();
        Thread t = new Thread(mr);
        t.start();*/

        //匿名内部类的方式改进
        //匿名内部类的话，每次开启一个线程都要重写一次也不方便
/*        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("多线程程序启动了！");
            }
        }).start();*/

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

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

        //如果参数有且仅有一个，那么小括号可以省略
        useFlyable( s ->{
            System.out.println(s);
        });
        //如果代码块的语句只有一条，可以省略大括号和分号
        useFlyable( s -> System.out.println(s));
        //如果代码块的语句只有一条，可以省略大括号和分号,如果有return，return也要省掉
        useAddable((x,y)-> x+y);
        //使用Lambda必须要有接口，并且要求接口中有且仅有一个抽象方法
        useFlyable(s-> System.out.println("*****"));
        //必须有上下文环境，才能推导出lambda对应的接口
        useFlyable(new Flyable() {
            @Override
            public void fly(String s) {
                System.out.println("艹");
            }
        });

        Flyable r = s -> System.out.println("***!");
        useFlyable(r);

        useFlyable(s-> System.out.println("**"));

    }
    public static void useFlyable(Flyable f){
        f.fly("口吐芬芳");
    }
    public static void useAddable(Addable a){
        int sum = a.add(66, 99);
        System.out.println(sum);
    }
}

Lambda表达式的练习——抽象方法无参无返回值

Lambda表达式的使用前提

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

package Lambda;

/*Lambda表达式的格式：（形式参数）-> {代码块}
练习一：
        1.定义一个接口（Eatable），里面定义一个抽象方法void eat（）；
        2.定义一个测试类（EatableDemo），在测试类中提供两个方法
            useEatable（Eatable e）
            主方法，在主方法中调用useEatable方法*/
public class EatableDemo {
    public static void main(String[] args) {
//        接口（ Interface ）不能直接实例化，即new一个接口是错误的。
//        只能通过xxx类 implemets XXX接口 来实现接口方法。
//        匿名内部类拓展https://www.pianshen.com/article/1973312680/

        //在主方法中调用useEatable方法（还是用了匿名内部类）
        Eatable e = new Eatable(){
            @Override
            public void eat() {
                System.out.println("hello");
            }
        };
        useEatable(e);

//        匿名内部类
//        不是new了接口，相当于new了一个匿名的接口实现类，再重写方法
        useEatable(new Eatable() {
            @Override
            public void eat() {
                System.out.println("world");
            }
        });

        //Lambda表达式
        useEatable(()->{
            System.out.println("java");
        });
    }
    public static void useEatable(Eatable e){
        e.eat();
    }
}

package Lambda;

public interface Eatable {
        void eat();
    }

Lambda表达式的练习——抽象方法带参无返回值

package Lambda;
/*
练习二：
1.定义一个接口（Flyable），里面定义一个抽象方法：void fly（String s）
2.定义一个测试类（FlyableDemo），在测试类中提供两个方法
        useFlyable（flyable f）
        主方法，在主方法中调用useFlyable方法
*/
public class FlyableDemo {
    public static void main(String[] args) {
        useFlyable((f)->{
            System.out.println(f);
        });
    }
    public static void useFlyable(Flyable f){
        f.fly("10月20日");

    }
}

package Lambda;

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

Lambda表达式的练习——抽象方法无参带返回值

package Lambda;
/*
练习三：
1.定义一个接口（Addable）里面定义一个抽象方法:int add(int x,int y)
2.定义一个测试类（AddableDemo）在测试类中提供两个方法
        useAddable（Addable a）
        主方法，在主方法中调用useAddable方法
*/
public class AddableDemo {
    public static void main(String[] args) {

        useAddable((x,y)->{
            return x+y;
        });

    }
    public static void useAddable(Addable a){
        int sum = a.add(5, 6);
        System.out.println(sum);
    }
}

package Lambda;

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

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

所需类型不同

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

使用限制不同

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

实现原理不同

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

发现问题及解决方案

接口和抽象类不可以被new！
这是匿名内部类，只是一种写法上的迷惑而已。
new 一个接口，可以这样写，运行也不会报错，但运行本质是：编译器帮我们自动生成的一个继承或实现了该接口/抽象类的匿名内部类（所谓匿名只是对开发人员匿名，而非对虚拟机匿名），然后才能在虚拟机上运行，只是编译器帮我们做了这些工作，从原理上并不能说“接口/抽象类可以被new出来

拓展

命名没有要求是任意的，与下面的方法没有关系

总结

Lambda表达式是新学习的一种语法格式，他简化了代码，所以用起来还是很方便的，相比较匿名内部类又节省了空间，重点是一定要注意书写Lambda表达式的限制条件

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