【Java】Java8新特性之接口默认方法与静态方法

一、接口默认方法

　　默认方法是在接口中的方法签名前加上了 default 关键字的实现方法

• 代码示例如下：

public class TestDefaultMethod {
    public static void main(String[] args) {
        ClasA a = new ClasA();
        a.foo();
    }
}

class ClasA implements InterfaceA {}

interface InterfaceA {
    default void foo(){
        System.out.println("InterfaceA foo");
    }
}

• 为什么要有默认方法

　　在 java 8 之前，接口与其实现类之间的 耦合度 太高了（tightly coupled），当需要为一个接口添加方法时，所有的实现类都必须随之修改。默认方法解决了这个问题，它可以为接口添加新的方法，而不会破坏已有的接口的实现。这在 lambda 表达式作为 java 8 语言的重要特性而出现之际，为升级旧接口且保持向后兼容（backward compatibility）提供了途径。

二、默认方法的继承

　　和其它方法一样，接口默认方法也可以被继承。

interface InterfaceA {
    default void foo() {
        System.out.println("InterfaceA foo");
    }
}
 
interface InterfaceB extends InterfaceA {
}
 
interface InterfaceC extends InterfaceA {
    @Override
    default void foo() {
        System.out.println("InterfaceC foo");
    }
}
 
interface InterfaceD extends InterfaceA {
    @Override
    void foo();
}
 
public class Test {
    public static void main(String[] args) {
        new InterfaceB() {}.foo(); // 打印：“InterfaceA foo”
        new InterfaceC() {}.foo(); // 打印：“InterfaceC foo”
        new InterfaceD() {
            @Override
            public void foo() {
                System.out.println("InterfaceD foo");
            }
        }.foo(); // 打印：“InterfaceD foo”
        
        // 或者使用 lambda 表达式
        ((InterfaceD) () -> System.out.println("InterfaceD foo")).foo();
    }
}

　　接口默认方法的继承分三种情况（分别对应上面的 InterfaceB 接口、InterfaceC 接口和 InterfaceD 接口）：

• 不覆写默认方法，直接从父接口中获取方法的默认实现。

• 覆写默认方法，这跟类与类之间的覆写规则相类似。

• 覆写默认方法并将它重新声明为抽象方法，这样新接口的子类必须再次覆写并实现这个抽象方法。

接口继承行为发生冲突时的解决规则

interface InterfaceA {
    default void foo() {
        System.out.println("InterfaceA foo");
    }
}
 
interface InterfaceB extends InterfaceA {
    @Override
    default void foo() {
        System.out.println("InterfaceB foo");
    }
}
 
// 正确
class ClassA implements InterfaceA, InterfaceB {
}
 
class ClassB implements InterfaceA, InterfaceB {
    @Override
    public void foo() {
//        InterfaceA.super.foo(); // 错误
        InterfaceB.super.foo();
    }
}

　　当 ClassA 类多实现 InterfaceA 接口和 InterfaceB 接口时，不会出现方法名歧义的错误。当 ClassB 类覆写 foo 方法时，无法通过 InterfaceA.super.foo(); 调用 InterfaceA 接口的 foo方法。

　　因为 InterfaceB 接口继承了 InterfaceA 接口，那么 InterfaceB 接口一定包含了所有 InterfaceA 接口中的字段方法，因此一个同时实现了 InterfaceA 接口和 InterfaceB 接口的类与一个只实现了 InterfaceB 接口的类完全等价。

接口与抽象类

　　当接口继承行为发生冲突时的另一个规则是，类的方法声明优先于接口默认方法，无论该方法是具体的还是抽象的。

interface InterfaceA {
    default void foo() {
        System.out.println("InterfaceA foo");
    }
 
    default void bar() {
        System.out.println("InterfaceA bar");
    }
}
 
abstract class AbstractClassA {
    public abstract void foo();
 
    public void bar() {
        System.out.println("AbstractClassA bar");
    }
}
 
class ClassA extends AbstractClassA implements InterfaceA {
    @Override
    public void foo() {
        InterfaceA.super.foo();
    }
}
 
public class Test {
    public static void main(String[] args) {
        ClassA classA = new ClassA();
        classA.foo(); // 打印：“InterfaceA foo”
        classA.bar(); // 打印：“AbstractClassA bar”
    }
}

　　ClassA 类中并不需要手动覆写 bar 方法，因为优先考虑到 ClassA 类继承了的 AbstractClassA抽象类中存在对 bar 方法的实现，同样的因为 AbstractClassA 抽象类中的 foo 方法是抽象的，所以在 ClassA 类中必须实现 foo 方法。

三、接口静态方法

　　Java 8 还在允许在接口中定义静态方法

interface InterfaceA {
    default void foo() {
        printHelloWorld();
    }
    
    static void printHelloWorld() {
        System.out.println("hello, world");
    }
}
 
public class Test {
    public static void main(String[] args) {
        InterfaceA.printHelloWorld(); // 打印：“hello, world”
    }
}

四、其他注意点

• default 关键字只能在接口中使用（以及用在 switch 语句的 default 分支），不能用在抽象类中。

• 接口默认方法不能覆写 Object 类的 equals、hashCode 和 toString 方法。

• 接口中的静态方法必须是 public 的，public 修饰符可以省略，static 修饰符不能省略。

• 即使使用了 java 8 的环境，一些 IDE 仍然可能在一些代码的实时编译提示时出现异常的提示（例如无法发现 java 8 的语法错误），因此不要过度依赖 IDE。