19.lambda表达式

Lambda表达式

lambda表达式体现的是函数编程思想

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

方式一:

• 定义MyRunnable类实现Runnable接口, 重写run方法
• 创建Thread类, 将MyRunable的对象作为构造参数
• 启动线程

方式二:

• 匿名内部类的方式改进

方式三:

• Lambda表达式的方式改进

MyRunnable

package myLambda;

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

LambdaDemo

package myLambda;

public class LambdaDemo {
    public static void main(String[] args) {
        // 实现类的方式实现需求
        /*
        MyRunnable my = new MyRunnable();
        Thread t = new Thread(my);
        t.start();
         */

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

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

Lambda表达式标准格式

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

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

Lambda表达式的代码分析

• (): 里面没有内容, 可以看成是方法形式参数为空

• ->: 箭头指向后面要做的事情

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

组成lambda表达式三要素: 形式参数, 箭头, 代码块

lambda表达式格式

• 格式: (形式参数) -> {代码块}
• 形式参数: 如果有多个参数, 参数之间用逗号隔开; 如果没有参数, 留空即可
• ->: 由英文中画线和大于符号组成, 固定写法,
• 代码块: 是具体要做的事情, 也就是以前我们写的方法体内容

练习

不带参数

Eatable

package myLambda.demo;

public interface Eatable {
    void eat();
}

EatableImpl

package myLambda.demo;

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

EatableDemo

package myLambda.demo;

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();
    }
}

带参数

Flyable

package myLambda.demo2;

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

FlyableDemo

package myLambda.demo2;

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("飞机自驾游");
            }
        });

        // lambda表达式带参数
        useFlyable((String s) -> {
            System.out.println(s);
            System.out.println("飞机自驾游");
        });
    }
    private static void useFlyable(Flyable f) {
        f.fly("风和日丽");
    }
}

多个参数

Addable

package myLambda.demo3;

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

AddableDemo

package myLambda.demo3;

public class AddableDemo {
    public static void main(String[] args) {
        // lambda表达式实现, 多参数
        useAddable((int x, int y) -> {
            // return x + y;
            return x - y;  // 这里是方法add的具体实现代码块
        });
    }

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

lambda省略模式

省略规则

• 参数类型可以省略, 多个参数类型不能单独省略一个
• 如果参数仅有一个, 小括号可以省略
• 如果代码块只有一句, 可以省略大括号和分号, 甚至是return

Addable

package myLambda.demo4;

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

Flyable

package myLambda.demo4;

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

LambdaDemo

package myLambda.demo4;

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

        // 有多个参数时, 不能单独省略一个, 要么都省略,要么都不省略

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

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

        // 省略模式二: 如果参数只有一个, 可以省略小括号
        useFlyable(s -> {
            System.out.println(s);
        });

        // 省略模式三: 如果代码块语句只有一条, 可以省略大括号和分号
        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);
    }
}

lambda表达式注意事项

注意:

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

Inter

package myLambda.demo5;

public interface Inter {
    void show();
    // void method();
}

LambdaDemo

package myLambda.demo5;

public class LambdaDemo {
    public static void main(String[] args) {
        /*
        useInter(() -> {
            System.out.println("好好学习, 天天向上");
        });
         */

        // lambda表达式前提: 必须有接口, 并且接口中有且只有一个抽象方法
        useInter(() -> System.out.println("好好学习, 天天向上"));

        // 使用lambda, 必须有上下文环境, 才能推导出lambda对应的接口
        /*
        new Thread((new Runnable() {
            @Override
            public void run() {
                System.out.println("匿名内部类");
            }
        })).start();

        Runnable r = () -> System.out.println("lambda表达式");
        new Thread(r).start();
         */

        new Thread(() -> System.out.println("lambda表达式")).start();
    }

    private static void useInter(Inter i) {
        i.show();
    }
}

lambda表达式和匿名内部类区别

所需类型不同:

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

使用限制不同:

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

实现原理不同:

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

Animal

package myLambda.demo6;

public abstract class Animal {
    public abstract void method();
}

Inter

package myLambda.demo6;

public interface Inter {
    void show();
    // void show2();
}

Student

package myLambda.demo6;

public class Student {
    public void study() {
        System.out.println("热爱生活!");
    }
}

Demo

package myLambda.demo6;

public class Demo {
    public static void main(String[] args) {
        // 匿名内部类
        useInter(new Inter() {
            @Override
            public void show() {
                System.out.println("接口");
            }
        });

        useAnimal(new Animal() {
            @Override
            public void method() {
                System.out.println("抽象类");
            }
        });

        useStudent(new Student(){
            @Override
            public void study() {
                System.out.println("具体类");
            }
        });

        // lambda方式
        // useInter(() -> System.out.println("接口"));

        // useAnimal(() -> System.out.println("抽象类"));  // lambda必须是一个接口
        // useStudent(() -> System.out.println("具体类"));  // lambda必须是一个接口

        // 接口中有多个抽象方法
        /*
        useInter(new Inter() {
            @Override
            public void show() {
                System.out.println("show");
            }

            @Override
            public void show2() {
                System.out.println("show2");
            }
        });
         */
    }

    private static void useStudent(Student s) {
        s.study();
    }

    private static void useAnimal(Animal a) {
        a.method();
    }

    private static void useInter(Inter i) {
        i.show();
    }
}