Lambda表达式

对于函数式接口，我们可以通过Lambda表达式来创建该接口的对象。
λ是希腊字母表中排序第十一位的字母，英语名称为Lambda，Lambda表达式其实质属于函数式编程的概念。

（params）-> expression [ 表达式 ]
（params）-> statement [ 语句 ]
（params）-> { statements }

为什么要用Lambda表达式？

避免匿名内部类定义过多
去掉了一堆没有意义的代码，只留下核心的逻辑，看起来更简洁
案例演示1
外部类、成员内部类、局部内部类、匿名内部类、Lambda表达式

interface Like{//函数式接口：只有一个抽象方法
    void like();
}
//1.外部类
class Like1 implements Like{
    @Override
    public void like() {
        System.out.println("I like lambda1");
    }
}

public class MyTest {
    //2.成员内部类
    private static class Like2 implements Like{
        @Override
        public void like() {
            System.out.println("I like lambda2");
        }
    }

    public static void main(String[] args) {
        Like l = new Like1();
        l.like();
        l = new Like2();
        l.like();
        //3.局部内部类
        class Like3 implements Like{
            @Override
            public void like() {
                System.out.println("I like lambda3");
            }
        }
        l=new Like3();
        l.like();

        //4.匿名内部类
        l=new Like() {
            @Override
            public void like() {
                System.out.println("I like lambda4");
            }
        };
        l.like();

        //5.lambda表达式
        l=()->{
            System.out.println("I like lambda5");
        };
        l.like();
        //也可以写成：
        //l=()-> System.out.println("I like lambda5");
        //l.like();

    }
}

 

案例演示2
抽象方法带参数的Lambda表达式；Lambda表达式的一步步简化

interface Like{//函数式接口：只有一个抽象方法
    void like(int a);
}
//1.外部类
class Like1 implements Like{
    @Override
    public void like(int a) {
        System.out.println("I like lambda"+a);
    }
}

public class MyTest {
    //2.成员内部类
    private static class Like2 implements Like{
        @Override
        public void like(int a) {
            System.out.println("I like lambda"+a);
        }
    }

    public static void main(String[] args) {
        Like l = new Like1();
        l.like(1);
        l = new Like2();
        l.like(2);
        //3.局部内部类
        class Like3 implements Like{
            @Override
            public void like(int a) {
                System.out.println("I like lambda"+a);
            }
        }
        l=new Like3();
        l.like(3);

        //4.匿名内部类
        l=new Like() {
            @Override
            public void like(int a) {
                System.out.println("I like lambda"+a);
            }
        };
        l.like(4);

        //5.lambda表达式
        l=(int a)->{
            System.out.println("I like lambda"+a);
        };
        l.like(5);

        //6.简化lambda表达式：去掉参数类型
        l=(a)-> {
            System.out.println("I like lambda"+a);
        };
        l.like(6);

        //7.简化lambda表达式：去掉括号
        l=a-> {
            System.out.println("I like lambda"+a);
        };
        l.like(7);

        //8.简化lambda表达式：去掉花括号（前提：抽象方法的逻辑只有一行）
        l=a->System.out.println("I like lambda"+a);
        l.like(8);
    }
}

 

案例演示3
抽象方法有多个参数的Lambda表达式

interface Like{//函数式接口：只有一个抽象方法
    void like(int a,int b,int c);
}
//1.外部类
class Like1 implements Like{
    @Override
    public void like(int a,int b,int c) {
        System.out.println("I like lambda"+a+b+c);
    }
}

public class MyTest {
    //2.成员内部类
    private static class Like2 implements Like{
        @Override
        public void like(int a,int b,int c) {
            System.out.println("I like lambda"+a+b+c);
        }
    }

    public static void main(String[] args) {
        Like l = new Like1();
        l.like(1,1,1);
        l = new Like2();
        l.like(2,2,2);
        //3.局部内部类
        class Like3 implements Like{
            @Override
            public void like(int a,int b,int c) {
                System.out.println("I like lambda"+a+b+c);
            }
        }
        l=new Like3();
        l.like(3,3,3);

        //4.匿名内部类
        l=new Like() {
            @Override
            public void like(int a,int b,int c) {
                System.out.println("I like lambda"+a+b+c);
            }
        };
        l.like(4,4,4);

        //5.lambda表达式
        l=(int a,int b,int c)->{
            System.out.println("I like lambda"+a+b+c);
        };
        l.like(5,5,5);

        //6.简化lambda表达式：去掉参数类型
        l=(a,b,c)-> {
            System.out.println("I like lambda"+a+b+c);
        };
        l.like(6,6,6);

        //7.简化lambda表达式：去掉花括号（前提：抽象方法的逻辑只有一行）
        l=(a,b,c)->System.out.println("I like lambda"+a+b+c);
        l.like(7,7,7);

    }
}

总结：

要使用Lambda表达式，前提是接口必须是函数式接口
抽象方法的逻辑只有一行的情况下，Lambda表达式才能去掉花括号
多个参数的情况下，也能去掉参数类型，要去掉就都去掉，但是括号不能去掉