Lamda表达式

λ 希腊字母中排序第十一位的字母，英语名称为Lambda
避免匿名内部类定义过多
其实质属于函数式编程的概念

new Thread(()->System.out.println("多线程学习。。。")).start();
为什么要使用lambda表达式
- 避免匿名内部类定义过多
- 可以让你的代码看起来很简洁
- 去掉一堆没有意义的代码，只留下核心的逻辑。
也许你会说，我看了Lambda表达式，不但不觉得简洁，反而觉得更乱，看不懂了。那是因为我们还没有习惯，用的多了，看习惯了，就好了。
理解Functional Intergace（函数式接口）是学习Java8 lambda表达式关键所在。
函数时接口的定义：
- 任何接口，如果只包含唯一一个抽象方法，那么它就是一个函数式接口。
```
 public interface Runnable{
     puablic abstract void run();
 }
```
- 对于函数式接口，我们可以通过lambda表达式来创建该接口的对象。

实例

 1 package com.learnThread;
 2 /*
 3     推到lambda表达式
 4     一步步简化来的
 5  */
 6 public class TestLambda01 {
 7     //3.静态内部类
 8     static class Like2 implements ILike{
 9         @Override
10         public void lambda() {
11             System.out.println("i like lambda2");
12         }
13     }
14     public static void main(String[] args) {
15         ILike like = new Like();
16         like.lambda();
17 
18         like=new Like2();
19         like.lambda();
20 
21         //4.局部内部类
22         class Like3 implements ILike{
23             @Override
24             public void lambda() {
25                 System.out.println("i like lambda3");
26             }
27         }
28         like = new Like3();
29         like.lambda();
30 
31         //5.匿名内部类
32         like=new ILike() {
33             @Override
34             public void lambda() {
35                 System.out.println("i like lambda4");
36             }
37         };
38         like.lambda();
39 
40         //6.用lambda简化
41         like = ()->{
42             System.out.println("i like lambda5");
43         };
44         like.lambda();
45     }
46 }
47 //1.定义一个函数式接口
48 interface ILike{
49      void lambda();
50 }
51 
52 //2.实现类
53 class Like implements ILike{
54     @Override
55     public void lambda() {
56        System.out.println("i like lambda");
57     }
58 }

 1 package com.learnThread;
 2 
 3 public class TestLambda02 {
 4     static class Love2 implements Ilove{
 5         @Override
 6         public void love(int a) {
 7             System.out.println("i love you"+a);
 8         }
 9     }
10     public static void main(String[] args) {
11         Ilove ilove =new Love();
12         ilove.love(2);
13 
14         ilove=new Love2();
15         ilove.love(3);
16         class Love3 implements Ilove{
17             @Override
18             public void love(int a) {
19                 System.out.println("i love you"+a);
20             }
21         }
22         ilove =new Love3();
23         ilove.love(4);
24 
25         ilove = new Ilove() {
26             @Override
27             public void love(int a) {
28                 System.out.println("i love you"+a);
29             }
30         };
31         ilove.love(5);
32         //1.lambda表达式简化
33         ilove = (int a)->{
34             System.out.println("i love you"+a);
35         };
36         ilove.love(6);
37         //简化1.参数类型
38         ilove=(a)->{
39             System.out.println("i love you"+a);
40         };
41         ilove.love(7);
42         //简化2.简化括号
43         ilove=a -> {
44             System.out.println("i love you"+a);
45         };
46         ilove.love(8);
47         //简化3.去掉花括号
48         ilove=a -> System.out.println("i love you"+a);
49         ilove.love(9);
50         /*
51             总结：
52                 1.lambda表达式只能有一行代码的情况下才能简化成一行，如果有多行，那就用代码块包裹
53                 2.前提是接口为函数式接口。
54                 3.多个参数也可以去掉参数类型，要去掉都去掉，必须加上括号
55          */
56     }
57 
58 }
59 interface Ilove{
60     void love(int a);
61 }
62 class Love implements Ilove{
63     @Override
64     public void love(int a) {
65         System.out.println("i love you"+a);
66     }
67 }