[JDK/8/17] 深度解析: Java 关键字(`default`)之接口级 default 方法: 接口方法的默认实现 [JDK8-]

0 序

  • 公司项目上从 JDK 8 切换到了 JDK 17,这是一个大踏步。
  • 但此篇,我主要需了解一下 JDK 8 中,先前没有使用过的 接口前带 default 关键词的语法糖的特性。

先对齐概念: 对从 JDK 8 升到 JDK 17 的开发团队很关键

  • default 不是“一个特性”,它在 Java 里有 4 个不同位置的含义:
出现位置 含义 起始版本
接口方法前 default 返回类型 m(){} 接口方法【带默认实现】,实现类可以不写 JDK 8
switch 分支 default: / default -> 兜底分支 老语法就有;switch 表达式里用它是 JDK 14 正式
注解属性后 int times() default 3; 注解属性的默认值 一直都有
什么都不写时(package 级别的私有) 不是关键字,只是“默认访问级别”的口语说法 —

我说的“default 特性”通常指第1个。
注意:接口 default 方法是 JDK 8 就有的,不是换到 17 才出现的新能力——在写 JDK 8 代码时它已经可用。8→17 之间真正新增的只有两项:接口 private 方法(JDK 9)、switch 表达式里的 default 分支(JDK 14)。

1 Java 的 接口 default 特性: 接口的默认实现方法

为什么需要它:一次不破坏兼容的接口升级

  • JDK 8 之前接口只能有【抽象方法】。想给 List 加 sort(),全世界所有 List 实现类都得改,否则【编译失败】。default 方法就是为了解决这个问题:【接口】可以有【方法体】,【老实现类】可不动。

  • JDK 自己就是这么干的。我用反射在 17 上逐个查过 Method.isDefault(),全部为 true:

Iterator.forEachRemaining  isDefault=true
Iterable.forEach           isDefault=true
Collection.stream          isDefault=true
Collection.removeIf        isDefault=true
List.sort                  isDefault=true
Map.getOrDefault           isDefault=true
Map.forEach                isDefault=true
Comparator.reversed        isDefault=true
Comparator.thenComparing   isDefault=true
Predicate.negate / and     isDefault=true
Function.andThen           isDefault=true

这就是 JDK 8 之后你能直接 list.forEach(...)、map.getOrDefault(...) 的原因——ArrayList 并没有逐个实现这些方法。

示例 1:最基础形态

interface Shape {
    double area();                                  // 抽象方法:实现类必须写

    default String describe() {                     // default 方法:有默认实现
        return getClass().getSimpleName() + "(area=" + String.format("%.2f", area()) + ")";
    }
}

class Circle implements Shape {
    private final double r;
    Circle(double r) { this.r = r; }

    @Override
    public double area() { return Math.PI * r * r; }
    // 故意不实现 describe(),直接用接口给的默认实现
}

class Rectangle implements Shape {
    private final double w, h;
    Rectangle(double w, double h) { this.w = w; this.h = h; }

    @Override
    public double area() { return w * h; }

    @Override
    public String describe() { return "Rectangle(" + w + "x" + h + ")"; }  // 也可以覆写
}

运行输出:

Circle(area=12.57)
Rectangle(3.0x4.0)
12.566370614359172

三个要点:

  • default 方法是虚方法,按实际对象类型分派;
  • 实现类覆写时照常加 @Override;describe() 里能用 getClass(),因为它【本质】上是【实例方法】,不是【静态代码】。

示例 2:default 之间复用逻辑 —— 接口 private 方法(JDK 9 起,升 17 后就有)

  • 这是 JDK 8 做不到的: 8 里两个 default 方法想共用一段工具逻辑,只能要么复制代码,要么暴露一个 public 方法污染 API。

9 开始接口可以写 private(含 private static):

interface PriceCalculator {
    double basePrice();                              // 唯一的抽象方法

    default double withTax()         { return round(basePrice() * 1.13); }
    default double withDiscount(double rate) { return round(basePrice() * (1 - rate)); }

    // 只给上面两个 default 共用的工具方法,不暴露给实现类
    private double round(double v) { return Math.round(v * 100) / 100.0; }

    // 接口的 static 方法:属于接口本身,不被实现类继承
    static PriceCalculator ofFixed(double p) {
        return () -> p;                              // 只有一个抽象方法 => 仍是函数式接口
    }
}

class Book implements PriceCalculator {
    private final double price;
    Book(double price) { this.price = price; }
    @Override public double basePrice() { return price; }
}

输出 112.89 / 79.92 / 56.5 / 45.0。

顺带一个容易踩的点:default 方法不参与“抽象方法个数”统计,所以 PriceCalculator 有 3 个 default 仍能当函数式接口用 lambda 实现,ofFixed 里那句 () -> p 就是证据。

示例 3:多个 default 撞名时的三条裁决规则

interface Walk { default String move() { return "walk"; } }
interface Ride { default String move() { return "ride"; } }

// 规则一:两个接口地位平等 -> 必须自己显式解决
class Walker implements Walk, Ride {
    @Override
    public String move() {
        return Walk.super.move() + " + " + Ride.super.move();   // X.super.m() 精确指定
    }
}

// 规则二:父类方法优先于任何接口 default
class Animal { public String move() { return "animal"; } }
class Dog extends Animal implements Walk { }   // 不覆写也编译通过,Animal 的 move() 生效

// 规则三:子接口的 default 覆盖父接口的 default
interface Swim extends Walk { @Override default String move() { return "swim"; } }
class Fish implements Swim { }

输出 walk + ride / animal / swim。

我实际把“规则一”里那个 move() 覆写删掉后编译,javac 原话是:

error: types P and Q are incompatible;
  class NegAmbiguous inherits unrelated defaults for tag() from types P and Q

示例 4:工程里真正好用的两种写法

@FunctionalInterface
interface Discount {
    double apply(double price);                       // 唯一抽象方法 => 可 lambda

    // 用 default 做组合:两个折扣串起来
    default Discount andThen(Discount next) { return price -> next.apply(apply(price)); }

    // 用 default 做兜底:封顶
    default Discount cappedAt(double max) { return price -> Math.min(apply(price), max); }

    static Discount none() { return p -> p; }
}

// API 平滑演进:老接口只声明抽象方法,后来新增的能力用 default
interface Exporter {
    String export(String item);
    default String exportAll(List<String> items) {
        return items.stream().map(this::export).collect(Collectors.joining("|"));
    }
}
Discount chain = ((Discount) p -> p * 0.9).andThen(p -> p - 10).cappedAt(200);
System.out.println(chain.apply(300));   // 200.0  先九折270,再减10=260,封顶200
System.out.println(chain.apply(100));   // 80.0   90 - 10

输出 200.0 / 80.0 / CSV:a|CSV:b|CSV:c。

这两种是 default 最值钱的场景:策略组合(把通用编排沉到接口里) 和 API 向后兼容演进。之前的“替代抽象类的模板方法”那种用法也是同理。

示例 5:switch 里的 default(JDK 14 正式)

enum Level { LOW, MED, HIGH }

static int weight(Level level) {
    return switch (level) {                       // switch 表达式:本身返回一个值
        case LOW  -> 1;
        case MED  -> 5;
        case HIGH -> 10;
        default   -> throw new IllegalArgumentException("unknown: " + level);
    };
}

static void printOld(Level level) {
    switch (level) {                              // 老语法:default 后面是冒号
        case LOW:  System.out.println("low"); break;
        default:   System.out.println("not-low");
    }
}

区别:箭头式 switch 是表达式,没有 fall-through、不写 break、必须穷尽(枚举情况全列出时 default 可省,但写上更安全)。这是从 8 到 17 最值得用起来的新语法之一。

示例 6:注解里的 default

@Retention(RetentionPolicy.RUNTIME)      // 反射读注解值必须加
@interface Retry {
    int times() default 3;
    long delayMs() default 100L;
    String reason() default "";
}

@Retry class SimpleService {}
@Retry(times = 5, reason = "network jitter") class RemoteService {}
SimpleService -> times=3, delayMs=100, reason=''
RemoteService -> times=5, delayMs=100, reason='network jitter'
Retry.times() default = 3

这里第一版漏了 @Retention(RUNTIME),getAnnotation 直接返回 null 抛 NPE——注解默认值是给编译器和反射读的,没有 RUNTIME 保留策略就读不到,写自定义注解时注意。

踩坑清单

都是在JDK17 机器上真跑出来的。

写法 结果(javac 原文)
default String toString(){} default method toString in interface X overrides a member of java.lang.Object
default static void x(){} illegal combination of modifiers: static and default
default abstract void x(); illegal combination of modifiers: abstract and default
default final void x(){} modifier final not allowed here
两接口同名 default 且类未解决 inherits unrelated defaults for tag() from types P and Q
想借 X.super.m() 调非直接父接口 编译错,只能调直接父接口
default 方法里想用实现类的实例字段 做不到——接口没有实例字段,只能靠抽象方法/参数

另外两条设计层面的:default 方法不能覆写 Object 的 equals/hashCode/toString(上表第一条就是它,因为接口不能决定对象身份语义);所以别指望用 default 给所有实现类统一 toString。

落地建议

  • 该用:接口演进(新增便捷方法)、策略/组合编排、把通用样板逻辑沉到接口(JDK 9 的 private 方法让它更干净)、函数式接口上的组合器(andThen、negate 这类)。
  • 别用:把业务主体逻辑塞进 default 假装它是抽象类——一旦需要状态(字段)就露馅;也别用 default 掩盖“这个接口其实该拆成两个”的问题。
  • 从 8 升 17,除了 default,更该顺手捡起来的是:var、switch 表达式、record、instanceof 模式匹配、文本块、List.of/Map.of。这些才是 17 真给我们的新东西。

Y 推荐文献

X 参考文献

posted @ 2026-11-09 16:32  千千寰宇  阅读(13)  评论(0)    收藏  举报