Java中Lambda表示式的進化之路

Thales_ZeeWay發表於2021-11-02
Java

Lambda表示式的進化之路

為什麼要使用Lambda表示式

  • 可以簡潔程式碼，提高程式碼的可讀性
  • 可以避免匿名內部類定義過多導致邏輯紊亂
  • 在原先實現介面抽象方法的時候，需要通過定義一個實現介面的外部類來實現，後面變為定義內部靜態類，然後變為用區域性內部類實現，再後面變成了定義匿名內部類來實現，最後的最後，為了程式碼的更加簡潔，推出了Lambda表示式，最終實現了用一行程式碼完成之前多行程式碼的效果

Lambda表示式的注意點

  • Lambda表示式實際上屬於是函數語言程式設計的概念，所以在使用的時候要知道是否屬於函數語言程式設計

  • Lambda表示式的實現依賴於介面和父類，所以必須有兩者之一才能實現Lam表示式

  • Lambda表示式實現的介面中要求只有一個抽象方法，如果有多個抽象方法就無法使用Lambda表示式來程式設計

  • Lambda表示式即適用於無參方法，也適用於含參方法

  • Lambda表示式最早在JDK 8中開始出現，所以只有 JDK 8 以後的版本才支援

下面是Lambda表示式的實現過程

  1. 最開始使用的是定義外部實現類來完成介面

    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. 開始使用靜態內部類來實現

    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. 使用區域性內部類使用

    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. 使用匿名內部類實現介面

    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表示式實現函式式介面

    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表示式中，只有當輸出語句或者程式碼只有一行的時候可以省略花括號。假如有多條執行程式碼，還是需要用花括號將程式碼包含在內

相關文章