Lamda表达式

Lamda表达式

一、Lamda表达式

1.为什么要使用Lamda表达式

A.避免匿名内部类定义过多；

B.可以让你的代码看起来很简洁；

C.去掉了一堆没有意义的代码，只留下核心的逻辑。

2.Lamda表达式的书写格式

new Thread（()->System.out.println(“Lamda表达式”)）.start()

3.Lamda表达式的关键

理解Functional Interface（函数式接口）

二、函数式接口的定义

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

public interface Runnable {
	public abstract void run();
}
//一个接口只有一个方法，超过一个抽象方法的接口都不能称为函数式接口！！！

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

三、演示

通过代码来推导Lamda表达式，请读者根据我的推导步骤一步一步的实现。

步骤1：

public class TestLambda {
    public static void main(String[] args) {
        //实例化一个对象，调用方法
        Lambda1 lambda1 = new Lambda1();
        lambda1.lambdaMethod();
    }
}

//定义一个函数式接口：一个接口有且仅有一个方法；
interface LambdaInterface {
    void lambdaMethod();
}

//实现类
class Lambda1 implements LambdaInterface {

    @Override
    public void lambdaMethod() {
        System.out.println("Lambda1");
    }
}

步骤2：

public class TestLambda {

    //静态内部类
    static class Lambda1 implements LambdaInterface {

        @Override
        public void lambdaMethod() {
            System.out.println("Lambda1");
        }
    }

    public static void main(String[] args) {
        //实例化一个对象，调用方法
        Lambda1 lambda1 = new Lambda1();
        lambda1.lambdaMethod();
    }
}

//定义一个函数式接口：一个接口有且仅有一个方法；
interface LambdaInterface {
    void lambdaMethod();
}

步骤3：

public class TestLambda {
    
    public static void main(String[] args) {

        //局部内部类，注意要把它放在实例化之前
        class Lambda1 implements LambdaInterface {

            @Override
            public void lambdaMethod() {
                System.out.println("Lambda1");
            }
        }

        //实例化一个对象，调用方法
        Lambda1 lambda1 = new Lambda1();
        lambda1.lambdaMethod();
    }
}

//定义一个函数式接口：一个接口有且仅有一个方法；
interface LambdaInterface {
    void lambdaMethod();
}

步骤4：

public class TestLambda {

    public static void main(String[] args) {

        //匿名内部类：没有类的名称，必须借助接口或父类；
        LambdaInterface testLambda = new LambdaInterface() {
            @Override
            public void lambdaMethod() {
                System.out.println("Lambda1");
            }
        };
        testLambda.lambdaMethod();
    }
}

//定义一个函数式接口：一个接口有且仅有一个方法；
interface LambdaInterface {
    void lambdaMethod();
}

步骤5：

public class TestLambda {

    public static void main(String[] args) {

        //匿名内部类：没有类的名称，必须借助接口或父类；
        LambdaInterface testLambda = new LambdaInterface() {
            @Override
            public void lambdaMethod() {
                System.out.println("Lambda1");
            }
        };
        testLambda.lambdaMethod();

        //用Lambda简化
        testLambda = () -> {
            System.out.println("Lambda2");
        };
        testLambda.lambdaMethod();
    }
}

//定义一个函数式接口：一个接口有且仅有一个方法；
interface LambdaInterface {
    void lambdaMethod();
}

推导过程示意图：

再进行一次含有参数的Lambda表达式推导，说明一些问题：

public class TestLambda2 {
    public static void main(String[] args) {
        Lambda2 lambda2 = new Lambda2();
        lambda2.value(88);
    }
}

interface LambdaInterface2 {
    int value(int b);
}

//实现类
class Lambda2 implements LambdaInterface2 {

    @Override
    public int value(int b) {
        System.out.println("数值 = " + b);
        return b;
    }
}

public class TestLambda2 {
    public static void main(String[] args) {
        Lambda2 lambda2 = new Lambda2();
        lambda2.value(88);
    }

    //静态内部类
    static class Lambda2 implements LambdaInterface2 {

        @Override
        public void value(int b) {
            System.out.println("数值 = " + b);
        }
    }
}

interface LambdaInterface2 {
    void value(int b);
}

public class TestLambda2 {
    public static void main(String[] args) {

        //局部内部类
        class Lambda2 implements LambdaInterface2 {

            @Override
            public void value(int b) {
                System.out.println("数值 = " + b);
            }
        }
        Lambda2 lambda2 = new Lambda2();
        lambda2.value(88);
    }
}

interface LambdaInterface2 {
    void value(int b);
}

public class TestLambda2 {
    public static void main(String[] args) {

        //匿名内部类
        LambdaInterface2 lambdaInterface2 = new LambdaInterface2() {
            @Override
            public void value(int b) {
                System.out.println("数值 = " + b);
            }
        };
        lambdaInterface2.value(88);
    }
}

interface LambdaInterface2 {
    void value(int b);
}

看上图，蓝色阴影部分的代码，Lambda表达式的形式就是将这部分里的括号()与花括号{}之间添加一个箭头即可。

public class TestLambda2 {
    public static void main(String[] args) {
        LambdaInterface2 lambdaInterface2 = null;
        //Lambda简化1：
        lambdaInterface2 = (int b) -> {
            System.out.println("简化1--->数值 = " + b);
        };
        lambdaInterface2.value(88);

        //Lambda简化2：简化参数类型
        //当有多个参数时，他们的参数类型要去掉就都去掉，要不然就都不去掉！！！
        lambdaInterface2 = (b) -> {
            System.out.println("简化2--->数值 = " + b);
        };
        lambdaInterface2.value(100);

        //Lambda简化3：简化括号
        //当有多个参数时，括号不可以被去掉！！！
        lambdaInterface2 = b -> {
            System.out.println("简化3--->数值 = " + b);
        };
        lambdaInterface2.value(99);

        //Lambda简化4：简化花括号
        //当方法体{}中只有一条执行语句(即：只有一个分号)时，才可以这样简化！！！
        //若方法体{}中有多条语句，必须用花括号{}包裹着；
        lambdaInterface2 = (b) -> System.out.println("简化4--->数值 = " + b);
        lambdaInterface2.value(77);
    }
}

interface LambdaInterface2 {
    void value(int b);
}

//多个参数，多条语句的情况
public class TestLambda2 {
    public static void main(String[] args) {

        //匿名内部类
        LambdaInterface2 lambdaInterface2 = new LambdaInterface2() {
            @Override
            public void value(int a, int b) {
                System.out.println("数值a = " + a);
                System.out.println("数值b = " + b);
            }
        };
    }
}

interface LambdaInterface2 {
    void value(int a, int b);
}

四、总结

1.Lambda表达式的前提是接口为函数式接口（一个接口有且仅有一个方法）；

2.多个参数也可以去掉参数类型，要去掉就都去掉，要保留就都保留，但是必须加上括号；

3.Lambda表达式只有在方法体{}中含有一条语句的情况下，才可以去掉花括号；若含有多条语句，不可去掉花括号{}。