Java 的组合（Composition）优于继承（Inheritance）：设计原则的实践

Java组合优于继承：告别“脆弱的基类”，拥抱灵活的“乐高积木”

各位老铁，程序员的世界，技术迭代那叫一个快，今天流行这个框架，明天又冒出那个语言。但有些亘古不变的真理，就像代码里的注释，虽然容易被忽略，但关键时刻能救你一命。今天咱们就来聊聊Java设计原则里一个非常重要，但又经常被新手朋友们忽视的议题：组合优于继承。

标题都说了，组合更牛，那继承岂不是要被扫进历史的垃圾堆了？别紧张，继承就像老家的老房子，虽然住了几十年，充满回忆，但有时候修修补补比推倒重建还麻烦。组合呢，更像是乐高积木，灵活多变，想搭啥就搭啥，出了问题拆了重来也简单。

继承：爱恨交织的“父子关系”

继承，面向对象编程的三大特性之一（封装、继承、多态），曾经是程序员们手中的利剑。它允许我们创建一个新的类（子类）来继承已有类（父类）的属性和行为，从而实现代码的重用和扩展。

想象一下，你是一位动物园园长，要管理各种动物。你先创建了一个 Animal 基类：

class Animal {
    protected String name;
    protected int age;

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

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

    public void sleep() {
        System.out.println(name + " is sleeping.");
    }
}

现在，你想创建 Dog 类和 Cat 类。使用继承，so easy：

class Dog extends Animal {
    public Dog(String name, int age) {
        super(name, age);
    }

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

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

    public void meow() {
        System.out.println(name + " is meowing.");
    }
}

这段代码简洁明了，Dog 和 Cat 自动拥有了 Animal 的 name、age、eat() 和 sleep() 方法，还分别增加了自己的 bark() 和 meow() 方法。 看起来很完美，对吧？ 代码重用，结构清晰，简直是教科书级别的示范。

但是，魔鬼就藏在细节里。

继承的黑暗面：脆弱的基类问题

随着动物园的规模不断扩大，你发现有些动物并不适合用继承来表示。 比如，你会遇到一种奇特的动物：飞行狗！ 按照之前的思路，你可能会这么做：

class FlyingDog extends Dog {
    public void fly() {
        System.out.println(name + " is flying!");
    }
}

看起来没问题，但仔细想想，Dog 类本身并没有飞行的能力。 FlyingDog 继承了 Dog 的所有属性和行为，但同时也继承了 Dog 的局限性。 这就像给一辆汽车装上翅膀，虽然能飞，但肯定不如真正的飞机飞得好。

更糟糕的是，如果 Animal 类发生变化，比如增加了一个 canFly 属性，那么所有继承自 Animal 的子类都必须进行相应的修改。 这被称为脆弱的基类问题：基类的修改可能会导致子类出现意想不到的问题，甚至崩溃。

想象一下，如果 Animal 类增加了一个 layEggs() 方法，Dog 类就非常尴尬了，难道还要让狗狗下蛋吗？ 这就违背了现实世界的逻辑。

此外，继承还存在以下问题：

• 紧耦合： 子类和父类之间高度耦合，父类的修改会直接影响子类。
• 代码复用性差： 子类只能继承父类的所有属性和行为，无法选择性地继承。
• 限制灵活性： Java只支持单继承，一个类只能继承一个父类，限制了类的扩展性。

总结一下，继承就像一把双刃剑，用得好可以提高代码重用性，用不好则会带来各种问题。 那么，有没有一种更好的方法来解决这些问题呢？ 答案是：组合。

组合：灵活多变的“乐高积木”

组合，顾名思义，就是将多个对象组合在一起，形成一个新的对象。 就像乐高积木一样，你可以将不同的积木组合成各种各样的模型。

在Java中，组合是通过将其他类的实例作为成员变量来实现的。 让我们用组合的思想来重新设计动物园的例子。

首先，我们创建一个 Flyable 接口，表示具有飞行能力的动物：

interface Flyable {
    void fly();
}

然后，我们创建一个 Dog 类，它不再继承 Animal 类，而是实现一个 AnimalBehavior 接口（假设我们有这样的接口，包含了 eat() 和 sleep() 方法）：

interface AnimalBehavior {
    void eat();
    void sleep();
}

class Dog implements AnimalBehavior {
    private String name;
    private int age;

    public Dog(String name, int age) {
        this.name = name;
        this.age = age;
    }

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

    @Override
    public void sleep() {
        System.out.println(name + " is sleeping.");
    }

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

现在，我们要创建一个 FlyingDog 类。 不再使用继承，而是将 Dog 对象和一个 Flyable 对象组合在一起：

class FlyingDog {
    private Dog dog;
    private Flyable flyable;

    public FlyingDog(Dog dog, Flyable flyable) {
        this.dog = dog;
        this.flyable = flyable;
    }

    public void eat() {
        dog.eat(); // 委托给 Dog 对象
    }

    public void sleep() {
        dog.sleep(); // 委托给 Dog 对象
    }

    public void bark() {
        dog.bark(); // 委托给 Dog 对象
    }

    public void fly() {
        flyable.fly(); // 委托给 Flyable 对象
    }
}

在这个例子中，FlyingDog 类并没有继承 Dog 类，而是将 Dog 对象和一个 Flyable 对象组合在一起。 FlyingDog 的 eat()、sleep() 和 bark() 方法都委托给 Dog 对象来执行，fly() 方法委托给 Flyable 对象来执行。

这种方式有以下优点：

• 松耦合： FlyingDog 类和 Dog 类以及 Flyable 接口之间的耦合度较低，修改其中一个类不会影响其他类。
• 代码复用性好： 可以选择性地组合需要的对象，而不是继承父类的所有属性和行为。
• 灵活性高： 可以动态地改变组合的对象，从而改变 FlyingDog 的行为。

例如，我们可以创建一个 Wing 类来实现 Flyable 接口：

class Wing implements Flyable {
    @Override
    public void fly() {
        System.out.println("Flying with wings!");
    }
}

然后，创建一个 FlyingDog 对象：

Dog myDog = new Dog("Buddy", 3);
Wing myWing = new Wing();
FlyingDog myFlyingDog = new FlyingDog(myDog, myWing);

myFlyingDog.fly(); // 输出：Flying with wings!

如果我们想让 FlyingDog 使用喷气引擎飞行，只需要创建一个 JetEngine 类来实现 Flyable 接口，然后将 JetEngine 对象传递给 FlyingDog 的构造函数即可。

class JetEngine implements Flyable {
    @Override
    public void fly() {
        System.out.println("Flying with jet engine!");
    }
}

JetEngine myJetEngine = new JetEngine();
FlyingDog myFlyingDog2 = new FlyingDog(myDog, myJetEngine);

myFlyingDog2.fly(); // 输出：Flying with jet engine!

可以看到，使用组合可以轻松地改变 FlyingDog 的飞行方式，而不需要修改 Dog 类或 FlyingDog 类的代码。 这种灵活性是继承所无法比拟的。

组合 vs. 继承：一场友谊赛

为了更清晰地对比组合和继承，我们用一张表格来总结它们的优缺点：

特性	继承	组合
耦合度	高	低
代码复用性	只能继承父类的所有属性和行为	可以选择性地组合需要的对象
灵活性	较低，受父类的限制	较高，可以动态地改变组合的对象
可维护性	较低，基类的修改可能影响子类	较高，修改一个类不会影响其他类
适用场景	关系紧密，具有 "is-a" 关系的类	关系松散，需要灵活组合对象的类
例子	Dog 继承 Animal (如果所有狗都是动物)	FlyingDog 组合 Dog 和 Flyable (并非所有狗都能飞)
风险	脆弱的基类问题	可能需要编写更多的代码来委托方法

从表格中可以看出，组合在耦合度、代码复用性、灵活性和可维护性等方面都优于继承。 当然，继承也有其适用的场景，比如当类之间的关系非常紧密，并且具有 "is-a" 关系时，可以使用继承。

但是，在大多数情况下，组合是更好的选择。

组合的实际应用：告别“上帝类”，拥抱“微服务”

组合的思想在实际开发中有着广泛的应用。 比如，在构建复杂的软件系统时，我们可以将系统分解成多个独立的模块，然后将这些模块组合在一起，形成一个完整的系统。 这就像搭积木一样，每个模块都是一个积木，我们可以根据需要将它们组合成不同的形状。

这种模块化的设计方法可以降低系统的复杂度，提高代码的可维护性和可扩展性。 它也是微服务架构的核心思想之一。

让我们看一个更实际的例子：一个图形编辑器。 传统的做法是创建一个 Shape 基类，然后让 Circle、Rectangle 和 Triangle 等类继承自 Shape 类。

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

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

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

这种做法的问题是，如果我们要增加新的图形类型，比如 Star，就需要修改 Shape 类，并且所有继承自 Shape 的子类都需要进行相应的修改。 这违反了开闭原则（对扩展开放，对修改关闭）。

使用组合的思想，我们可以将图形的绘制行为抽象成一个 Drawable 接口：

interface Drawable {
    void draw();
}

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

class Rectangle implements Drawable {
    @Override
    public void draw() {
        System.out.println("Drawing a rectangle.");
    }
}

class Star implements Drawable {
    @Override
    public void draw() {
        System.out.println("Drawing a star.");
    }
}

然后，创建一个 Editor 类，它包含一个 Drawable 对象的列表：

class Editor {
    private List<Drawable> drawables = new ArrayList<>();

    public void addDrawable(Drawable drawable) {
        drawables.add(drawable);
    }

    public void drawAll() {
        for (Drawable drawable : drawables) {
            drawable.draw();
        }
    }
}

现在，我们可以轻松地增加新的图形类型，而不需要修改 Editor 类的代码。 只需要创建一个新的类来实现 Drawable 接口，然后将该类的对象添加到 Editor 对象的 drawables 列表中即可。

这种设计方式更加灵活，也更容易维护和扩展。

总结：拥抱组合，告别“脆弱的基类”

总而言之，组合是一种比继承更强大、更灵活的设计原则。 它可以帮助我们构建更加健壮、可维护和可扩展的软件系统。

当然，这并不是说继承就一无是处。 在某些情况下，继承仍然是合适的选择。 但是，在大多数情况下，我们应该优先考虑使用组合。

记住，组合就像乐高积木，可以让我们创造出无限可能。 而继承就像老房子，虽然充满回忆，但有时候修修补补比推倒重建还麻烦。

所以，下次在设计类的时候，不妨先考虑一下是否可以使用组合来代替继承。 相信你会发现，组合可以让你写出更优雅、更健壮的代码。

最后，送给大家一句编程界的至理名言：多用组合，少用继承，bug自然少一半。 祝大家编程愉快！