46. 接口默认方法与静态方法（default / static）

一个真实的麻烦

在 Java 8 之前，接口里只有抽象方法。这带来一个尴尬：假如你发布了一个接口 DoIt，全公司有 100 个类实现了它。某天你想给接口加一个新方法，编译器会立刻让那 100 个类全部报错——因为它们都没实现这个新方法。

要么逼着所有人改代码，要么另起一个 DoItPlus 接口继承它。无论哪种，都很折腾。

Java 8 给出的解法是：允许接口里写带方法体的 default 方法。这样老接口加新功能，已有的实现类一行都不用改，自动「白捡」一份默认实现。

default 方法怎么写

在方法前加 default 关键字，再写上方法体：

interface DoIt {
    void doSomething(int i, double x);
    int doSomethingElse(String s);

    // 新方法，带默认实现
    default boolean didItWork(int i, double x, String s) {
        System.out.println("默认实现：假装成功了");
        return true;
    }
}
```java

所有实现了 `DoIt` 的老类，不用动任何代码，就能直接调用 `didItWork()`。新写的类也可以直接复用这份默认逻辑，或者自己重写它。

```java
class MyImpl implements DoIt {
    @Override
    public void doSomething(int i, double x) { }

    @Override
    public int doSomethingElse(String s) { return 0; }

    // didItWork 不重写也没关系，自动用接口的默认实现
}

static 方法：把工具方法收进接口

除了 default，Java 8 还允许接口里写 static 方法（有方法体，属于接口本身，不依赖某个实例）：

interface MathTools {
    static int max(int a, int b) {
        return a > b ? a : b;
    }
}

// 调用时直接用接口名
int m = MathTools.max(3, 7);
```bash

以前这类工具方法只能孤零零地扔在一个独立的 `XxxUtils` 类里。现在把它们和相关的接口放一起，逻辑更聚合，调用也更直观。

> [!TIP]
> 经验法则：如果这个工具方法只服务于某个接口的能力（比如各种比较器工厂方法），就写成接口的 `static` 方法；如果和接口无关，才单独建工具类。

## 菱形冲突：多个同名 default 怎么办

`default` 方法一多，就可能出现「一个类实现了两个接口，两个接口都有同名同参数的 `default` 方法」的菱形冲突。

```java
interface A {
    default void hello() { System.out.println("A"); }
}

interface B {
    default void hello() { System.out.println("B"); }
}

class C implements A, B {
    // 编译错误：不知道该用 A 还是 B 的 hello()
}

编译器不会替你猜，必须由子类自己重写来明确选择：

class C implements A, B {
    @Override
    public void hello() {
        // 显式指定用哪个父接口的默认实现
        A.super.hello();
    }
}
```bash

通过 `A.super.hello()`（或 `B.super.hello()`）可以精确调用某个父接口的默认实现，也可以完全自己写新逻辑。

> [!WARNING]
> 冲突只在「两个 `default` 方法签名相同」时发生。如果其中一个是抽象方法（没有 `default`），那么子类实现这个抽象方法即可，不会冲突。类里的**具体方法**优先级也高于接口的 `default` 方法——如果父类（class）已经实现了该方法，接口的 `default` 就被忽略。

## 接口继承时的 default 三种命运

当一个接口继承另一个带 `default` 方法的接口时，子接口可以：

1. **什么都不做**：直接继承父接口的默认实现。
2. **重新声明为抽象**：把 `default` 方法去掉方法体、写成 `abstract`，强迫下游实现类必须自己实现。
3. **重新定义**：再写一个 `default` 方法覆盖掉父接口的版本。

```java
interface Base {
    default void show() { System.out.println("Base"); }
}

interface Child extends Base {
    @Override
    default void show() { System.out.println("Child 覆盖"); }
}

private 方法：Java 9 补上的一块拼图

default 方法一多，就会冒出重复代码。比如两个 default 方法都要做同一段拼装，总不能复制两遍。

Java 9 起，接口允许写 private 方法，专门给接口内部的 default / static 方法抽公共逻辑：

interface Logger {
    default void info(String msg)  { log("INFO", msg); }
    default void error(String msg) { log("ERROR", msg); }

    // private 方法：只给接口内部用，实现类看不见、也不能重写
    private void log(String level, String msg) {
        System.out.println("[" + level + "] " + msg);
    }
}
```bash

三条规矩记住：`private` 方法必须带方法体；不能被实现类继承或重写；`private static` 方法只能被接口里的 `static` 方法调用。

> [!NOTE]
> 接口成员的开放程度是一版一版放宽的：Java 7 及以前只有抽象方法和常量，Java 8 加了 `default` / `static`，Java 9 加了 `private`。本教程基线 Java 25，三样都能用。

## 完整可运行示例

```java
interface Greeting {
    void sayHello();

    default void sayBye() {
        System.out.println("默认：拜拜");
    }

    static String make(String name) {
        return "你好，" + name;
    }
}

class Chinese implements Greeting {
    @Override
    public void sayHello() {
        System.out.println(Greeting.make("世界"));
    }
}

public class Main {
    public static void main(String[] args) {
        Chinese c = new Chinese();
        c.sayHello();
        c.sayBye();          // 用接口的默认实现
        System.out.println(Greeting.make("Java"));  // 调静态方法
    }
}

default 方法的真实价值：库作者的救命稻草

站在写「被很多人用的库」的角度看，default 方法几乎是必选项。Java 自己的 Collection、Comparator 等接口在 Java 8 都靠它添加 stream()、comparing() 等新能力，而无数老代码一行没改就直接享受了新功能。如果没有 default，任何一次接口升级都是「全民改代码」的灾难。

常见疑问

Q：default 方法和抽象类里的普通方法有什么区别？

最根本的差别是状态。抽象类有实例字段，普通方法能读写这些字段；接口没有实例字段，default 方法只能靠参数和常量干活。要维护对象状态，就得用抽象类。

Q：实现类里能用 super.hello() 调接口的默认方法吗？

不能，必须写成 接口名.super.hello()。裸的 super 指向的是父类（没写父类时就是 Object），跟接口没有半点关系。

Q：Object 已有的方法能写成 default 吗？

不能。toString()、equals()、hashCode() 这几个在接口里写 default 会直接编译报错。原因是任何对象都继承自 Object，类里的实现永远优先，接口写了也是白写。

小结

• default 方法（Java 8 引入）让老接口能加新方法而不破坏已有实现；写法是在方法前加 default 并提供方法体。
• static 方法（Java 8 引入）属于接口本身，用 接口名.方法() 调用，适合放相关工具方法。
• 多个接口的 default 方法冲突时，子类必须重写，可用 接口名.super.方法() 指定调用哪一个。
• 类的具体方法优先级高于接口 default 方法。
• default/static 的出现，让接口从「纯约定」变成了「能携带实现的约定」，是 Java 函数式编程（如 Comparator 大量增强）的基础设施。

下一章我们学习函数式接口和 Lambda，你会看到 default/static 方法和单一抽象方法的接口如何配合，让 Java 也能写得简洁又现代。