接口

是什么，为什么存在

Java 接口是一种不能直接实例化的引用类型。它为一组操作命名，却不要求所有实现共享同一父类或对象布局。类可以实现多个接口，接口也可以继承多个接口，因此行为契约不必绑在单继承的类层次上。

Java 采用 名义类型（nominal typing） 。一个类即使恰好拥有同名方法，也不会自动成为某个接口的实现；源码必须通过 implements 或继承关系明确建立类型关系。这样，方法签名相同只是巧合还是有意履行契约，不需要由调用方猜测。

接口类型带来 子类型多态（subtype polymorphism） 。例如，构造器接收 ShippingRule 时，可以得到固定费率、按重量计费或测试替身，而无需知道各自的类。运行时仍在实际对象上分派实例方法；接口引用不是包裹对象的新容器。

你会在集合、比较器、监听器、服务边界和依赖注入中遇到接口。它最适合表达调用方真正依赖的能力，尤其是多个不相关类都能履行的契约。若设计主要目的是共享实例状态、构造流程或受保护的辅助代码，抽象类通常更直接。

方法签名没有写出全部行为。空值规则、参数单位、返回值含义、异常、线程安全要求和副作用都属于契约。接口位于跨团队或公共库边界时，应把这些约束写进文档和契约测试。

工作原理

类用 implements 实现接口，接口用 extends 组合其他接口。非抽象类必须为继承到的抽象实例方法提供实现，除非某个更具体的默认方法已经满足要求。接口变量可以引用任何兼容实例，但只能直接调用其静态类型公开的成员。

接口没有构造器和实例字段。字段声明隐式为 public static final，因此保存的是接口级常量引用；若该引用指向可变集合，集合本身仍可修改。把可变对象放进接口字段会制造公开的全局状态，不会因为引用是 final 就变安全。

抽象方法和默认方法隐式为 public；它们不能是 protected 或包可见。静态方法可以是 public 或 private，私有实例方法只能由接口自己的实例方法调用。实现类不能降低所实现方法的可见性。

默认方法（default method） 拥有实例方法体，可以调用其他实例方法和私有实例辅助方法。它没有自己的实例字段，所以其行为只能依赖参数、常量和接收对象通过契约暴露的状态。默认方法适合从已有原语推导便捷操作，不适合偷偷引入新的状态要求。

多个候选实例方法相遇时，编译器按下面的规则决定是否需要显式覆盖：

1. 类或父类中的具体实例方法优先于接口默认方法。
2. 一个接口比另一个更具体时，子接口声明的方法优先。
3. 两个无关接口提供冲突的默认方法时，实现类必须覆盖；覆盖体可用 InterfaceName.super.method() 选择某个直接父接口实现。

静态接口方法不参与这些规则，因为它不被子接口或实现类继承。应通过声明它的接口调用，例如 Rule.parse()，不能假设 ConcreteRule.parse() 存在。私有方法同样不被继承，也不能从实现类调用。

函数式接口（functional interface） 只有一个抽象方法契约，也称单一抽象方法（single abstract method，SAM）接口。默认、静态和私有方法不计入这个数量，签名与 Object 的公开实例方法对应的方法也有专门的排除规则。@FunctionalInterface 不是必须的，但它会让编译器在契约不再满足时立即报错。

Lambda 表达式和方法引用需要目标类型；目标函数式接口决定参数与返回类型。这种从函数值到 SAM 接口实例的适配常称为 SAM 转换（SAM conversion） 。Lambda 只提供那个函数方法的实现，接口中的默认方法仍然可用。

示例

下面三个程序从替代实现开始，再处理默认方法冲突，最后构造函数式接口组合。输出由本地 OpenJDK 21.0.12 使用 javac --release 21 -Xlint:all 编译并执行得到；所用语法和接口规则在目标 Java 25 中保持有效。

用接口隔离调用方与实现

计费函数只接收 ShippingRule。两个记录类保存不同数据并实现同一操作，而默认方法根据实际类给出诊断名称。

List.<ShippingRule>of(...) 明确把两个不同记录视为同一接口类型。循环中的调用仍落到各自的 feeInCents() 实现，label() 则复用接口中的默认实现。调用方无需用 instanceof 分支识别每个计费类。

这个接口尚未约束费率必须非负，第三个试验会暴露该缺口。约束属于记录构造器还是规则方法要由领域契约决定；仅把实现藏在接口后面不会自动验证对象状态。

解决默认方法的优先级与冲突

Child 同时继承父类方法和接口默认方法，类方法获胜。Transfer 实现两个无关接口，必须显式覆盖冲突的方法。

public class DispatchRules {
    static class Parent {
        public String source() {
            return "class";
        }
    }

    interface Named {
        default String source() {
            return "interface";
        }
    }

    static final class Child extends Parent implements Named {}

    interface Fast {
        default String mode() {
            return "fast";
        }
    }

    interface Safe {
        default String mode() {
            return "safe";
        }
    }

    static final class Transfer implements Fast, Safe {
        @Override
        public String mode() {
            return Fast.super.mode() + "+" + Safe.super.mode();
        }
    }

    public static void main(String[] args) {
        System.out.println(new Child().source());
        System.out.println(new Transfer().mode());
    }
}

class
fast+safe

删除 Transfer.mode() 会产生编译错误，而不是在运行时随意选择一个默认实现。Fast.super.mode() 只能限定直接父接口，不能把任意祖先接口当作普通静态工具类调用。

Child 没有覆盖 source()，但父类提供的具体方法已经满足 Named 契约。父类甚至不必声明 implements Named；只要继承到的方法签名与可见性符合要求，子类声明就能建立接口关系。

组合函数式接口

Rule<T> 只有 test() 一个抽象方法，所以 Lambda 可以实现它。默认方法 and() 返回另一个 Rule<T>，静态方法提供一个有名称的基础规则。

import java.util.Objects;

public class ValidationPipeline {
    @FunctionalInterface
    interface Rule<T> {
        boolean test(T value);

        default Rule<T> and(Rule<? super T> other) {
            Objects.requireNonNull(other);
            return value -> test(value) && other.test(value);
        }

        static Rule<String> notBlank() {
            return value -> value != null && !value.isBlank();
        }
    }

    public static void main(String[] args) {
        Rule<String> accountName = Rule.<String>notBlank()
                .and(value -> value.startsWith("acct-"));

        System.out.println(accountName.test("acct-alice"));
        System.out.println(accountName.test("   "));
        System.out.println(accountName.test("guest"));
    }
}

true
false
false

and() 使用短路求值。空白字符串在第一条规则处失败，不会执行 startsWith()；null 也不会进入第二条规则。这项行为是组合器契约的一部分，应像参数类型一样接受测试。

给 Rule 增加第二个不等价的抽象方法会让 @FunctionalInterface 声明和所有 Lambda 目标一起失效。增加默认或静态方法不会改变函数描述符，但新默认方法仍可能与其他接口产生名称冲突。

把静态工厂与私有辅助方法留在接口中

静态工厂可以把简单实现藏在接口后面，默认方法则可复用私有辅助逻辑。两种方法都不会增加函数式接口的抽象方法数量。

import java.util.Locale;
import java.util.Objects;

public class InterfaceHelpers {
    @FunctionalInterface
    interface AccountId {
        String raw();

        default String normalized() {
            return normalize(raw());
        }

        static AccountId of(String raw) {
            Objects.requireNonNull(raw);
            return () -> raw;
        }

        private static String normalize(String raw) {
            return raw.strip().toLowerCase(Locale.ROOT);
        }
    }

    public static void main(String[] args) {
        AccountId account = AccountId.of(" ACCT-42 ");
        System.out.println(account.normalized());
        System.out.println(AccountId.of(" JOB-7 ").raw().strip());
    }
}

acct-42
JOB-7

of() 必须通过 AccountId 调用，因为静态接口方法不被实现对象继承。normalize() 只能由接口内部调用，它允许默认方法共享实现，却没有扩大实现类或调用方可见的 API。

陷阱

把可变对象当作接口常量

修复方法： 接口只暴露真正不可变的值，并优先把配置与状态交给实现对象的构造器。若常量只供接口内部实现使用，放入私有静态方法或单独的内部实现类，避免扩大公共 API。

设计调用方无法履行的大接口

修复方法： 按调用方需要拆分能力，并应用 接口隔离原则（interface segregation principle） 。让方法参数依赖最小接口；确需成组能力时，再用子接口组合它们。

用默认方法隐藏失败策略

修复方法： 默认方法只组合已有操作，并保留原契约的失败语义。跨网络重试、授权失败与事务回滚应由拥有上下文的调用层决定；为正常缺失设计显式返回类型，不要吞掉意外异常。

假设默认方法自动向后兼容

修复方法： 用旧实现二进制运行兼容测试，再对全部实现与调用方做干净重编译。检查同名方法、返回类型、异常与副作用；公共接口变更需要发布说明和迁移路径。

把静态方法当作继承成员

修复方法： 始终用声明接口限定静态方法。若工厂必须根据实现类型变化，把创建行为放进独立工厂接口、构造器或注册表，不要试图用静态方法模拟多态分派。

延伸阅读

• Java 语言规范 25：接口成员
• Java 语言规范 25：继承覆盖等价签名的方法
• Java 语言规范 25：函数式接口
• Java 语言规范 25：接口方法演进
• Dev.java：定义接口