45. 接口默认实现与冲突

接口也能有方法体了

早期 C# 的接口只能声明成员，所有实现都要落到类上。C# 8 起，接口可以提供默认实现（default interface methods）。实现类不写就用默认的，想改就 override 掉。

namespace CSharpDemo;

interface ILogger
{
    void Log(string msg) => Console.WriteLine($"[日志] {msg}");
}

class App : ILogger
{
    // 没写 Log，自动继承默认实现
}

new App().Log("启动完成");

默认实现非常适合“给老接口加新方法”而不破坏已有实现。旧的类不用改一行，新能力自动到手。这在维护公共库时尤其有用：你新增成员，已发布的实现类不会因为缺实现而编译失败。

为什么引入默认实现

先讲清动机。在 C# 8 之前，给一个已发布的接口新增一个成员，是一场“破坏性更新”：所有已存在的实现类都会因为“没实现新方法”而编译失败。接口一旦被广泛使用，想加功能几乎不可能。

默认实现解决了这个演进难题。它让接口的“契约”可以逐步长大，而不强制所有实现类立刻跟进。这是 C# 向 Java 8（接口默认方法）、Scala 等成熟语言借鉴的实用特性，目的是让接口既能“锁契约”又能“慢慢长”。

默认实现的限制

默认实现虽然方便，但它并不能让接口拥有状态。接口仍不能声明实例字段，默认方法里想存数据也做不到——状态只能放在实现类。

默认实现与抽象方法混用

一个接口里可以同时有“必须实现的抽象成员”和“带默认实现的成员”。实现类只对前者负责。

namespace CSharpDemo;

interface IWorker
{
    void DoWork();                 // 必须实现
    void OnDone() => Console.WriteLine("完成"); // 默认实现
}

class Worker : IWorker
{
    public void DoWork() => Console.WriteLine("干活中");
}

这让接口既能“强制核心契约”，又能“顺手提供便捷默认行为”。

派生类也能覆盖默认实现

实现类如果不满意默认行为，照样用 override 覆盖掉，和普通接口实现写法一样：

namespace CSharpDemo;

class LoudLogger : ILogger
{
    public void Log(string msg) => Console.WriteLine($"!!! {msg} !!!");
}

new LoudLogger().Log("警告"); // !!! 警告 !!!

默认实现只是“备胎”，真要定制，实现类一句话就覆盖了。

多接口同名冲突

当类同时实现两个接口，且它们有同名成员，编译器就不知道该用哪个。必须用“显式接口实现（explicit implementation）”来消歧。

namespace CSharpDemo;

interface IFlyable
{
    void Move() => Console.WriteLine("飞");
}

interface ISwimmable
{
    void Move() => Console.WriteLine("游");
}

class Duck : IFlyable, ISwimmable
{
    void IFlyable.Move() => Console.WriteLine("鸭子飞");
    void ISwimmable.Move() => Console.WriteLine("鸭子游");
}

Duck duck = new Duck();
((IFlyable)duck).Move();
((ISwimmable)duck).Move();

注意：显式实现的成员没有 public，只能通过接口类型调用，不能 duck.Move() 直接调。

冲突的决议细则

当两个接口有同名成员时，编译器不会替你随便挑一个，而是直接报错，逼你显式实现。规则是：只要任一方提供了默认实现而另一方没有，或者双方都有，你都必须用显式实现指明各自行为。

一句话：同名即冲突，冲突必显式。这是 C# 为了“不留歧义”做的硬性规定。

显式实现的另一个用途

即使没有冲突，显式实现也能用来“隐藏”某些成员，保持类的公共 API 干净。只想通过接口暴露的能力，就显式实现它。

namespace CSharpDemo;

interface IInternal
{
    void DebugOnly();
}

class Service : IInternal
{
    void IInternal.DebugOnly() => Console.WriteLine("仅供内部调试");
}

外部代码看不到 DebugOnly，只有转成 IInternal 才能用，降低了误用风险。

接口里的静态成员

接口还能定义静态成员（C# 8+），常用于提供工厂方法或运算符约定。它们通过接口名调用，不被实例继承。

namespace CSharpDemo;

interface IMath
{
    static int Add(int x, int y) => x + y;
}

int r = IMath.Add(1, 2);
Console.WriteLine(r);

何时不该用默认实现

默认实现是把双刃剑。以下情况要谨慎：

• 新项目从零设计接口：一开始就该把核心行为定为强制成员，默认实现只适合“演进老接口”，不适合当默认值随手写。
• 默认实现依赖状态：接口没字段，默认方法只能操作参数或实现类透传的数据，一旦你想“在里面记个数”，就该改用抽象类。
• 过度堆叠默认行为：接口里塞一堆默认方法，会逐渐变成“披着接口皮的抽象类”，失去轻量契约的本意，也让实现类难以预料行为。

与其他语言客观对比

Java 8 的接口默认方法（用 default 关键字）与 C# 8 的默认实现目标一致，都是为接口演进解套。C# 更彻底一点：不仅默认方法，还能有静态成员、显式实现消歧。Go 没有默认方法概念（接口纯签名），Python 的接口靠“协议/鸭子类型”约定，也不支持默认实现。可见“接口能带默认行为”是 Java/C# 这类强类型工业语言为兼容性做的务实妥协。

新手常见坑

第一，默认实现不是“多继承”。接口仍不能有字段、构造器，状态还得放在实现类。

第二，显式实现的方法无法被 override 再改，也不能有访问修饰符，调用渠道受限。

第三，冲突时若没有显式实现，编译直接报错而非随机选一个。这其实是好事，逼你明确意图。

第四，以为默认实现会自动覆盖派生接口的需求。子接口若再声明同名成员，依然要重新面对冲突。

第五，误以为能在实现类里用 base 调接口默认实现。C# 里 base 只能调基类，接口默认实现要用显式实现里转调接口的语法，二者机制不同。

最佳实践小结

• 默认实现优先用于“给已发布接口安全加新成员”，新设计别滥用。
• 接口依旧不能有状态，需要字段就用抽象类。
• 同名冲突一律用显式接口实现消歧，规则是“同名即冲突、冲突必显式”。
• 显式实现还可用于隔离内部 API，保持实现类公共面干净。
• 静态成员适合做工厂/工具约定，通过接口名调用。

动手练一练

1. 定义 ILogger 带默认 Log，让 App 不实现 Log 直接调用，体会默认兜底；再让 LoudLogger 覆盖它。
2. 写 IFlyable、ISwimmable 都含 Move() 默认实现，Duck 用显式实现分别给出飞和游，分别转型调用。
3. 尝试在 IWorker 默认方法里“记一个计数器”（想存字段），观察编译器为何拒绝，理解接口无状态的限制。

要点速记

默认实现让接口具备了有限的“演化能力”，靠 C# 8 引入，用来给老接口加功能而不破坏既有实现。但它不是多继承、不能存状态。多接口同名时必须显式实现消歧。要注意：过度使用会让接口变成“披着接口皮的抽象类”，失去轻量契约的本意。