JDK8 新特性-接口方法

概述

在 Java 8 之前，接口只能定义抽象方法，而不能有方法的实现，只有抽象类才能同时拥有抽象方法和非抽象方法。从 Java 8 开始，接口新增了静态方法和默认方法，本文主要讨论接口新增的这两种方法

静态方法

通常情况下，类中定义的方法都会是虚方法，当我们使用静态方法时，往往都是希望为特定的操作提供工具方法。实际上，各种第三方类库都提供了很多工具类，这些工具类集合了特定对象的很多操作方法，比如 StringUtil 提供了字符串工具。

但是通过另一个工具类来提供静态操作，并不是最好的选择。Java 8 为接口新增静态方法后，可以把常用的工具方法直接写在接口上，可以更好地组织代码，更易阅读和使用。

以新版的 Comparator 接口为例，新增了 comparing 静态方法，用于构造比较器。该方法的参数为 Function 函数接口，可以接收 lambda 表达式参数，从而生成比较器。

@FunctionalInterface
public interface Comparator<T> {
    /*省略其他代码*/
    public static <T, U extends Comparable<? super U>> Comparator<T> comparing(
            Function<? super T, ? extends U> keyExtractor)
    {
        Objects.requireNonNull(keyExtractor);
return (Comparator<T> & Serializable)
            (c1, c2) -> keyExtractor.apply(c1).compareTo(keyExtractor.apply(c2));
    }
    /*省略其他代码*/
}

在使用时，利用 comparing 方法可以很方便地得到一个比较器。而且这个方法通过 Comparator 接口去调用，代码紧凑，语义上也容易理解。

List<Integer> list = Arrays.asList(1,2,3,4,5);
int min = list.stream()
    .min(Comparator.comparing(value -> value))
    .get();
int max = list.stream()
    .max(Comparator.comparing(value -> value))
    .get();

默认方法

默认方法与静态方法不同，使用 default 关键字声明，实现类可以选择不实现这个方法。接口通过声明默认方法，提供了这个方法的默认实现。如果子类实现了这个方法调用时使用子类的实现，否则使用默认实现。

以 Function 接口为例，提供了默认方法 andThen，这个方法实现在当前 apply 完成之后再进行后置的 apply 操作。andThen 方法的默认实现中，返回了一个 lambda 表达式，表达式中先调用当前的 apply 方法，再调用传入的 after 的 apply 方法。

@FunctionalInterface
public interface Function<T, R> {
    R apply(T t);
    /*省略其他代码*/
    default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {
        Objects.requireNonNull(after);
        return (T t) -> after.apply(apply(t));
    }
    /*省略其他代码*/
}

实现类实现 Function 接口时，如果不实现 andThen 方法，则调用 andThen 方法时使用接口的默认实现。在如下的示例中，当前类的 apply 实现是在字符串后添加 “ ok”，而后置的 Function 接口 apply 实现是把字符串转为大写，调用 test 方法最终打印出来的字符是“TEST OK”。

public class FunctionTest implements Function<String, String> {
    @Override
    public String apply(String t) {
        return t + " ok";
    }

    public void test() {
        String res = andThen(str -> str.toUpperCase()).apply("test");
        System.out.println(res);
    }
}

如果实现类实现了接口的默认方法，则实现类的方法优先级高于默认方法，调用时使用实现类的实现。在如下的示例中，FunctionTestWithImpl 类实现了接口的 andThen 方法，只调用 after 的 apply 方法而不再调用当前实现类的 apply 方法，调用 test 方法最终打印出来的字符是“TEST”。

public class FunctionTestWithImpl implements Function<String, String> {
    @Override
    public String apply(String t) {
        return t + " ok";
    }

    @Override
    public <V> Function<String, V> andThen(Function<? super String, ? extends V> after) {
        return (t) -> after.apply(t);
    }

    public void test() {
        String res = andThen(str -> str.toUpperCase()).apply("test");
        System.out.println(res);
    }
}

Java 允许一个类实现多个接口，如果这多个接口中存在签名相同的默认方法，就会出现冲突，无法判断该使用哪个默认实现。这时，在实现类中覆盖这个方法的默认实现即可，因为在实现类中的方法实现优先级高于默认实现。

接口与抽象类的区别

Java 8 中的接口相比于以前的版本更加接近抽象类，尤其是静态方法和默认方法，但仍然存在很大的区别。接口里定义的变量只能是公共的静态的常量，抽象类中的变量一般是普通变量。接口允许多重继承，却没有成员变量；抽象类可以继承成员变量，却不能多重继承。