Java 8 | 接口的静态方法和默认方法

2017-08-01 From 程序之心 By 丁仪

在 Java 8 之前,接口只能定义抽象方法,而不能有方法的实现,只有抽象类才能同时拥有抽象方法和非抽象方法。从 Java 8 开始,接口新增了静态方法和默认方法,本文主要讨论接口新增的这两种方法。在前文已经介绍过《Java 8 lambda 表达式》和《Java 8 | Stream 简介与常用方法》,这两种新技术依赖于函数接口,在 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 中的接口相比于以前的版本更加接近抽象类,尤其是静态方法和默认方法,但仍然存在很大的区别。接口里定义的变量只能是公共的静态的常量,抽象类中的变量一般是普通变量接口允许多重继承,却没有成员变量;抽象类可以继承成员变量,却不能多重继承。

本文来源:程序之心,转载请注明出处!

本文地址:https://chengxuzhixin.com/blog/article/200040.html

发表感想

© 2016 - 2022 chengxuzhixin.com All Rights Reserved.

浙ICP备2021034854号-1    浙公网安备 33011002016107号