Java 中的继承与组合：深入剖析与最佳实践

简介

在 Java 面向对象编程中，继承（Inheritance）和组合（Composition）是两个强大的概念，它们有助于实现代码的复用、提高程序的可维护性和扩展性。理解这两个概念以及如何在合适的场景中运用它们，对于开发高质量的 Java 应用至关重要。本文将详细介绍 Java 中的继承与组合，包括基础概念、使用方法、常见实践和最佳实践，并通过清晰的代码示例辅助说明。

继承的基础概念

继承是一种机制，通过它一个类（子类或派生类）可以继承另一个类（父类或基类）的属性和方法。这使得子类能够重用父类的代码，并且可以根据自身需求进行扩展和修改。在 Java 中，一个类只能继承一个父类（单继承），但可以有多层继承结构。

示例：

// 父类
class Animal {
    private String name;

    public Animal(String name) {
        this.name = name;
    }

    public void eat() {
        System.out.println(name + " is eating.");
    }
}

// 子类
class Dog extends Animal {
    public Dog(String name) {
        super(name);
    }

    public void bark() {
        System.out.println(getName() + " is barking.");
    }
}

在上述代码中，Dog 类继承自 Animal 类，因此 Dog 类拥有 Animal 类的 name 属性和 eat 方法，并且还添加了自己特有的 bark 方法。

继承的使用方法

定义父类和子类：如上述示例，使用 extends 关键字来建立继承关系。
访问父类成员：子类可以通过 super 关键字访问父类的构造函数、属性和方法。例如，在 Dog 类的构造函数中使用 super(name) 调用父类的构造函数。
方法重写（Override）：子类可以重写父类的方法，以提供自己的实现。重写的方法需要满足方法签名（方法名、参数列表、返回类型）与父类中被重写的方法相同。

class Cat extends Animal {
    public Cat(String name) {
        super(name);
    }

    @Override
    public void eat() {
        System.out.println(getName() + " is eating fish.");
    }
}

在这个例子中，Cat 类重写了 Animal 类的 eat 方法，提供了自己的实现。

组合的基础概念

组合是一种通过将其他类的对象作为当前类的成员变量来实现代码复用的方式。它强调的是 “has - a” 关系，即一个类拥有另一个类的对象。与继承不同，组合更加灵活，因为一个类可以包含多个不同类型的对象，并且可以在运行时动态地改变这些对象。

示例：

class Engine {
    public void start() {
        System.out.println("Engine started.");
    }
}

class Car {
    private Engine engine;

    public Car() {
        this.engine = new Engine();
    }

    public void startCar() {
        engine.start();
    }
}

在这个例子中，Car 类包含一个 Engine 类的对象，通过组合的方式实现了 Car 类对 Engine 类功能的使用。

组合的使用方法

定义包含对象的类：在类中声明其他类的对象作为成员变量，如 Car 类中的 Engine 对象。
初始化成员对象：通常在构造函数中实例化成员对象，如 Car 类的构造函数中创建 Engine 对象。
使用成员对象的方法：通过成员对象调用其方法来实现所需的功能，如 Car 类的 startCar 方法中调用 engine.start()。

常见实践

继承的常见实践
- 创建通用基类：当多个类有共同的属性和行为时，可以创建一个基类来封装这些共性，然后让子类继承基类。例如，在图形绘制程序中，可以创建一个 Shape 基类，包含通用的属性（如颜色、位置）和方法（如绘制），然后让 Circle、Rectangle 等子类继承自 Shape 类。
- 实现多态：通过继承和方法重写，可以实现多态性。即同一个方法调用可以根据对象的实际类型执行不同的实现。例如，创建一个 Animal 数组，其中包含 Dog 和 Cat 对象，调用 eat 方法时会根据对象的实际类型执行相应的实现。

Animal[] animals = {new Dog("Buddy"), new Cat("Whiskers")};
for (Animal animal : animals) {
    animal.eat();
}

组合的常见实践
- 封装复杂对象：当一个类的功能依赖于多个其他类的功能时，可以使用组合将这些类的对象组合在一起。例如，在一个订单系统中，Order 类可以包含 Customer、Product 和 Payment 等对象，以实现订单处理的功能。
- 实现灵活的代码结构：组合可以在运行时动态地改变对象之间的关系。例如，一个游戏角色可以在不同的情况下装备不同的武器，通过组合可以轻松实现这种灵活性。

最佳实践

继承的最佳实践
- 遵循 “is - a” 关系：只有当子类与父类之间存在真正的 “is - a” 关系时才使用继承。例如，Dog 是一种 Animal，这种关系适合使用继承。避免滥用继承，否则会导致代码结构混乱。
- 谨慎使用 protected 成员：虽然 protected 成员可以被子类访问，但过度使用会破坏封装性。尽量将父类的属性设为 private，通过 public 或 protected 方法来访问和修改。
- 避免深度继承层次：过深的继承层次会使代码难以理解和维护。尽量保持继承层次简洁，将相关的功能放在合理的层次上。
组合的最佳实践
- 优先使用组合而非继承：如果 “has - a” 关系更符合业务逻辑，应优先选择组合。组合提供了更大的灵活性，并且不会破坏封装性。
- 保持对象职责单一：每个对象应该有单一的职责，通过组合将多个职责组合在一起。这样可以提高代码的可维护性和可测试性。
- 合理控制对象生命周期：在使用组合时，需要注意对象的创建和销毁。确保成员对象在合适的时机被创建和释放，避免内存泄漏。

小结

继承和组合是 Java 中实现代码复用和提高软件设计质量的重要手段。继承通过 “is - a” 关系实现子类对父类代码的重用和扩展，而组合通过 “has - a” 关系将其他类的对象组合到当前类中。在实际开发中，需要根据具体的业务需求和代码结构选择合适的方式。遵循最佳实践可以帮助我们写出更加清晰、可维护和可扩展的代码。

参考资料

《Effective Java》 by Joshua Bloch
Oracle Java Documentation
《Java 核心技术》 by Cay S. Horstmann and Gary Cornell