JAVA设计模式-组合模式-Composite

8. Composite（组合）

意图：

将对象组合成树形结构以表示“部分-整体”的层次结构。C o m p o s i t e 使得用户对单个对象和组合对象的使用具有一致性。

适用性：

你想表示对象的部分-整体层次结构。

你希望用户忽略组合对象与单个对象的不同，用户将统一地使用组合结构中的所有对象。

解释：

意图：由“士兵”组成“ 班”，再由“班”组成“排”，在使用“出击”方法的时候，对“ 班”使用“出击”方法，那么就会让该“ 班”内的“士兵”全部使用“出击”，而不用再显式地逐个调用每个“士兵”的“出击”方法；而在对“排”使用“出击”，那么就会让该“排”内所有“ 班”全部使用“出击”。

适用性：

当一系列对象的分组关系，从属关系非常明确的时候，对组合要求比较自由的时候。如军队的编制关系，上下从属比较明确，也可以将不同的队伍通过组合为一个作战部队。

当你需要对成组的对象使用一致的指令的时候：比如说对帖子批量操作、对某个组合的士兵下令等等。

实现：

将要实现：

那么需要3个容器（concreteRole,row,team）

抽象成员类：

abstract class Role {
    abstract void heal(int hp);

    boolean add(Role role) {
        return false;
    }

    boolean remove(Role role) {
        return false;
    }

    Role getChild(int i) {
        return null;
    }
}

具体成员类（我将其视为单位为1的容器）：

class ConcreteRole extends Role {
    @Override
    void heal(int hp) {
        System.out.println(this + "被治疗了" + hp + "点");
    }
}

容器类row：

class Row extends Role {
    private List<Role> row = new ArrayList<Role>();

    void heal(int hp) {
        for (Role r : row)
            r.heal(hp);
    }

    @Override
    boolean add(Role role) {
        row.add(role);
        return true;
    }

    @Override
    boolean remove(Role role) {
        row.remove(role);
        return true;
    }

    @Override
    Role getChild(int i) {
        return row.get(i);
    }
}

容器类team

class Team extends Role {
    private List<Role> team = new ArrayList<Role>();

    void heal(int hp) {
        for (Role r : team)
            r.heal(hp);
    }

    @Override
    boolean add(Role role) {
        team.add(role);
        return true;
    }

    @Override
    boolean remove(Role role) {
        team.remove(role);
        return true;
    }

    @Override
    Role getChild(int i) {
        return team.get(i);
    }
}

测试：

    public static void main(String[] args) {
        //初始化容器……
        Role player1 = new ConcreteRole();
        Role player2 = new ConcreteRole();
        Role player3 = new ConcreteRole();
        Role monster1 = new ConcreteRole();
        Role monster2 = new ConcreteRole();
        Role monster3 = new ConcreteRole();
        Role playerTeam = new Team();
        Role monsterTeam = new Team();
        Role playerFrontRow = new Row();
        Role playerBackRow = new Row();
        Role monsterFrontRow = new Row();
        Role monsterBackRow = new Row();
        //将ConcreteRole组合为Row……
        playerFrontRow.add(player1);
        playerFrontRow.add(player2);
        playerBackRow.add(player3);
        monsterFrontRow.add(monster1);
        monsterBackRow.add(monster2);
        monsterBackRow.add(monster3);
        //将Row组合为Team……
        playerTeam.add(playerFrontRow);
        playerTeam.add(playerBackRow);
        monsterTeam.add(playerFrontRow);
        monsterTeam.add(playerBackRow);
        System.out.println("治疗player1");
        //对容器发出指令，成员会自动逐级调用方法
        player1.heal(100);
        System.out.println("治疗playerTeam");
        playerTeam.heal(100);
        System.out.println("治疗playerFrontRow");
        playerFrontRow.heal(100);
        System.out.println("治疗monster1");
        monster1.heal(100);
        System.out.println("治疗monsterTeam");
        monsterTeam.heal(100);
        System.out.println("治疗monsterBackRow");
        monsterBackRow.heal(100);
    }

结果：

治疗player1
com.ake.designMethod.Player@9cb0f4被治疗了100点
治疗playerTeam
com.ake.designMethod.Player@9cb0f4被治疗了100点
com.ake.designMethod.Player@125844f被治疗了100点
com.ake.designMethod.Player@11978b被治疗了100点
治疗playerFrontRow
com.ake.designMethod.Player@9cb0f4被治疗了100点
com.ake.designMethod.Player@125844f被治疗了100点
治疗monster1
com.ake.designMethod.Monster@f42ad0被治疗了100点
治疗monsterTeam
com.ake.designMethod.Player@9cb0f4被治疗了100点
com.ake.designMethod.Player@125844f被治疗了100点
com.ake.designMethod.Player@11978b被治疗了100点
治疗monsterBackRow
com.ake.designMethod.Monster@1309e87被治疗了100点
com.ake.designMethod.Monster@f7c31d被治疗了100点