Lambda表达式的逐步简化过程，超详细，干货

JDK1.8 Lambda表达式

为什么要用Lambda表达式？

• 避免内部类定义过多
• 让代码看起来更整洁
• 去掉一堆没有意义的代码，只留下核心逻辑

Functional Interface(函数式接口)

• 理解函数式接口是学习Java8，Lambda表达式的关键
• 函数式接口的定义：
  • 任何接口如果只包含唯一一个抽象方法，那么它就是一个函数式接口
  • 对于函数式接口，我们可以通过Lambda表达式来创建该接口的对象。

package com.thread.lambdaTest;
/*
* 推导Lambda表达式
*   注释的序号，是一个逐步简化的过程
*   1.定义一个函数式接口
*   2.用实现类实现接口
*   3.用静态内部类实现接口
*   4.用局部内部类实现接口
*   5.用匿名内部类实现接口
*   6.用lambda表达式简化实现接口
* */

//1.定义一个函数式接口
interface Love{
    void showLove();
}
//2.实现类
class Person implements Love{
    @Override
    public void showLove() {
        System.out.println("I love you");
    }
}

public class LambdaTest {
    //3.静态内部类
    static class Person2 implements Love{
        @Override
        public void showLove() {
            System.out.println("I love you 2");
        }
    }
    public static void main(String[] args) {
        //4.局部内部类
        class Person3 implements Love{
            @Override
            public void showLove() {
                System.out.println("I love you 3");
            }
        }
        //5.匿名内部类,没有类的名称，必须借助接口或者父类
        Love love4 = new Love() {
            @Override
            public void showLove() {
                System.out.println("I love you 4");
            }
        };

        //6.用lambda表达式简化
        Love love5 = ()->{
            System.out.println("I love you 5");
        };

        //测试实现类输出
        Love love = new Person();
        love.showLove();
        //测试静态内部类输出
        Love love2 = new Person2();
        love2.showLove();
        //测试局部内部类输出
        Love love3 = new Person3();
        love3.showLove();
        //测试匿名内部类输出
        love4.showLove();
        //测试lambda表达式简化后输出
        love5.showLove();
    }
}

对于lambda表达式的简化

package com.thread.lambdaTest;
/*
* 继续简化lambda表达式
* */
//还是先定义接口
interface Kiss{
    void kissYou(String name);
}
public class LambdaTestTwo {
    public static void main(String[] args) {
        //初始态
        Kiss kiss = (String name)->{
            System.out.println("I want to kiss you "+name);
        };
        kiss.kissYou("漂亮");
        //简化方式一：参数类型 (两种写法：一种写在参数括号内部（只限单参数）；另一种在参数括号外部)
        Kiss kiss2 = (name -> {
            //括号内
            System.out.println("I want to kiss you "+name);
        });
        kiss2.kissYou("漂亮X2");

        kiss2 = (name)->{
            //括号外
            System.out.println("I want to kiss you "+name);
        };
        kiss2.kissYou("漂亮X2.1");

        //简化方式二：简化参数括号
        Kiss kiss3 = name -> {
            System.out.println("I want to kiss you "+name);
        };
        kiss3.kissYou("漂亮X3");

        //简化方式三：简化代码外层花括号
        Kiss kiss4 = name -> System.out.println("I want to kiss you "+name);
        kiss4.kissYou("漂亮X4");
    }
}

总结注意：

• 如若使用lambda表达式，必须保证接口是函数式接口（即该接口只有一个方法）

• 在对lambda表达式的简化方式一中，在参数括号内的写法，如果有大于一个以上的参数时，会报错。请使用括号外写法

• 简化方式三中，在只有一行代码的情况下可以缩减为一行。如果有多行代码，请使用简化方式一或二，用代码块包裹。

• 在有多个参数的情况下，也可以去掉参数类型。如果去掉，就都去掉。前提是所有参数必须写在括号内