JDK1.8新特性——接口改動和Lambda表達式

摘要：本文主要學習了JDK1.8的新特性中有關接口和Lambda表達式的部分。

部分內容來自以下博客：

https://www.cnblogs.com/onetwo/p/8526374.html

https://www.cnblogs.com/xxez-d/p/5989944.html

https://www.cnblogs.com/runningTurtle/p/7092632.html

https://www.cnblogs.com/jiangwz/p/9197238.html

https://www.cnblogs.com/hujingnb/p/10181630.html

接口增強

在JDK1.8以前的版本中，定義一個接口時，所有的方法必須是抽象方法，不能有具體實現，這是Java語法規定的。但是在JDK1.8中定義一個接口時，在滿足特定的前提下，可以有方法的具體實現。這樣一個接口中可以有屬性，可以有抽象方法，也可以有具體的方法，這跟JDK1.8以前的接口比，明顯接口的功能變得強大了。

使用接口增強

接口中定義具體的方法實現是有限制的，它不能像我們在一個普通類那樣隨便定義方法實現，它只能定義default和static類型的方法。

在調用的時候，被default修飾的默認方法需要通過實現了該接口的類去調用，被static修飾的靜態方法可以通過接口名直接調用。

default和static不能用來修飾Object中的public方法，但是可以修飾Object中其他訪問修飾符修飾的方法。

代碼如下：

public class Demo {
    public static void main(String[] args) {
        NewInterface.testStatic();
        new NewInterfaceImpl().testDefault();
    }
}

interface NewInterface {
    public String name = "";
    
    default void testDefault() {
        System.out.println("測試新增的default方法");
    }
    
    static void testStatic() {
        System.out.println("測試新增的static方法");
    }
}

class NewInterfaceImpl implements NewInterface {
    @Override
    public void testDefault() {
        NewInterface.super.testDefault();
        System.out.println("測試子類重寫的新增的static方法");
    }
}

運行結果如下：

測試新增的static方法
測試新增的default方法
測試子類重寫的新增的static方法

好處

想象這樣一中情況，當多個類實現一個接口的某個方法時，方法的具體實現代碼相同，這樣就會造成代碼重復問題。接口增強就相當於把公共的代碼抽離出來，放入接口定義中，這樣實現類對於該方法就不用重新定義，直接調用即可，這很好的解決了實現該接口的子類代碼重復的問題。

函數式接口

所謂的函數式接口，當然首先是一個接口，然后就是在這個接口里面只能有一個抽象方法，這種類型的接口也稱為SAM（Single Abstract Method）接口。

下面的代碼展示了一個簡單的函數式接口：

interface NewInterface {
    void test();
}

關於@FunctionalInterface注解

JDK1.8為函數式接口引入了一個新注解@FunctionalInterface，主要用於編譯級錯誤檢查，加上該注解，當你寫的接口不符合函數式接口定義的時候，編譯器會報錯。

加不加@FunctionalInterface對於接口是不是函數式接口沒有影響，該注解只是提醒編譯器去檢查該接口是否僅包含一個抽象方法。

下面的代碼展示了一個加了注解的函數式接口：

@FunctionalInterface
interface NewInterface {
    void test();
}

函數式接口里允許定義默認方法

函數式接口里是可以包含默認方法，因為默認方法不是抽象方法，其有一個默認實現，所以是符合函數式接口的定義的。

下面的代碼展示了一個帶有默認方法的函數式接口：

@FunctionalInterface
interface NewInterface {
    void test();
    
    default void defaultRead() {
        System.out.println("defaultRead() ...");
    }
    
    default void defaultWrite() {
        System.out.println("defaultWrite() ...");
    }
}

函數式接口里允許定義靜態方法

函數式接口里是可以包含靜態方法，因為靜態方法不能是抽象方法，是一個已經實現了的方法，所以是符合函數式接口的定義的。

下面的代碼展示了一個帶有靜態方法的函數式接口：

@FunctionalInterface
interface NewInterface {
    void test();
    
    static void staticRead() {
        System.out.println("staticRead() ...");
    }
    
    static void staticWrite() {
        System.out.println("staticWrite() ...");
    }
}

函數式接口里允許定義java.lang.Object里的public方法

函數式接口里是可以包含Object里的public方法，這些方法對於函數式接口來說，不被當成是抽象方法（雖然它們是抽象方法）。因為此接口的實現類一定是Object的子類，會自動實現這個接口中定義的抽象方法。

但也只能是public方法，其他訪問修飾符修飾的方法是不允許在函數式接口里定義的。

下面的代碼展示了一個帶有Object類的public方法的函數式接口：

@FunctionalInterface
interface NewInterface {
    void test();
    
    @Override
    public String toString();
    
    @Override
    public boolean equals(Object obj);
    
//    @Override
//    public Object clone();
}

JDK1.8新增的函數式接口

JDK1.8內置的函數式接口放在包java.util.function下，默認在JDK安裝路徑下的src.zip中。

Supplier接口

Supplier接口沒有參數，只有返回值，作用是為了產生對象。

@FunctionalInterface
public interface Supplier<T> {
    T get();
}

Consumer接口

Consumer接口有參數，但是沒有返回值，作用是為了進行某種操作，比如打印操作。

@FunctionalInterface
public interface Consumer<T> {
    void accept(T t);

    default Consumer<T> andThen(Consumer<? super T> after) {
        Objects.requireNonNull(after);
        return (T t) -> { accept(t); after.accept(t); };
    }
}

Function接口

Function接口有參數，也有返回值，作用是對參數進行處理並返回。

@FunctionalInterface
public interface Function<T, R> {
    R apply(T t);

    default <V> Function<V, R> compose(Function<? super V, ? extends T> before) {
        Objects.requireNonNull(before);
        return (V v) -> apply(before.apply(v));
    }

    default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {
        Objects.requireNonNull(after);
        return (T t) -> after.apply(apply(t));
    }

    static <T> Function<T, T> identity() {
        return t -> t;
    }
}

Predicate接口

Predicate接口有參數，也有返回值，但返回值是Boolean類型的值，作用是對傳入的參數進行某種判斷。

@FunctionalInterface
public interface Predicate<T> {
    boolean test(T t);

    default Predicate<T> and(Predicate<? super T> other) {
        Objects.requireNonNull(other);
        return (t) -> test(t) && other.test(t);
    }

    default Predicate<T> negate() {
        return (t) -> !test(t);
    }

    default Predicate<T> or(Predicate<? super T> other) {
        Objects.requireNonNull(other);
        return (t) -> test(t) || other.test(t);
    }

    static <T> Predicate<T> isEqual(Object targetRef) {
        return (null == targetRef)
                ? Objects::isNull
                : object -> targetRef.equals(object);
    }
}

Lambda表達式

什么是Lambda表達式

通過使用表達式來提供一種清晰簡潔的方式來表示方法接口。

語法

參數列表 -> 方法體

如果參數列表有多個值，可以使用小括號包含，如果只有一條，則可以省略小括號。

如果方法體有多條語句，可以使用大括號包含，如果只有一條，則可以省略大括號，如果是return語句，則可以省略return關鍵字。

使用舉例

在創建一個線程並調用的時候，需要傳入一個Runnable接口的實現類。

使用Lambda表達式之前：

new Thread(new Runnable() {
    @Override
    public void run() {
        System.out.println("Thread1 run() ...");
    }
}).start();

使用Lambda表達式之后：

new Thread(() -> System.out.println("Thread2 run() ...")).start();

變量作用域

Lambda表達式只能引用標記了final的外層局部變量，這就是說不能在Lambda內部修改定義在域外的局部變量，否則會編譯錯誤。

final int num = 100;
NewInterface ni = i -> String.valueOf(i + num);
System.out.println(ni.test(num));

Lambda表達式的局部變量可以不用聲明為final，但是必須不可被后面的代碼修改（即隱性的具有final的語義）。

final int num = 100;
NewInterface ni = i -> String.valueOf(i + num);
System.out.println(ni.test(num));
// num++;

在Lambda表達式當中不允許聲明一個與局部變量同名的參數或者局部變量。

final int num = 100;
// NewInterface ni = num -> String.valueOf(num);
NewInterface ni = i -> String.valueOf(i);
System.out.println(ni.test(num));

方法引用

什么是方法引用

方法引用是JDK1.8中提出的用來簡化Lambda表達式的一種手段。它通過類名和方法名來定位到一個靜態方法或者實例方法。

語法

類或對象名::方法名或new

靜態方法引用

如果是靜態方法引用，那么語法是 類名::靜態方法名 ，並且方法調用傳入的參數就是方法用到的參數。

代碼如下：

public class Demo {
    public static void main(String[] args) {
        // 使用匿名內部類
//        NewInterface ni = new NewInterface() {
//            @Override
//            public String test(String name) {
//                return String.valueOf(name);
//            }
//        };
        // 使用Lambda表達式
//        NewInterface ni = name -> String.valueOf(name);
        // 使用方法引用
        NewInterface ni = String::valueOf;
        System.out.println(ni.test("name"));
    }
}

@FunctionalInterface
interface NewInterface {
    String test(String name);
}

運行結果如下：

name

實例方法引用

如果是實例方法引用，那么語法是 對象實例::方法名 ，並且方法調用傳入的第一個參數是方法的調用者，后面的參數才是方法的參數。

代碼如下：

public class Demo {
    public static void main(String[] args) {
        // 使用匿名內部類
//        NewInterface ni = new NewInterface() {
//            @Override
//            public int test(String str) {
//                return str.length();
//            }
//        };
        // 使用Lambda表達式
//        NewInterface ni = str -> str.length();
        // 使用方法引用
        NewInterface ni = String::length;
        System.out.println(ni.test("lenth"));
    }
}

@FunctionalInterface
interface NewInterface {
    int test(String str);
}

運行結果如下：

5

構造方法引用

如果是構造方法引用，那么語法是 類名::new ，並且方法調用傳入的參數就是構造方法的參數。

代碼如下：

public class Demo {
    public static void main(String[] args) {
        // 使用匿名內部類
//        NewInterface ni = new NewInterface() {
//            @Override
//            public String test(String str) {
//                return new String(str);
//            }
//        };
        // 使用Lambda表達式
//        NewInterface ni = str -> new String(str);
        // 使用方法引用
        NewInterface ni = String::new;
        System.out.println(ni.test("str"));
    }
}

@FunctionalInterface
interface NewInterface {
    String test(String str);
}

運行結果如下：

str