Lambda表達式的進化之路
為什么要使用Lambda表達式
- 可以簡潔代碼，提高代碼的可讀性
- 可以避免匿名內部類定義過多導致邏輯紊亂
- 在原先實現接口抽象方法的時候，需要通過定義一個實現接口的外部類來實現，后面變為定義內部靜態類，然后變為用局部內部類實現，再后面變成了定義匿名內部類來實現，最后的最后，為了代碼的更加簡潔，推出了Lambda表達式，最終實現了用一行代碼完成之前多行代碼的效果
Lambda表達式的注意點
- Lambda表達式實際上屬于是函數式編程的概念，所以在使用的時候要知道是否屬于函數式編程
- Lambda表達式的實現依賴于接口和父類，所以必須有兩者之一才能實現Lam表達式
- Lambda表達式實現的接口中要求只有一個抽象方法，如果有多個抽象方法就無法使用Lambda表達式來編程
- Lambda表達式即適用于無參方法，也適用于含參方法
- Lambda表達式最早在JDK 8中開始出現，所以只有 JDK 8 以后的版本才支持
下面是Lambda表達式的實現過程
1.最開始使用的是定義外部實現類來完成接口
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
public class tt1 { public static void main(String[] args) { //用外部類來實現接口，首先需要在主類外定義另外一個類，之后再在內部類中創建對象 //這樣對于那些只需要使用一次的接口來說比較的麻煩，而且也會使整個代碼變得臃腫，給其他開發人員帶來閱讀困難 lover l1 = new lover(); l1.love(); }}//定義接口interface ILove { void love();}//外部實現類class lover implements ILove{ @Override public void love() { System.out.println("I love you my lover ---> 1"); }} |
//輸出為：I love you lover ---> 1
2.開始使用靜態內部類來實現
|
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
|
public class tt1 { //靜態內部類 static class lover2 implements ILove{ @Override public void love() { System.out.println("I love you my lover ---> 2"); } } public static void main(String[] args) { //用外部類來實現接口，首先需要在主類外定義另外一個類，之后再在內部類中創建對象 //這樣對于那些只需要使用一次的接口來說比較的麻煩，而且也會使整個代碼變得臃腫，給其他開發人員帶來閱讀困難 ILove l1 = new lover1(); l1.love(); //使用靜態內部類來實現，由于實現類和main方法位于相同主類中，方便了開發人員閱讀，但是實現過程還是比較麻煩 ILove l2 = new lover2(); l2.love(); }}//定義一個函數式接口interface ILove { void love();}//外部實現類class lover1 implements ILove{ @Override public void love() { System.out.println("I love you my lover ---> 1"); }} |
//輸出為：I love you my lover ---> 1
// I love you my lover ---> 2
3.使用局部內部類使用
|
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
|
public class tt1 { //靜態內部類 static class lover2 implements ILove{ @Override public void love() { System.out.println("I love you my lover ---> 2"); } } public static void main(String[] args) { //用外部類來實現接口，首先需要在主類外定義另外一個類，之后再在內部類中創建對象 //這樣對于那些只需要使用一次的接口來說比較的麻煩，而且也會使整個代碼變得臃腫，給其他開發人員帶來閱讀困難 ILove l1 = new lover1(); l1.love(); //使用靜態內部類來實現，由于實現類和main方法位于相同主類中，方便了開發人員閱讀，但是實現過程還是比較麻煩 ILove l2 = new lover2(); l2.love(); //局部內部類 class lover3 implements ILove{ @Override public void love() { System.out.println("I love you my lover ---> 3"); } } ILove l3 = new lover3(); l3.love(); }}//定義一個函數式接口interface ILove { void love();}//外部實現類class lover1 implements ILove{ @Override public void love() { System.out.println("I love you my lover ---> 1"); }} |
//輸出為：I love you my lover ---> 1
// I love you my lover ---> 2
// I love you my lover ---> 3
4.使用匿名內部類實現接口
|
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
|
public class tt1 { //靜態內部類 static class lover2 implements ILove{ @Override public void love() { System.out.println("I love you my lover ---> 2"); } } public static void main(String[] args) { //用外部類來實現接口，首先需要在主類外定義另外一個類，之后再在內部類中創建對象 //這樣對于那些只需要使用一次的接口來說比較的麻煩，而且也會使整個代碼變得臃腫，給其他開發人員帶來閱讀困難 ILove l1 = new lover1(); l1.love(); //使用靜態內部類來實現，由于實現類和main方法位于相同主類中，方便了開發人員閱讀，但是實現過程還是比較麻煩 ILove l2 = new lover2(); l2.love(); //局部內部類 class lover3 implements ILove{ @Override public void love() { System.out.println("I love you my lover ---> 3"); } } ILove l3 = new lover3(); l3.love(); //使用內部匿名類 ILove l4 = new ILove() { @Override public void love() { System.out.println("I love you my lover ---> 4"); } }; }}//定義一個函數式接口interface ILove { void love();}//外部實現類class lover1 implements ILove{ @Override public void love() { System.out.println("I love you my lover ---> 1"); }} |
//輸出為：I love you my lover ---> 1
// I love you my lover ---> 2
// I love you my lover ---> 3
// I love you my lover ---> 4
5..最后使用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
|
public class tt1 { //靜態內部類 static class lover2 implements ILove{ @Override public void love() { System.out.println("I love you my lover ---> 2"); } } public static void main(String[] args) { //用外部類來實現接口，首先需要在主類外定義另外一個類，之后再在內部類中創建對象 //這樣對于那些只需要使用一次的接口來說比較的麻煩，而且也會使整個代碼變得臃腫，給其他開發人員帶來閱讀困難 ILove l1 = new lover1(); l1.love(); //使用靜態內部類來實現，由于實現類和main方法位于相同主類中，方便了開發人員閱讀，但是實現過程還是比較麻煩 ILove l2 = new lover2(); l2.love(); //局部內部類 class lover3 implements ILove{ @Override public void love() { System.out.println("I love you my lover ---> 3"); } } ILove l3 = new lover3(); l3.love(); //使用內部匿名類 ILove l4 = new ILove() { @Override public void love() { System.out.println("I love you my lover ---> 4"); } }; l4.love(); //使用Lambda表達式實現接口 ILove l5 = () ->{ System.out.println("I love you my lover ---> 5"); }; l5.love(); }}//定義一個函數式接口interface ILove { void love();}//外部實現類class lover1 implements ILove{ @Override public void love() { System.out.println("I love you my lover ---> 1"); }} |
//輸出為：
I love you my lover ---> 1
I love you my lover ---> 2
I love you my lover ---> 3
I love you my lover ---> 4
I love you my lover ---> 5
關于Lambda表達式的更加極致的簡化（針對有參數的Lambda表達書）
- 簡化數據類型 在Lambda表達式中可以將參數的數據類型省略，只留下一個數據名稱。比較特殊的是如果有多個參數，省略的時候應該將所有參數的數據類型都省略，不然就全部不省略，而且需要用括號將參數包含在內。
- 省略括號 參照上一條，只有一個參數要求的時候才可以省略括號省略花括號
- 在Lambda表達式中，只有當輸出語句或者代碼只有一行的時候可以省略花括號。假如有多條執行代碼，還是需要用花括號將代碼包含在內
總結
本篇文章就到這里了，希望能夠給你帶來幫助，也希望您能夠多多關注服務器之家的更多內容！
原文鏈接：https://www.cnblogs.com/ZeeWay/p/15501789.html
