设计原则 - 合成复用原则

面向对象编程中常会说「少用继承，多用组合」，于是让 ChatGPT 给出了一个具体的例子来说明。

我们假设有一个角色类，拥有攻击和防御的方法。我们可以通过继承来创建战士或弓箭手等具体的角色类型。下面是使用继承来实现的例子：

// 父类：Character
abstract class Character {
    public abstract void attack();
    public abstract void defend();
}

// 子类：Warrior（战士）
class Warrior extends Character {
    @Override
    public void attack() {
        System.out.println("Warrior attacks with sword");
    }

    @Override
    public void defend() {
        System.out.println("Warrior defends with shield");
    }
}

// 子类：Archer（弓箭手）
class Archer extends Character {
    @Override
    public void attack() {
        System.out.println("Archer attacks with bow");
    }

    @Override
    public void defend() {
        System.out.println("Archer defends with agility");
    }
}

public class Main {
    public static void main(String[] args) {
        Character warrior = new Warrior();
        warrior.attack();  // Warrior attacks with sword
        warrior.defend();  // Warrior defends with shield

        Character archer = new Archer();
        archer.attack();   // Archer attacks with bow
        archer.defend();   // Archer defends with agility
    }
}

这样做的问题是，我们之后每添加一个新的角色类型，都要创建一个 Character 的子类。如果我们需要改变父类的结构，有可能需要同步修改它的所有子类。而随着继承链增多，耦合度会变高。

而下面是使用组合的例子：

// 攻击行为接口
interface AttackBehavior {
    void attack();
}

// 防御行为接口
interface DefenseBehavior {
    void defend();
}

// 攻击行为实现：SwordAttack
class SwordAttack implements AttackBehavior {
    @Override
    public void attack() {
        System.out.println("Attacks with sword");
    }
}

// 攻击行为实现：BowAttack
class BowAttack implements AttackBehavior {
    @Override
    public void attack() {
        System.out.println("Attacks with bow");
    }
}

// 防御行为实现：ShieldDefense
class ShieldDefense implements DefenseBehavior {
    @Override
    public void defend() {
        System.out.println("Defends with shield");
    }
}

// 防御行为实现：AgilityDefense
class AgilityDefense implements DefenseBehavior {
    @Override
    public void defend() {
        System.out.println("Defends with agility");
    }
}

// 角色类
class Character {
    private AttackBehavior attackBehavior;
    private DefenseBehavior defenseBehavior;

    public Character(AttackBehavior attackBehavior, DefenseBehavior defenseBehavior) {
        this.attackBehavior = attackBehavior;
        this.defenseBehavior = defenseBehavior;
    }

    public void attack() {
        attackBehavior.attack();
    }

    public void defend() {
        defenseBehavior.defend();
    }
}

public class Main {
    public static void main(String[] args) {
        // 创建一个战士角色，组合剑攻击和盾防御
        Character warrior = new Character(new SwordAttack(), new ShieldDefense());
        warrior.attack();  // Attacks with sword
        warrior.defend();  // Defends with shield

        // 创建一个弓箭手角色，组合弓攻击和敏捷防御
        Character archer = new Character(new BowAttack(), new AgilityDefense());
        archer.attack();   // Attacks with bow
        archer.defend();   // Defends with agility
    }
}

这样的写法代码实现相对复杂，但是整体上变得更加灵活了，其拓展性更强。我们定义好不同的攻击和防御行为后，每新创建一个角色类型，都不需要再额外创建一个类，只需要选择合适的行为进行组合即可。