Lambda 表达式简单演化（原始的方法调用，一步步简化成 lambda 表达式的过程）

Lambda 表达式简单演化

函数式接口的定义：

1、任何接口，如果只包含唯一一个抽象方法，那么它就是一个函数式接口。

2、对于函数式接口，我们可以通过 lambda 表达式来创建该接口的对象。

原始的方法调用，一步步简化成 lambda 表达式的过程

原始接口方法没有参数的演示—示例 1

具体代码

//原始的方法调用，一步步简化成 lambda 表达式的过程
public class TestLambda01 {

    //4、第一次优化-->静态内部类（把实现类放到静态内部类里面即可）=========类名是Like2
    static class Like2 implements ILike{
        @Override
        public void studyLambda() {
            System.err.println("复习lambda-----静态内部类---02");
        }
    }



    
    public static void main(String[] args) {
    	//3、最原始的调用一个实现类的方法========================
        Like like = new Like();
        like.studyLambda();



        //4、-----测试----------========================
        Like2 like2 = new Like2();
        like2.studyLambda();



        //5、第二次优化-----> 局部内部类=====================类名是Like3
        class Like3 implements ILike{
            @Override
            public void studyLambda() {
                System.err.println("复习lambda-----局部内部类---03");
            }
        }

        Like3 like3 = new Like3();
        like3.studyLambda();
        

        //6、第三次优化--->匿名内部类，没有类的名称，必须借助接口或者父类-----没有类名=======
        //iLike 不是类名，而是一个对象的引用变量名
        ILike iLike = new ILike() {
            @Override
            public void studyLambda() {
                System.err.println("复习lambda-----匿名内部类---04");
            }
        };

        iLike.studyLambda();



        //7、第四次优化---> 用 Lambda 简化
        iLike = () -> {
            System.err.println("复习lambda-----Lambda 简化版本---05");
        };

        iLike.studyLambda();


    }
}

//1、定义一个函数式接口
interface ILike {
    void studyLambda();
}

//2、实现类
class Like implements ILike{
    @Override
    public void studyLambda() {
        System.err.println("复习lambda-----原始实现类里面的方法---01");
    }
}

原始接口方法携带参数的演示—示例 2

和上面的演示一样，只不过这次方法加了参数而已

具体方法

//原始的方法调用，一步步简化成 lambda 表达式的过程
public class TestLambda02 {

    //1、第一次优化-->静态内部类（把实现类放到静态内部类里面即可）=========类名是 Love01
    static class Love01 implements ILove {
        //实现接口方法
        @Override
        public void love(int a,int b) {
            System.err.println("实现接口的love方法------>" + a + " - " + b);
        }
    }

    public static void main(String[] args) {

        //最原始的调用一个实现类的方法========================
        Love love = new Love();
        love.love(0,0);

        Love01 love01 = new Love01();
        love01.love(22,222);


        //2、匿名内部类--- ilove 不是类名，而是一个对象的引用变量名
        ILove ilove = new ILove(){
            @Override
            public void love(int a, int b) {
                System.err.println("实现接口的love方法------>" + a + " - " + b);
            }
        };
        ilove.love(66,666);


        //直接简化成 lambda

        ilove = (a,b)->{
            System.err.println("简化成 lambda 表达式------>" + a + " - " + b);
        };
        ilove.love(99,999);
        
    }
}

//接口
interface ILove {
    void love(int a,int b);
}

//实现类
class Love implements ILove {
    //实现接口方法
    @Override
    public void love(int a,int b) {
        System.err.println("实现接口的love方法------> " + a + " - " + b);
    }
}