Lambda表达式的来源和用法

Lambda表达式简介

• 入希腊字母表中排序第十一位的字母，英语名称为Lamda
• 避免匿名内部类定义过多
• 其实质属于函数式编程的概念
• lambda是java8的新特性

a-> System.out.println("i like java-->" + a)

为什么要使用lamdba表达式

• 避免匿名内部类定义过多
• 可以使代码看起来更简洁
• 去掉了没有意义的代码，只留下了核心的逻辑

理解 Functional Interface(函数式接口)是学习lambda表达式的基础

函数式接口

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

对于函数式接口，可以通过lambda表达式来创建接口的对象

public interface Runnable{
    public abstract void run();
}

代码实现

public class TestLambda01 {
    //3、静态内部类
   static class Like2 implements IlikeJava{
        @Override
        public void lambda() {
            System.out.println("第二次输出lambda");
        }
    }

    public static void main(String[] args) {

        IlikeJava like = new Like();
        like.lambda();

        Like2 like2 = new Like2();
        like2.lambda();

        //4、局部内部类
        class Like3 implements IlikeJava{
            @Override
            public void lambda() {
                System.out.println("第三次输出lambda");
            }
        }
        Like3 like3 = new Like3();
        like3.lambda();

        //5、匿名内部类  没有类的名称，必须借助接口或者父类
        like = new IlikeJava() {
            @Override
            public void lambda() {
                System.out.println("第四次输出lambda");
            }
        };
        like.lambda();

        //6、用lambda表达式简化
        like = ()->{System.out.println("第五次输出lambda");};
        like.lambda();

    }
}
//1、定义一个函数式接口
interface IlikeJava{
    void lambda();
}
//2、定义一个实现类
class Like implements IlikeJava{
    @Override
    public void lambda() {
        System.out.println("第一次输出lambda");
    }
}

public class TestLambda02 {
//3、静态内部类
    static class Love2 implements ILove {
        @Override
        public void love(int a) {
            System.out.println("第二次执行"+a);
        }
    }
    public static void main(String[] args) {
        ILove love1 = new Love();
        love1.love(111);
        Love2 love2 = new Love2();
        love2.love(222);
        
        ILove love3 = new Love();
        ILove love4 = new Love();
        ILove love5 = new Love();
        ILove love6 = new Love();
        ILove love7 = new Love();

        //4、匿名内部类
        love3 = new ILove() {
            @Override
            public void love(int a) {
                System.out.println("第三次执行"+a);
            }
        };

        love3.love(333);

        //5、lambda表达式版
        love4 = (int a)-> {System.out.println("第四次执行"+a);};
        love4.love(444);

        //6、简化去掉参数类型
        love5 = (a)-> {System.out.println("第五次执行"+a);};
        love5.love(555);


        //7、简化去掉括号
        love6 = a-> {System.out.println("第六次执行"+a);};
        love6.love(666);

        //8、简化去掉大括号
        love7 = a-> System.out.println("第七次执行"+a);
        love7.love(777);

        }



    }

//1、定义一个接口
interface ILove {
    void love(int a);
}
//2、实现类
class Love implements ILove {
    @Override
    public void love(int a) {
        System.out.println("第一次执行"+a);
    }
}