设计模式 | 组合模式（composite）

定义：

将对象组合成树形结构以表示“部分-总体”的层次结构。组合模式使得用户对单个对象和组合对象的使用具备一致性。

结构：（书中图，侵删）

 

一个Component接口：定义统一的方法

若干树枝（Composite）类（继承Component）：可包含若干个叶子（Leaf）节点

若干树叶（Leaf）类：叶子节点

 

书中说到这个模式有两种方式：

透明方式：在Component接口中定义添加和移除子节点的方法，可是叶子节点不须要这两个方法。这样写能够保持客户端调用的一致性。

安全方式：不在Component接口中定义添加和移除子节点的方法，直接在叶子节点中定义，这样写省去了叶子节点中的无用代码，可是客户端须要添加判断。

实例：

书中举到一个例子说是，假如你在word修改字体的大小时，你修改一个字和一段文字操做都是相同的。用户不用对此有差异操做，程序也不用差异对待。

而后，就让我想到了游戏中的队伍系统，在某些游戏里是能够跟随的，队长操纵本身，整个队伍都会跟着一块儿行动，和队长一我的行动没有什么区别。

 

玩家操纵的目标接口（Component）：

package designpattern.composite;

public abstract class Target {
    private String name;// 名称

    public abstract void add(Target target);// 增长节点

    public abstract void remove(Target target);// 删除节点

    public abstract void move();// 移动

    public abstract void attack();// 攻击

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

}

玩家类（Leaf）：

package designpattern.composite;

public class Player extends Target {
    private String name;

    public Player(String name) {
        super();
        this.name = name;
    }

    @Override
    public void move() {
        System.out.println("[" + name + "]正在移动");
    }

    @Override
    public void attack() {
        System.out.println("[" + name + "]发动攻击");
    }

    @Override
    public void add(Target target) {
    }

    @Override
    public void remove(Target target) {
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Player [name=" + name + "]";
    }

}

队伍类（Composite）：

package designpattern.composite;

import java.util.ArrayList;
import java.util.List;

public class Team extends Target {
    List<Target> team = new ArrayList<>();

    @Override
    public void add(Target target) {
        team.add(target);
        System.out.println(target.getName() + "加入队伍");
    }

    @Override
    public void remove(Target target) {
        team.remove(target);
        System.out.println(target.getName() + "离开队伍");
    }

    @Override
    public void move() {
        System.out.println(teamMembers() + "组成的队伍正在移动");
    }

    @Override
    public void attack() {
        System.out.println(teamMembers() + "组成的队伍发动攻击");
    }

    private String teamMembers() {
        StringBuffer stringBuffer = new StringBuffer();
        stringBuffer.append("[");
        for (Target target : team) {
            stringBuffer.append(target.getName() + " ");
        }
        stringBuffer.append("]");
        return stringBuffer.toString();
    }
}

客户端：

package designpattern.composite;

public class Client {
    public static void main(String[] args) {
        Player captainAmerica = new Player("美国队长");
        captainAmerica.move();
        captainAmerica.attack();

        System.out.println("----------复联成立----------");
        Player ironMan = new Player("钢铁侠");
        Player hulk = new Player("绿巨人");
        Team team = new Team();
        team.add(captainAmerica);
        team.add(ironMan);
        team.add(hulk);

        team.move();
        team.attack();

        System.out.println("----------发生矛盾--------");
        team.remove(ironMan);

        team.move();
        team.attack();
    }
}

结果输出：

[美国队长]正在移动
[美国队长]发动攻击
----------复联成立----------
美国队长加入队伍
钢铁侠加入队伍
绿巨人加入队伍
[美国队长 钢铁侠 绿巨人 ]组成的队伍正在移动
[美国队长 钢铁侠 绿巨人 ]组成的队伍发动攻击
----------发生矛盾--------
钢铁侠离开队伍
[美国队长 绿巨人 ]组成的队伍正在移动
[美国队长 绿巨人 ]组成的队伍发动攻击

总结：

这个模式用在两个事物存在必定的包含关系，可是他们的行为又是一致的，为了让客户能够方便统一的使用他们。

套用书中的话：组合模式让客户能够一致的使用组合结构和单个对象。