microwind/ai-skills/composition-over-inheritance

// ❌ 继承导致的问题：脆弱基类
public class ArrayList<E> {
    public void add(E element) { /* ... */ }
    public void addAll(Collection<E> c) {
        for (E e : c) add(e);  // 内部调用 add
    }
}
 
public class CountingList<E> extends ArrayList<E> {
    private int addCount = 0;
 
    @Override
    public void add(E element) {
        addCount++;
        super.add(element);
    }
 
    @Override
    public void addAll(Collection<E> c) {
        addCount += c.size();
        super.addAll(c);  // 父类 addAll 又调用了 add，计数翻倍！
    }
}

// ✅ 组合：不依赖父类实现细节
public class CountingList<E> {
    private final List<E> list = new ArrayList<>();
    private int addCount = 0;
 
    public void add(E element) {
        addCount++;
        list.add(element);
    }
 
    public void addAll(Collection<E> c) {
        addCount += c.size();
        list.addAll(c);  // 不关心 ArrayList 内部如何实现
    }
 
    public int getAddCount() { return addCount; }
}

# ❌ 多重继承导致菱形问题
class Flyer:
    def move(self):
        return "飞行"
class Swimmer:
    def move(self):
        return "游泳"
class Duck(Flyer, Swimmer):  # 菱形继承，move() 是哪个？
    pass
# ✅ 组合：行为可插拔
class FlyBehavior:
    def move(self) -> str:
        return "飞行"
class SwimBehavior:
    def move(self) -> str:
        return "游泳"
class Duck:
    def __init__(self):
        self.fly_behavior = FlyBehavior()
        self.swim_behavior = SwimBehavior()
    def fly(self) -> str:
        return self.fly_behavior.move()
    def swim(self) -> str:
        return self.swim_behavior.move()

// ❌ 继承层次过深
class Animal { move() {} }
class Bird extends Animal { fly() {} }
class Parrot extends Bird { talk() {} }
class PetParrot extends Parrot { tricks() {} }
// 4 层继承，耦合严重
// ✅ 组合 + 接口
interface Movable { move(): void; }
interface Flyable { fly(): void; }
interface Talkable { talk(): void; }
class Parrot implements Movable, Flyable, Talkable {
    constructor(
        private mover: Movable,
        private flyer: Flyable,
        private talker: Talkable
    ) {}
    move() { this.mover.move(); }
    fly() { this.flyer.fly(); }
    talk() { this.talker.talk(); }
}

继承仍然适用的场景：
✅ 真正的 "is-a" 关系（Cat is an Animal）
✅ 框架要求（Android Activity、JUnit TestCase）
✅ 模板方法模式（固定算法骨架，子类实现步骤）
✅ 类层次稳定且不深（≤ 2 层）
 
应该用组合的场景：
✅ "has-a" 或 "uses-a" 关系
✅ 需要运行时切换行为
✅ 需要复用多个不相关类的功能
✅ 继承层次超过 2 层