十七、Java8新特性——Lambda表达式【黑马JavaSE笔记】

Lambda表达式

（一）体验Lambda表达式

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

代码演示：

public class LambdaDemo {
    public static void main(String[] args) {
        //匿名内部类改进
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("多线程程序启动了");
            }
        }).start();

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

（二）lambda表达式的标准格式

（三）Lambda表达式的练习

Lambda表达式的使用前提

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

练习一：抽象方法无参无返回值

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

代码实现：

定义一个接口（Eatable）

package TEMP.TEMP30;

public interface Eatable {
    void eat();
}

定义接口的实现类：

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

定义测试类：

public class EatableDemo {
    public static void main(String[] args) {
        //在主方法中调用useEatable()方法
        Eatable e = new EatableImpl();
        useEatable(e);

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

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

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

练习二：抽象方法带参无返回值

定义接口：

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

定义接口实现类：

public class FlyableImpl implements Flyable {
    @Override
    public void fly(String s) {
        System.out.println(s + "飞起来了");
    }
}

定义测试类：

public class FlyableDemo {
    public static void main(String[] args) {
        //调用useFlyable方法
        Flyable f = new FlyableImpl();
        useFlyable(f, "狗");

        //匿名内部类
        useFlyable(new Flyable() {
            @Override
            public void fly(String s) {
                System.out.println(s + "飞起来了");
            }
        }, "猫");

        //lambda表达式改进
        useFlyable((String s) -> {
            System.out.println(s + "飞起来了");
        }, "鱼");
    }

    private static void useFlyable(Flyable f, String s) {
        f.fly(s);
    }
}

练习三：抽象方法带参带返回值

定义接口：

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

定义测试类：

public class AddableDemo {
    public static void main(String[] args) {
        //lambda方法
        useAddable((int x, int y) -> {
           return x + y;
        });
    }

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

（四）Lambda表达式的省略模式

省略规则：

• 参数类型可以省略，但有多个参数的情况下不能只省略一个
• 如果参数有且仅有一个，那么可以省略小括号
• 如果代码块的语句只有一条，可以省略大括号和分号，如果这一条语句有return，想要省略的话return必须要省略掉

（五）Lambda表达式的注意事项

注意事项：

• 使用Lambda必须要有接口，并且要求接口中有且仅有一个抽象方法

• 必须要有上下文环境，才能推导出Lambda对应的接口

  ​ 根据局部变量的赋值得知Lambda对应的接口：Runnable r = () -> System.out.println(“Lambda表达式”);

  ​ 根据调用方法的参数得知Lambda对应的接口：new Thread(() -> System.out.println(“Lambda表达式”))

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