Inheritance vs Composition in Java: 深入剖析与实践

简介

在 Java 编程中，Inheritance（继承）和 Composition（组合）是两种用于实现代码复用和构建对象关系的重要技术。理解它们的概念、使用方法以及在不同场景下的应用，对于编写高质量、可维护的 Java 代码至关重要。本文将详细探讨这两种技术，通过清晰的代码示例展示其用法，并给出常见实践和最佳实践建议。

Inheritance 基础概念

继承是 Java 面向对象编程中的一种机制，允许一个类（子类）继承另一个类（父类）的属性和方法。通过继承，子类可以复用父类的代码，并且可以根据需要进行扩展或重写。这有助于创建一个类层次结构，提高代码的可维护性和可扩展性。

例如，有一个 Animal 类作为父类，具有 eat 方法：

public class Animal {
    public void eat() {
        System.out.println("The animal is eating.");
    }
}

然后有一个 Dog 类继承自 Animal 类：

public class Dog extends Animal {
    public void bark() {
        System.out.println("The dog is barking.");
    }
}

在这个例子中，Dog 类继承了 Animal 类的 eat 方法，同时还拥有自己特有的 bark 方法。

Composition 基础概念

组合是一种通过将其他对象作为成员变量包含在一个类中来实现代码复用的技术。一个类可以由多个不同类型的对象组成，这些对象之间是一种 “has-a” 的关系。与继承不同，组合强调的是对象的聚合，而不是类的层次结构。

例如，有一个 Engine 类：

public class Engine {
    public void start() {
        System.out.println("The engine is starting.");
    }
}

然后有一个 Car 类，它包含一个 Engine 对象：

public class Car {
    private Engine engine;

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

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

在这个例子中，Car 类通过组合 Engine 类来实现启动功能，Car 类 “拥有” 一个 Engine 对象。

Inheritance 使用方法

定义父类

public class Shape {
    public void draw() {
        System.out.println("Drawing a shape.");
    }
}

定义子类

public class Circle extends Shape {
    @Override
    public void draw() {
        System.out.println("Drawing a circle.");
    }
}

使用继承

public class Main {
    public static void main(String[] args) {
        Shape shape = new Shape();
        shape.draw(); 

        Shape circle = new Circle();
        circle.draw(); 
    }
}

在这个例子中，Circle 类继承了 Shape 类的 draw 方法，并对其进行了重写。在 main 方法中，可以看到不同类型对象调用 draw 方法的不同行为。

Composition 使用方法

定义组件类

public class Wheel {
    public void rotate() {
        System.out.println("The wheel is rotating.");
    }
}

定义包含组件的类

public class Bicycle {
    private Wheel wheel;

    public Bicycle() {
        this.wheel = new Wheel();
    }

    public void ride() {
        wheel.rotate();
        System.out.println("Riding the bicycle.");
    }
}

使用组合

public class Main {
    public static void main(String[] args) {
        Bicycle bicycle = new Bicycle();
        bicycle.ride(); 
    }
}

在这个例子中，Bicycle 类通过组合 Wheel 类来实现骑行功能，在 ride 方法中调用了 Wheel 类的 rotate 方法。

常见实践

Inheritance 常见实践

创建类层次结构：用于建模具有明显父子关系的对象，如 Employee 类和 Manager 类，Manager 类继承自 Employee 类，继承其基本属性和方法，并可能添加管理相关的功能。
代码复用：子类复用父类的代码，减少重复代码。例如，多个图形类（Circle、Rectangle 等）继承自 Shape 类，复用 Shape 类的通用方法。

Composition 常见实践

对象聚合：用于构建复杂对象，如 Computer 类包含 CPU、Memory、HardDrive 等对象，通过组合这些组件来实现计算机的功能。
动态组合：在运行时根据不同需求组合不同的对象，提高代码的灵活性。例如，一个游戏角色可以在运行时组合不同的武器和装备对象。

最佳实践

Inheritance 最佳实践

遵循 “is-a” 原则：只有当子类和父类之间存在真正的 “is-a” 关系时才使用继承。例如，Dog 是一种 Animal，所以 Dog 类继承 Animal 类是合理的。
谨慎使用方法重写：重写方法时要确保子类方法的行为与父类方法的行为保持一致，遵循里氏替换原则。
避免过度继承：过多的继承层次可能导致代码复杂度过高，难以维护。尽量保持继承层次的简洁。

Composition 最佳实践

遵循 “has-a” 原则：确保组合对象之间是 “has-a” 的关系。例如，Car 拥有一个 Engine，所以在 Car 类中组合 Engine 对象是合适的。
提高封装性：通过组合，可以更好地封装对象的内部实现。将复杂的功能封装在组件对象中，对外提供简单的接口。
便于代码维护和扩展：组合方式使得代码更易于维护和扩展。如果需要修改某个组件的功能，只需要修改该组件类，而不会影响到其他类。

小结

Inheritance 和 Composition 是 Java 编程中两种强大的代码复用技术，各有其优缺点和适用场景。Inheritance 适用于建立类层次结构，实现 “is-a” 关系的代码复用；而 Composition 更适合于构建复杂对象，实现 “has-a” 关系的对象聚合。在实际编程中，应根据具体需求选择合适的技术，遵循最佳实践原则，以编写高质量、可维护的 Java 代码。

参考资料

《Effective Java》 - Joshua Bloch
Oracle Java Documentation
Java Tutorials on Baeldung

希望本文能帮助读者深入理解 Inheritance 和 Composition 在 Java 中的应用，从而在实际项目中做出更明智的选择。