Lambda表达式 ( Java 8新特性 )

函数式接口 ( 什么是函数式接口 )

1. 任何接口，如果只包含唯一 一个抽象方法，那么它就是一个函数式接口。比如多线程中的Runnable接口，只包含一个run()抽象方法，所以Runnable接口是一个函数式接口。

   @FunctionalInterface
   public interface Runnable {
      
       public abstract void run();
   }
   1
   2
   3
   4
   5

注1：@FunctionalInterface 注解是 Java 8为函数式接口引入的新注解。@FunctionalInterface主要用于编译期错误检查，如果标注了该注解的接口不符合函数式接口的定义，那么就会编译不通过。

注2：函数式接口有且仅有一个抽象方法，但可以有其它非抽象方法

注3：@FunctionalInterface注解不是必须的，如果一个接口符合 函数式接口 定义，那么加不加该注解都没有影响。加上该注解能够更好地让编译器进行检查。如果编写的不是函数式接口，但是加上了@FunctionInterface，那么编译器会报错。

2. 对于函数式接口，我们可以使用 java 8提供的新特性 Lambda表达式来创建该接口的对象。

   //匿名内部类创建线程
   new Thread(new Runnable() {
       @Override
       public void run() {
           System.out.println("$*****$");
       }
   }).start();
   
       ||
       ||
       \/
   
   //lambda表达式创建线程
   new Thread(() -> System.out.println("lambda表达式")).start();
   1
   2
   3
   4
   5
   6
   7
   8
   9
   10
   11
   12
   13
   14

为什么要使用lambda表达式

1. 避免匿名内部类定义过多。
2. 使代码看起来更加简洁。
3. 去掉一堆没有意义的代码，只留下核心的逻辑。

Lambda表达式的实质属于函数式编程：

(params) -> expression[表达式]
    
(params) -> expression[语句]
    
(params) -> {expression}
1
2
3
4
5

推导 Lambda 表达式的产生之路

package com.cd.test;

//1.定义一个函数式接口（函数式接口只有一个抽象方法）
interface FunInterface {
    void lambda();
}

//2.实现类
class Fun implements FunInterface {

    @Override
    public void lambda() {
        System.out.println("1");
    }
}

public class Lambda {

    //3.静态内部类
    static class Fun2 implements FunInterface {

        @Override
        public void lambda() {
            System.out.println("2");
        }
    }

    public static void main(String[] args) {
        FunInterface fun = new Fun();
        fun.lambda();

        fun = new Fun2();
        fun.lambda();

        //4.局部内部类
        class Fun3 implements FunInterface {

            @Override
            public void lambda() {
                System.out.println("3");
            }
        }

        fun = new Fun3();
        fun.lambda();

        //5.匿名内部类，没有类的名称，必须借助接口或父类
        fun = new FunInterface() {
            @Override
            public void lambda() {
                System.out.println("4");
            }
        };
        fun.lambda();


        //6.Lambda表达式（简化）
        fun = () -> {
            System.out.println("5");
        };
        fun.lambda();

    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64

带参的函数式接口

package com.cd.test;

//1.定义一个函数式接口（函数式接口只有一个方法）
interface FunInterface {
    void lambda(String str);
}

public class Lambda {

    public static void main(String[] args) {

        //2.Lambda表达式（简化1）
        FunInterface fun = (String str) -> {
            System.out.println("lambda" + str);
        };
        fun.lambda("表达式");


        //3.Lambda表达式，省略参数类型（简化2）
        fun = (str) -> {
            System.out.println("lambda" + str);
        };
        fun.lambda("表达式, 省略参数类型");


        //4.Lambda表达式，省略参数类型 和 括号（简化3）
        fun = str -> {
            System.out.println("lambda" + str);
        };
        fun.lambda("表达式, 省略参数类型 和 括号");


        //5.Lambda表达式，省略参数类型、括号 和 花括号（简化4）
        fun = str -> System.out.println("lambda" + str);
        fun.lambda("表达式, 省略参数类型、括号 和 花括号");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

总结：（前提：接口是函数式接口）

1. lambda表达式在只有一行代码的情况下才可以去掉{}花括号，简化成一行。如果有多行，那么就必须用{}代码块包裹。

2. 函数式接口的抽象方法只有一个参数时，lambda表达式可以去掉参数类型 和 ()括号。有多个参数时，lambda表达式可以去掉参数类型，但必须全部参数类型都去掉，且必须用()括号包裹。

Variable used in lambda expression should be final or effectively final 异常

Lambda表达式是由匿名内部类演变过来的，在内部类中使用外部类的变量，这个变量需要使用final修饰