设计模式之路 | 组合模式

组合模式的定义与特点

组合（Composite）模式的定义：有时又叫作部分-整体模式，它是一种将对象组合成树状的层次结构的模式，用来表示“部分-整体”的关系，使用户对单个对象和组合对象具有一致的访问性。

组合模式的主要优点有：

1. 组合模式使得客户端代码可以一致地处理单个对象和组合对象，无须关心自己处理的是单个对象，还是组合对象，这简化了客户端代码；
2. 更容易在组合体内加入新的对象，客户端不会因为加入了新的对象而更改源代码，满足“开闭原则”；

其主要缺点是：

1. 设计较复杂，客户端需要花更多时间理清类之间的层次关系；
2. 不容易限制容器中的构件；
3. 不容易用继承的方法来增加构件的新功能；

 

组合模式的结构与实现

组合模式的结构不是很复杂，下面对它的结构和实现进行分析。

1. 模式的结构

组合模式包含以下主要角色。

1. 抽象构件（Component）角色：它的主要作用是为树叶构件和树枝构件声明公共接口，并实现它们的默认行为。在透明式的组合模式中抽象构件还声明访问和管理子类的接口；在安全式的组合模式中不声明访问和管理子类的接口，管理工作由树枝构件完成。
2. 树叶构件（Leaf）角色：是组合中的叶节点对象（叶子节点），它没有子节点，用于实现抽象构件角色中 声明的公共接口。
3. 树枝构件（Composite）角色：是组合中的分支节点对象（非叶子节点），它有子节点。它实现了抽象构件角色中声明的接口，它的主要作用是存储和管理子部件，通常包含 Add()、Remove()、GetChild() 等方法。

组合模式分为透明式的组合模式和安全式的组合模式。

 

(1) 透明方式：在该方式中，由于抽象构件声明了所有子类中的全部方法，所以客户端无须区别树叶对象和树枝对象，对客户端来说是透明的。但其缺点是：树叶构件本来没有 Add()、Remove() 及 GetChild() 方法，却要实现它们（空实现或抛异常），这样会带来一些安全性问题。其结构图如图 1 所示。
 

代码实现：

/**
 * 组织结构，相当于Component接口
 * 
 * @author Administrator
 */
public abstract class OrganizationComponent {

	/**
	 * 名称
	 */
	private String name;

	/**
	 * 说明
	 */
	private String desc;

	public OrganizationComponent(String name, String desc) {
		super();
		this.name = name;
		this.desc = desc;
	}

	/**
	 * 新增方法，默认实现 这里不写成抽象方法，是考虑叶子节点不需要实现改方法
	 */
	protected void add(OrganizationComponent component) {
		throw new UnsupportedOperationException();
	}

	protected void remove(OrganizationComponent component) {
		throw new UnsupportedOperationException();
	}

	/**
	 * 打印方法，描述基本信息
	 */
	public abstract void print();

	public String getName() {
		return name;
	}

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

	public String getDesc() {
		return desc;
	}

	public void setDesc(String desc) {
		this.desc = desc;
	}

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

}

/**
 * University根节点，下级为Collage，相当于Composite
 * 
 * @author Administrator
 */
public class University extends OrganizationComponent {

	/**
	 * list存放的是学院Collage
	 */
	private List<OrganizationComponent> organizationComponentList = new ArrayList<>();

	public University(String name, String desc) {
		super(name, desc);
	}

	@Override
	protected void add(OrganizationComponent component) {
		organizationComponentList.add(component);
	}
	
	@Override
	protected void remove(OrganizationComponent component) {
		organizationComponentList.remove(component);
	}

	@Override
	public void print() {
		System.out.println("================================");
		System.out.println(this.toString());
		// 遍历输出学院
		for (OrganizationComponent organizationComponent : organizationComponentList) {
			organizationComponent.print();
		}
	}

	@Override
	public String toString() {
		return "University [name=" + getName() + ", desc=" + getDesc() + "]";
	}
}

/**
 * 上级为University，下级为Department，相当于Composite
 * 
 * @author Administrator
 */
public class Collage extends OrganizationComponent {

	/**
	 * 这个list存方法的是院系Department
	 */
	private List<OrganizationComponent> organizationComponentList = new ArrayList<>();

	public Collage(String name, String desc) {
		super(name, desc);
	}

	@Override
	protected void add(OrganizationComponent component) {
		organizationComponentList.add(component);
	}
	
	@Override
	protected void remove(OrganizationComponent component) {
		organizationComponentList.remove(component);
	}

	@Override
	public void print() {
		System.out.println("================================");
		System.out.println(this.toString());
		// 遍历输出学院
		for (OrganizationComponent organizationComponent : organizationComponentList) {
			organizationComponent.print();
		}
	}

	@Override
	public String toString() {
		return "Collage [name=" + getName() + ", desc=" + getDesc() + "]";
	}
}

/**
 * Department，叶子节点，相当于Leaf
 * 不需要实现add，remove方法
 * 
 * @author Administrator
 */
public class Department extends OrganizationComponent {

	public Department(String name, String desc) {
		super(name, desc);
	}

	@Override
	public void print() {
		System.out.println(this.toString());
	}

	@Override
	public String toString() {
		return "Department [name=" + getName() + ", desc=" + getDesc() + "]";
	}
}

public class Client {
	public static void main(String[] args) {
		
		// 创建点击节点，university
		OrganizationComponent university = new University("北京大学", "中国顶级大学");
		
		// 创建节点，collage
		OrganizationComponent collage1 = new Collage("计算机学院", "中国顶级计算机学院");
		OrganizationComponent collage2 = new Collage("古汉语学院", "中国顶级古汉语学院");
		
		// 创建叶子节点，Department
		OrganizationComponent department11 = new Department("软件工程", "中国顶级软件工程");
		OrganizationComponent department12 = new Department("物联网", "中国顶级物联网专业");
		collage1.add(department11);
		collage1.add(department12);
		university.add(collage1);
		
		OrganizationComponent department21 = new Department("八股文", "中国顶级八股文专业");
		collage2.add(department21);
		university.add(collage2);
		
		university.print();
	}
}

运行结果：

(2) 安全方式：在该方式中，将管理子构件的方法移到树枝构件中，抽象构件和树叶构件没有对子对象的管理方法，这样就避免了上一种方式的安全性问题，但由于叶子和分支有不同的接口，客户端在调用时要知道树叶对象和树枝对象的存在，所以失去了透明性。其结构图如图 2 所示。
 

 

2. 模式的实现

假如要访问集合 c0={leaf1,{leaf2,leaf3}} 中的元素，其对应的树状图如图 3 所示。
 

下面给出透明式的组合模式的实现代码，与安全式的组合模式的实现代码类似，只要对其做简单修改就可以了。

 

组合模式的应用场景

前面分析了组合模式的结构与特点，下面分析它适用的以下应用场景。

1. 在需要表示一个对象整体与部分的层次结构的场合。
2. 要求对用户隐藏组合对象与单个对象的不同，用户可以用统一的接口使用组合结构中的所有对象的场合。

 

组合模式的扩展

如果对前面介绍的组合模式中的树叶节点和树枝节点进行抽象，也就是说树叶节点和树枝节点还有子节点，这时组合模式就扩展成复杂的组合模式了，如 Java AWT/Swing 中的简单组件 JTextComponent 有子类 JTextField、JTextArea，容器组件 Container 也有子类 Window、Panel。复杂的组合模式的结构图如图 5 所示。