Lambda表达式的使用

函数式接口：

如果一个接口中只有一个抽象方法，那么它就是函数式接口。
对于函数式接口我们可以通过Lambda表达式创建该接口对象。

Lambda表达式：

1. 以下为Lambda表达式的"进化"之路 :

① 首先定义一个函数式接口：

// 1. 定义一个函数式接口
interface Lambda{
    void like();
}

② 平时正常使用这个接口，我们是在外面定义它的实现类，再在主函数中创建该实现类对象，然后通过实现类对象调用方法。

public class TestLambda {
    public static void main(String[] args) {
        iLambda1 iLambda1 = new iLambda1();
        iLambda1.like();
    }
}

// 2. 定义实现类
class iLambda1 implements Lambda{

    @Override
    public void like() {
        System.out.println("I like lambda1");
    }
}

运行结果：

I like lambda1

③ 也可以主类里面创建静态内部类实现接口，再在主函数中创建该静态内部类对象，然后通过该对象调用方法。

public class TestLambda {
    // 3. 静态内部类
    static class iLambda2 implements Lambda{

        @Override
        public void like() {
            System.out.println("I like lambda2");
        }
    }
    public static void main(String[] args) {
        iLambda2 iLambda2 = new iLambda2();
        iLambda2.like();
    }
}

运行结果：

I like lambda2

④ 或者在主方法中里面创建局部内部类实现接口，再在主函数中创建该局部内部类对象。

public class TestLambda {
    public static void main(String[] args) {
        // 4. 局部内部类：即把类写在方法中
        class iLambda3 implements Lambda{

            @Override
            public void like() {
                System.out.println("I like lambda3");
            }
        }

        iLambda3 iLambda3 = new iLambda3();
        iLambda3.like();
    }
}

运行结果：

I like lambda3

⑤ 创建匿名内部类实现接口

public class TestLambda {
    public static void main(String[] args) {
        // 5. 匿名内部类：没有类的名称，必须借助接口或父类
        Lambda lambda = new Lambda() {
            @Override
            public void like() {
                System.out.println("I like lambda4");
            }
        };
        lambda.like();
    }
}

运行结果：

I like lambda4

⑥ 使用Lambda表达式来简化操作

public class TestLambda {
    public static void main(String[] args) {
       // 6. Lambda表达式
        Lambda lambda1 = ()->{
            System.out.println("I like lambda5");
        };
        lambda1.like();
    }
}

运行结果：

I like lambda5

2. Lambda表达式的扩展 :

① 如果接口中的方法带参数：

public class TestLambda2 {
    public static void main(String[] args) {
        Like like = (int a)->{
            System.out.println("我的幸运数字是"+a);
        };
        like.ilike(5);

        // 可以省略参数类型
        like = (a)->{
            System.out.println("我的幸运数字是"+a);
        };
        like.ilike(6);

        //如果只有一个参数，可以省略小括号()
        like = a->{
            System.out.println("我的幸运数字是"+a);
        };
        like.ilike(7);

        // 如果方法中的代码只有一行，可以省略花括号{}
        like = a->System.out.println("我的幸运数字是"+a);
        like.ilike(8);
    }
}
interface Like{
    void ilike(int a);
}

结果：

我的幸运数字是5
我的幸运数字是6
我的幸运数字是7
我的幸运数字是8

② 如果接口中的方法有返回值：

public class TestLambda2 {
    public static void main(String[] args) {
        Like like = (int a)->{
            System.out.println("我的幸运数字是"+a);
            return a*2;
        };
        System.out.println(like.ilike(5));
        
        System.out.println("-----------------------");
        
        // 如果方法中只有一句返回语句也可以同时省略花括号{}和return
        like = (int a)->a*2;
        System.out.println(like.ilike(6));
    }
}
interface Like{
    int ilike(int a);
}

结果：

我的幸运数字是5
10
-----------------------
12

总结：

1. 使用Lambda表达式的前提是接口必须为函数式接口
2. Lambda表达式只有方法中只有一行代码时才能省略花括号{}，当有多行时不能省略
3. 当有多个参数时，也可以省略参数类型，但必须都省略，或者都不省略
4. 只有当方法中只有一个参数时才能省略小括号
5. 只有当方法中只有一句返回语句时，才能省略省略花括号{}和return，且必须是同时省略