Lambda 表达式 和 方法引用

 一 、 Lambda 表达式

interface  TestInterface{
    void test(String s);
}

class TestInterfaceInstance implements TestInterface{

    @Override
    public void test(String s) {
        System.out.println("子类实现testInterface"+s);
    }
}

public class Lambda {

    public static void main(String[] args) {
        // 1、正常写法
        TestInterfaceInstance t1 = new TestInterfaceInstance();
        t1.test("s");

        // 2、正常写法 - 多态形式（父类引用指向子类对象）
        TestInterface t2 = new TestInterfaceInstance();
        t2.test("s");

        // 3、匿名内部类
        TestInterface t3 = new TestInterface() {  // 因为TestInterface是接口，不能new，所以，用{}表示TestInterface的子类实现
            @Override
            public void test(String s) {
                System.out.println("子类实现testInterface"+s);
            }
        };
        t3.test("s");

        // 4、 Lambda（匿名内部类的简化版）
        TestInterface t4 = (s)->{
            System.out.println("子类实现testInterface"+s);
        };
        t4.test("s");
        // 5、Lambda 简化版
        TestInterface t5 = s-> System.out.println("子类实现testInterface"+s);
        t5.test("s");


        // Lambda 允许把函数作为一个方法的参数。
        Lambda lambda = new Lambda();
        lambda.testMethod(s -> {
            System.out.println("子类实现testInterface"+s);
        }); // 需要传入一个对象，
    }

    public void testMethod(TestInterface testInterface){ // 传入的不是接口，而是一个子类（多态的效果，子类对象执行的test方法）
       testInterface.test("s");
    }
}

二、Lambda 方法引用

interface  Demo{
    int method(String s);
}

public class Lambda2 {
    public static void main(String[] args) {
        // 匿名内部类
        Demo demo1 = new Demo() { // new Demo() 是个接口，不能new，只能用{}表示是Demo的子类
            @Override
            public int method(String s) {
                return Integer.parseInt(s);  // method方法不能把 String s  转换为 int ，于是，借助了Integer.parseInt（）方法
                // return new Integer（s）;
            }
        };

        // 1、Lambda表示式
        Demo demo2 = (s)->{
            return Integer.parseInt(s);
        };

        // 2、Lambda表示式 - 优化（Lambda表示式 中对应的子类 方法中 只有一行代码）
        Demo demo3 = s-> Integer.parseInt(s);

        // 3、Lambda表示式  - 再优化
            /**
             * 条件一：Lambda表示式对应的这一行代码，
             * 条件二：这一行代码不是我们自己要写的逻辑，引用了别的类现成的方法）
             * 可以利用 方法引用 ::  来再优化
             */
        Demo demo4 = Integer::parseInt;  // 表示 使用的是Integer 下的 parseInt 方法

        // 如果引用了构造方法  return new Integer（s）;
        Demo demo5 = Integer::new;       // 表示 使用的是Integer 下的 构造方法 方法
    }
}