Lambda表达式

Lambda表达式：函数式编程思想，重点关注做什么！
lambda表达式本质是实现该接口,下面例子中所有的 @Override 都是lambda的等价形式（具体实现形式）

Lambda表达式的使用前提
1）有一个接口（不能是类）
2）接口中有且只有一个抽象方法

练习1：
1、编写一个接口（ShowHandler）
2、在该接口中有一个抽象方法show，该方法无参数无返回值
3、在测试类（ShowhandlerDemo）中存在一个方法（useShowHandler）,方法的参数是ShowHandler类型的，在方法内部调用了ShowHandler的show方法。

public class Testlamba {

    public static void main(String[] args) {

        useShowHandler(new ShowHandler() {
            @Override
            public void show() {
                System.out.println("我是匿名内部类里的show方法");
            }
        });

        //lambda实现
        useShowHandler(() -> {
            System.out.println("我是lambda里的show方法");
        });

    }

    public static void useShowHandler(ShowHandler showHandler) {
        showHandler.show();
    }
}

interface ShowHandler {
    void show();
}

练习2：带参数无返回值----------lambda的（）里也要有对应的参数
1、首先存在一个接口（StringHandler）
2、在该接口中存在一个抽象方法（pringMessage），该方法是有参数无返回值
3、在测试类StringHanderDemo中存在一个方法(userStringHandler)方法的参数是StringHandler类型的在方法内部调用了StringHandler的pringMessage方法

public class StringHanderDemo {

    public static void main(String[] args) {
        userStringHandler(new StringHandler() {
            @Override
            public void pringMessage(String message) {
                System.out.println("我是匿名内部类：" + message);
            }
        });

        //使用lambda
        userStringHandler((String message) -> {
            System.out.println("我是lambda表达式：" + message);
        });

    }

    private static void userStringHandler(StringHandler stringHandler) {
        stringHandler.pringMessage("itheima");
    }
    
}

interface StringHandler {
    void pringMessage(String message);
}

练习3：无参数有返回值
注意：如果lambda所操作的接口中的方法，有返回值，一定要通过return语句将结果返回，否则会出现编译错误
1、首先存在一个接口（RandomNumHander）
2、在该接口中存在一个抽象方法（getNumber），该方法是无参数有返回值
3、在测试类RandomNumHanderDemo中存在一个方法(userRandomNumHander)方法的参数是RandomNumHander类型的
在方法内部调用了RandomNumHander的getNumber方法

public class RandomNumHanderDemo {

    public static void main(String[] args) {
        userRandomNumHander(new RandomNumHander() {
            @Override
            public int getNumber() {
                Random r = new Random();
                int num = r.nextInt(10) + 1;
                return num;
            }
        });
        //lambda
        userRandomNumHander(() -> {
            Random r = new Random();
            int num = r.nextInt(10) + 1;
            return num;
        });
    }
    private static void userRandomNumHander(RandomNumHander randomNumHander) {
        int number = randomNumHander.getNumber();
        System.out.println(number);
    }
}
interface RandomNumHander {
    int getNumber();
}

练习4：带参数带返回值
1、首先存在一个接口（Calculator）
2、在该接口中存在一个抽象方法（calc），该方法是带参数有返回值
3、在测试类CalculatorDemo中存在一个方法(userCalculator)
方法的参数是Calculator类型的在
方法内部调用了Calculator的calc方法

    public static void main(String[] args) {

        userCalculator(new Calculator() {
            @Override
            public int calc(int a, int b) {
                return a + b;
            }
        });
       //lambda
        userCalculator((int a, int b) -> {
            return a + b;
        });
    }

    private static int userCalculator(Calculator calculator) {
        int result = calculator.calc(10, 20);
        System.out.println(result);
        return result;
    }

}

interface Calculator {
    int calc(int a, int b);
}

Lambda表达式的省略模式：
1、参数类型可以省略，但是有多个参数的情况下，不能只省略一个
2、如果参数有且仅有一个，小括号可以省略(没有参数也不能省！)
3、如果代码块的语句只有一条，可以省略大括号和分号，甚至是return！

Lambda表达式和匿名内部类的区别：
所需类型不同：
匿名内部类：可以是接口、也可以是抽象类、具体类
lambda表达式：只能是接口
使用限制不同：
如果接口中有且只有一个接口且接口只有一个抽象方法，可以使用lambda表达式，也可以使用匿名内部类。
如果接口中多于一个抽象方法，只能使用匿名内部类！
实现原理不同：
匿名内部类：编译之后，产生一个单独的.class字节码文件。
lambda表达式：编译之后，没有一个单独的.class字节码文件。对应的字节码会在运行时动态生成。