文章目录

  • ​​1.1 Lambda表达式的标准格式​​
  • ​​1. 格式：​​
  • ​​2. 组成Lambda表达式的三要素：​​
  • ​​1.2 Lambda 使用示例​​
  • ​​1. 代码演示​​
  • ​​1.3 Lambda表达式的省略模式​​
  • ​​1. 省略的规则​​
  • ​​2. 代码演示​​
  • ​​1.4 Lambda表达式的注意事项​​
  • ​​1.5 Lambda表达式和匿名内部类的区别​​
  • ​​1. 所需类型不同​​
  • ​​2. 使用限制不同​​
  • ​​3. 实现原理不同​​

1.1 Lambda表达式的标准格式

1. 格式：

(形式参数) -> {代码块}
  1. 形式参数
  2. ->
  3. 代码块

2. 组成Lambda表达式的三要素：

  • 形式参数，箭头，代码块

1.2 Lambda 使用示例

  • 题目：启动一个线程，在控制台输出 ​​Hello World​​

1. 代码演示

  • Ⅰ，题解一：定义类并创建对象实现
  • ① 定义一个类 ​​MyRunnable​​​ 实现 ​​Runnable​​​ 接口，重写 ​​run()​​ 方法
  • ② 创建 ​​MyRunnable​​ 类的对象
  • ③ 创建 ​​Thread​​​ 类的对象，把 ​​MyRunnable​​ 的对象作为构造参数传递
  • ④ 启动线程
class MyRunnable implements Runnable{

    @Override
    public void run(){
        System.out.println("Hello World");
    }
}

public class Demo{
    public static void main(String[] args) {

        MyRunnable my = new MyRunnable();
        Thread thread = new Thread(my);
        thread.start();
    }
}
  • Ⅱ，题解二：匿名内部类的方式改进
public class Demo{
    public static void main(String[] args) {

        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("Hello World");
            }
        }).start();
    }
}
  • Ⅲ，题解三：Lambda 表达式的方式改进
public class Demo{
    public static void main(String[] args) {

       new Thread(() -> {
           System.out.println("Hello World");
       }).start();
    }
}

1.3 Lambda表达式的省略模式

1. 省略的规则

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

2. 代码演示

interface Add {
    int add(int x,int y);
}

interface Run {
    void run(String s);
}

public class Demo {

    private static void startAdd(Add a) {
        int sum = a.add(10,10);
        System.out.println(sum);
    }

    private static void startRun(Run r){
        r.run("Hello World");
    }

    public static void main(String[] args) {

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

        // 参数的类型可以省略
        startAdd((x,y)->{
            return x + y;
        });

        //如果代码块的语句只有一条，可以省略大括号和分号，如果有return，return也要省略掉
        startAdd((x,y)->x + y);

        //-----------------------------

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

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

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

1.4 Lambda表达式的注意事项

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

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

1. 所需类型不同

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

2. 使用限制不同

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

3. 实现原理不同

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