Java继承与接口：extends和implements怎么选？

extends用于实现类间“is-a”关系，强调代码复用与层次结构表达，适用于存在明确继承关系且需共享实现的场景；implements用于实现接口定义的“can-do”契约，强调多态与解耦，适用于不同类共享行为规范的场景。1.extends核心优势在于提供代码复用机制和清晰层次结构，适合强烈的“is-a”关系、代码复用、扩展现有功能及抽象基类设计；2.implements通过接口实现多态性和解耦，使客户端代码仅依赖接口而非具体类，提高系统灵活性和可扩展性；3.Java 8/9引入默认方法、静态方法和私有方法增强了接口功能，但未改变extends与implements的核心语义，选择时仍需根据设计意图判断是继承身份还是实现行为契约。

Java中，extends 用于实现类之间的继承关系，表达“is-a”的语义，即子类是父类的一种特殊类型，它继承了父类的所有非私有成员。而 implements 用于实现接口，表达“can-do”或“has-a-capability”的语义，即一个类承诺实现某个接口定义的所有行为，但不关心它“是什么”。选择哪个取决于你想要表达的设计意图和系统结构。

解决方案

说实话，这其实是个老生常谈的问题，但每次聊起来都还是挺有意思的，因为它触及了面向对象设计最核心的部分。我个人觉得，理解 extends 和 implements 的关键在于它们各自代表的“契约”和“关系”。

当你使用 extends 时，你是在说：“我这个新类，它就是你那个老类的一个更具体的版本。” 比如，你有一个 Animal 类，然后你创建了一个 Dog 类，Dog extends Animal，这很自然。狗是一种动物，它继承了动物的特性（比如有生命、会呼吸），然后在此基础上增加了自己的特性（比如会吠叫）。这里面包含着代码的复用，子类可以直接使用父类的方法和属性，甚至可以重写（override）父类的方法来表现自己的独特行为。但要注意，Java是单继承的，一个类只能 extends 一个父类，这意味着你的“血统”是唯一的。这种强绑定带来了代码复用上的便利，但有时候也会导致耦合度较高，尤其是在类层次结构设计不当的时候。

而 implements 则完全是另一种哲学。它代表的是一种“能力”或者“行为契约”。当你 implements 一个接口时，你是在承诺：“我这个类，不管我是谁，我都能做到这个接口里定义的所有事情。” 比如，你有一个 Flyable 接口，里面定义了一个 fly() 方法。现在 Bird 可以 implements Flyable，Airplane 也可以 implements Flyable。鸟和飞机在本质上是完全不同的东西，它们没有继承关系，但它们都具备“飞行”的能力。接口强制你实现它定义的所有抽象方法，这确保了多态性，因为你可以通过接口类型来操作任何实现了该接口的对象，而无需关心它们的具体实现细节。这大大降低了类之间的耦合，提高了系统的灵活性和可扩展性。你甚至可以实现多个接口，一个类既能飞又能跑（implements Flyable, Runnable），这在某种程度上弥补了Java单继承的限制。

总结一下，如果你的类之间存在明确的“is-a”层次结构，并且你想复用父类的实现，那就用 extends。如果你的类之间没有直接的继承关系，但它们需要共享某种行为规范或能力，或者你想实现多态和解耦，那么 implements 就是你的首选。

extends 的核心优势与适用场景是什么？

extends 的核心优势在于它提供了一种强大的代码复用机制和清晰的层次结构表达。当一个类 extends 另一个类时，子类自动获得了父类的所有非私有成员（字段和方法）。这意味着你不需要在子类中重新编写父类已经实现的功能，可以直接继承并使用。这在构建复杂的软件系统时非常有用，比如你有一个基础的 User 类，包含了用户名、密码等通用信息，然后你可以派生出 AdminUser 和 GuestUser，它们都继承了 User 的基本功能，再各自添加特有的权限或行为。

适用场景通常是：

• 强烈的“is-a”关系： 当你能够明确地说“A是一种B”时，比如“轿车是一种汽车”，“圆形是一种形状”。这种关系通常是稳定的，不会轻易改变。
• 代码复用： 当多个子类需要共享大部分相同的实现逻辑时，将其放在一个父类中，子类继承即可避免代码重复。
• 扩展现有功能： 你想在不修改原有类代码的基础上，增加新的功能或修改部分行为（通过方法重写）。这符合开放-封闭原则（OCP），即对扩展开放，对修改封闭。
• 抽象基类： 当你需要定义一个通用的模板，其中包含一些具体实现和一些需要子类去完成的抽象方法时，可以使用抽象类（abstract class）并让其他类去 extends 它。这提供了一种半成品的设计，既有骨架也有肉。

我发现很多初学者，甚至是一些有经验的开发者，有时候会滥用继承，导致类层次结构过于深，或者出现“继承爆炸”的问题，即为了复用一点点代码就引入了继承，最终使得系统变得僵硬且难以维护。所以，在使用 extends 之前，最好问问自己：这真的是一个“is-a”关系吗？

// 示例：extends 的应用
class Vehicle {
    protected String brand;

    public Vehicle(String brand) {
        this.brand = brand;
    }

    public void start() {
        System.out.println(brand + " vehicle started.");
    }

    public void stop() {
        System.out.println(brand + " vehicle stopped.");
    }
}

class Car extends Vehicle {
    private int numberOfDoors;

    public Car(String brand, int numberOfDoors) {
        super(brand); // 调用父类构造器
        this.numberOfDoors = numberOfDoors;
    }

    // 重写父类方法
    @Override
    public void start() {
        System.out.println(brand + " car engine purrs and starts.");
    }

    public void drive() {
        System.out.println(brand + " car is driving with " + numberOfDoors + " doors.");
    }
}

// 使用
// Car myCar = new Car("Toyota", 4);
// myCar.start(); // 输出：Toyota car engine purrs and starts.
// myCar.drive(); // 输出：Toyota car is driving with 4 doors.

implements 如何实现多态与解耦？

implements 在Java中是实现多态和解耦的基石，它提供了一种非常灵活的机制来定义行为契约。当一个类 implements 一个接口时，它必须提供接口中所有抽象方法的具体实现。这就像签了一份合同，你承诺会完成合同里列出的所有工作。

• 多态性： 这是 implements 最强大的特性之一。通过接口，你可以编写出能够处理多种不同类型对象的通用代码。只要这些对象都实现了同一个接口，你就可以把它们当作该接口的类型来处理。例如，你有一个 Printable 接口，Document 类和 Image 类都实现了它。那么你可以有一个 printAll(List items) 方法，它能打印任何实现了 Printable 接口的对象，而无需知道这些对象是文档还是图片。这种“向上转型”的能力，让代码变得非常灵活和可扩展。

• 解耦： 接口将“做什么”与“如何做”分离开来。客户端代码只需要知道它需要一个实现特定接口的对象，而不需要知道这个对象的具体类是什么。这意味着你可以轻松地替换掉某个接口的实现，而不需要修改依赖于该接口的客户端代码。这对于单元测试、模块化开发以及大型系统的维护都至关重要。比如，你有一个 Logger 接口，它有 logInfo()、logError() 等方法。你可以有 FileLogger、DatabaseLogger、ConsoleLogger 等多种实现。你的应用程序代码只需要依赖 Logger 接口，具体使用哪个实现可以在运行时配置，或者通过依赖注入框架来管理。这种设计模式让系统组件之间的依赖关系变得松散，降低了修改一个组件对其他组件的影响。

所以，当你在设计系统时，如果某个功能可以有多种不同的实现方式，或者你需要定义一组行为规范，而不想限制具体实现类的继承关系，那么接口就是最佳选择。它鼓励“面向接口编程”，这是构建健壮、可维护和可扩展系统的关键。

// 示例：implements 的应用
interface Drivable {
    void accelerate();
    void brake();
}

class SportsCar implements Drivable {
    @Override
    public void accelerate() {
        System.out.println("SportsCar: Vroom! Accelerating fast!");
    }

    @Override
    public void brake() {
        System.out.println("SportsCar: Screech! Braking hard!");
    }
}

class Truck implements Drivable {
    @Override
    public void accelerate() {
        System.out.println("Truck: Slowly gaining speed.");
    }

    @Override
    public void brake() {
        System.out.println("Truck: Grinding to a halt.");
    }
}

// 使用多态
// public void testDrive(Drivable vehicle) {
//     vehicle.accelerate();
//     vehicle.brake();
// }
//
// Drivable mySportsCar = new SportsCar();
// Drivable myTruck = new Truck();
//
// testDrive(mySportsCar); // 调用 SportsCar 的方法
// testDrive(myTruck);     // 调用 Truck 的方法

Java 8/9 之后，接口的新特性如何影响 extends 与 implements 的选择？

Java 8 和 Java 9 为接口引入了一些非常重要的特性，这在一定程度上模糊了接口和抽象类之间的界限，但并没有从根本上改变 extends 和 implements 的核心设计哲学。

Java 8 引入的特性：

• 默认方法（Default Methods）： 接口现在可以包含带有具体实现的 default 方法。这意味着你可以在不破坏现有实现类的情况下，为接口添加新方法。如果一个类实现了包含默认方法的接口，它可以选择不重写该默认方法，直接使用接口提供的默认实现，也可以重写它。
• 静态方法（Static Methods）： 接口也可以包含静态方法。这些方法属于接口本身，而不是任何实现该接口的对象。它们通常用于提供与接口相关的工具方法。

Java 9 引入的特性：

• 私有方法（Private Methods）： 接口可以包含私有方法，包括静态私有方法。这些私有方法主要用于在接口内部，为默认方法或静态方法提供辅助功能，避免代码重复。

这些新特性让接口变得更加强大和灵活。以前，如果想在接口中提供一些公共的、可复用的逻辑，你可能不得不创建一个抽象类。但现在，通过默认方法，接口也能提供一部分实现。这在某些场景下，确实减少了对抽象类的依赖，因为接口也能提供某种程度的代码复用。

对选择的影响：

• 接口的“能力”增强： 默认方法让接口在定义行为契约的同时，也能提供一些通用的、默认的行为实现。这对于库和框架的维护者来说非常方便，他们可以在不破坏兼容性的前提下扩展接口。
• 抽象类与接口的区分依然存在： 尽管接口有了默认方法，但它仍然不能有实例字段（非 static final 字段），也不能有构造器。抽象类则可以拥有这些。所以，如果你的基类需要维护状态（实例字段）或需要复杂的初始化逻辑（构造器），那么抽象类（通过 extends）仍然是更合适的选择。
• 核心语义不变： extends 依然强调“is-a”的层次结构和实现继承，而 implements 依然强调“can-do”的行为契约和多态性。默认方法只是为接口提供了一种“可选的”行为实现，而不是强制的“身份”继承。

所以，我的看法是，这些新特性并没有颠覆 extends 和 implements 的基本选择原则。它们更多地是作为一种工具，让你在设计时有更多的选择，尤其是在处理接口演进和提供通用实用方法时。但在决定是建立“is-a”关系还是“can-do”能力时，你依然需要回到最初的那个问题：你的设计意图是什么？是继承身份和状态，还是实现行为契约？这才是关键。