“组合优于继承”是因为组合能提供更高的灵活性和更低的耦合性，避免继承导致的类爆炸和紧耦合问题，如策略模式通过组合实现运行时行为切换，装饰器模式动态添加功能而避免大量子类，组合模式统一处理个体与整体，使得代码更易维护和扩展，同时符合开闭原则；继承仅在明确的“is-a”关系或抽象模板场景下推荐使用，但应优先考虑组合以实现更优的设计。
“组合优于继承”是面向对象设计中的一个重要原则，它的核心思想是：优先使用对象组合的方式来实现功能复用，而不是依赖类的继承。理解这一点，有助于写出更灵活、更易维护的代码。
一、为什么说“组合优于继承”？
继承虽然能实现代码复用，但有几个明显的缺点：
- 紧耦合：子类和父类强绑定，父类一改，子类可能就出问题。
- 灵活性差：继承是静态的，编译时就确定了，无法在运行时动态改变行为。
- 继承层次容易失控：多层继承会导致类爆炸，结构复杂，难以维护。
而组合通过将功能封装到独立的对象中，再把它们组合起来使用，可以更灵活地构建对象行为。
举个简单比喻： 继承像是“你生来就是某种人（比如医生）”，而组合像是“你可以随时拥有不同的工具（比如会用听诊器、会开药）”。后者更灵活。
二、设计模式中的组合实例
下面通过几个经典设计模式来说明组合如何优于继承。
1. 策略模式（Strategy Pattern）
场景：一个游戏角色可以使用不同的武器攻击。
如果用继承，你可能会写：
class Character {}
class Warrior extends Character { void attack() { /* 挥剑 */ } }
class Archer extends Character { void attack() { /* 射箭 */ } }问题来了：如果角色在战斗中想换武器？继承无法动态改变行为。
用组合的方式：
interface Weapon {
void use();
}
class Sword implements Weapon { public void use() { System.out.println("挥剑"); } }
class Bow implements Weapon { public void use() { System.out.println("射箭"); } }
class Character {
private Weapon weapon;
public void setWeapon(Weapon weapon) {
this.weapon = weapon;
}
public void attack() {
weapon.use();
}
}这样，角色可以在运行时切换武器：
Character hero = new Character(); hero.setWeapon(new Sword()); hero.attack(); // 挥剑 hero.setWeapon(new Bow()); hero.attack(); // 射箭
✅ 优势：行为可变、代码复用、易于扩展新武器。
2. 装饰器模式（Decorator Pattern）
场景：给咖啡添加配料（如牛奶、糖、奶油），每种组合价格不同。
如果用继承，你会写出：
- Coffee
- MilkCoffee
- SugarCoffee
- MilkSugarCoffee
- CreamMilkCoffee
- … 类爆炸！
用组合的方式（装饰器模式）：
interface Coffee {
double cost();
}
class SimpleCoffee implements Coffee {
public double cost() { return 2.0; }
}
abstract class CoffeeDecorator implements Coffee {
protected Coffee coffee;
public CoffeeDecorator(Coffee coffee) {
this.coffee = coffee;
}
}
class Milk extends CoffeeDecorator {
public Milk(Coffee coffee) { super(coffee); }
public double cost() { return coffee.cost() + 0.5; }
}
class Sugar extends CoffeeDecorator {
public Sugar(Coffee coffee) { super(coffee); }
public double cost() { return coffee.cost() + 0.3; }
}使用：
Coffee order = new Milk(new Sugar(new SimpleCoffee())); System.out.println(order.cost()); // 2.8
✅ 优势：动态组合功能，避免类爆炸，扩展性强。
3. 组合模式（Composite Pattern）
这个模式名字就叫“组合”，它把部分和整体的关系用树形结构表示。
场景：图形编辑器中，可以绘制单个图形（圆形、矩形），也可以组合成组（Group），对组的操作相当于对所有子图形操作。
interface Shape {
void draw();
}
class Circle implements Shape {
public void draw() { System.out.println("画圆形"); }
}
class Rectangle implements Shape {
public void draw() { System.out.println("画矩形"); }
}
class Group implements Shape {
private List children = new ArrayList<>();
public void add(Shape shape) {
children.add(shape);
}
public void draw() {
for (Shape s : children) {
s.draw();
}
}
} 使用：
Group group = new Group(); group.add(new Circle()); group.add(new Rectangle()); group.draw(); // 依次画出圆形和矩形
✅ 优势：客户端无需区分单个对象和组合对象，统一处理。
三、总结：组合的优势
- 高内聚、低耦合：功能模块独立，易于测试和复用。
- 运行时动态组合：行为可以在程序运行中改变。
- 避免继承层级过深：减少类数量，结构更清晰。
- 符合开闭原则：扩展新功能无需修改原有代码。
四、什么时候可以用继承？
当然，继承也不是完全不能用。以下情况可以考虑继承：
- 类之间是“is-a”关系（如 Dog is an Animal）。
- 父类是抽象的模板（如抽象基类定义骨架，子类实现细节）。
- 框架级设计，需要统一接口和默认行为。
但即便如此，也建议优先考虑组合。
基本上就这些。组合不是完全否定继承，而是提醒我们：不要为了复用而滥用继承，用组合往往更灵活、更可控。在设计模式中，大多数解耦方案都依赖组合来实现，这也是它被称为“优于继承”的原因。
