设计模式学习 - 组合模式

组合模式关注那些包含叶子构件和容器构件以及它们的组织形式，在叶子构件中不包含成员对象，而容器构件可以包含成员对象，这些对象通过递归组合可构成一个树形结构。例如Windows中的文件目录结构。

定义

组合多个对象形成树形结构以表示具有部分-整体关系的层次结构。组合模式让客户端可以统一对待单个对象和组合对象。

结构

Component(抽象构件)

它可以是接口或抽象类，为叶子构件和容器构件对象声明接口，在该角色中可以包含所有子类共有行为的声明和实现。在抽象构件中定义了访问及管理它的子构件的方法，如增加子构件、删除子构件、获取子构件等。

Leaf(叶子构件)

它在组合结构中表示叶子结点对象，叶子结点没有子节点，它实现了在抽象构件中定义的行为。对于那些访问及管理子构件的方法，可以通过抛出异常、提示错误等方式进行处理。

Composite(容器构件)

它在组合结构中表示容器结点对象，容器结点包含子结点，其子节点可以是叶子结点，也可以是容器结点，它提供了一个集合用于存储子结点，实现了在抽象构件中定义的行为，包括那些访问及管理子构件的方法，在其业务方法中可以递归调用其子结点的业务方法。

实现

组合模式关键在于定义一个抽象构件类，它既可以代表叶子，又可以代表容器，客户端针对该抽象构件类进行编程，无须知道它到底表示的是叶子还是容器，可以对其进行统一处理。同时容器对象与抽象构件类之间还建立了一个聚合关联关系，在容器对象中既可以包含叶子，又可以包含容器，以此实现递归组合，形成一个树形结构。

举例说明

模拟一个杀毒软件，该软件可以对某个文件夹或某个指定文件进行杀毒，还可以根据不同类型的文件提供不同的杀毒方式。比如文本文件和图像文件。

1.抽象构件类

// 抽象构件类 - 抽象文件类
public abstract class AbstractFile {
	public abstract void add(AbstractFile file);
	public abstract void remove(AbstractFile file);
	public abstract AbstractFile getChild(int i);
	public abstract void killVirus();
}

2.叶子构件类

// 叶子构件类 - 图像文件
public class ImageFile extends AbstractFile{
	private String name;
	
	public ImageFile(String name) {
		this.name = name;
	}
	
	@Override
	public void add(AbstractFile file) {
		System.out.println("对不起，不支持该方法");
	}

	@Override
	public void remove(AbstractFile file) {
		System.out.println("对不起，不支持该方法");
	}

	@Override
	public AbstractFile getChild(int i) {
		System.out.println("对不起，不支持该方法");
		return null;
	}

	@Override
	public void killVirus() {
		// 模拟杀毒
		System.out.println("对图像文件'" + name + "'进行杀毒");
	}

}

// 叶子构件类 - 文本文件类
public class TextFile extends AbstractFile {
	private String name;
	
	public TextFile(String name) {
		this.name = name;
	}
	
	@Override
	public void add(AbstractFile file) {
		System.out.println("对不起，不支持该方法");
	}

	@Override
	public void remove(AbstractFile file) {
		System.out.println("对不起，不支持该方法");
	}

	@Override
	public AbstractFile getChild(int i) {
		System.out.println("对不起，不支持该方法");
		return null;
	}

	@Override
	public void killVirus() {
		// 模拟杀毒
		System.out.println("对文本文件'" + name + "'进行杀毒");
	}

}

3.容器构件类

// 容器构件类 - 文件夹类
public class Folder extends AbstractFile {
	// 定义集合fileList,用于存储AbstractFile类型的成员
	private List<AbstractFile> fileList = new ArrayList<AbstractFile>();
	
	private String name;
	
	public Folder(String name) {
		this.name = name;
	}
	
	@Override
	public void add(AbstractFile file) {
		fileList.add(file);
	}

	@Override
	public void remove(AbstractFile file) {
		fileList.remove(file);
	}

	@Override
	public AbstractFile getChild(int i) {
		return (AbstractFile)fileList.get(i);
	}

	@Override
	public void killVirus() {
		// 模拟杀毒
		System.out.println("对文件夹'" + name + "'进行杀毒");
		// 递归调用成员构件的killVirus方法
		for(AbstractFile file : fileList) {
			file.killVirus();
		}
	}

}

4.测试

// 测试类
public class Client {
	public static void main(String[] args) {
		// 文件夹
		AbstractFile folder1,folder2,folder3;
		// 文件
		AbstractFile file1,file2,file3,file4;
		
		folder1 = new Folder("文件管理");
		folder2 = new Folder("图像文件");
		folder3 = new Folder("文本文件");
		
		file1 = new ImageFile("Vae.jpg");
		file2 = new ImageFile("Jay.png");
		file3 = new TextFile("寻宝游戏.doc");
		file4 = new TextFile("床边故事.txt");
		
		folder1.add(folder2);
		folder1.add(folder3);
		folder2.add(file1);
		folder2.add(file2);
		folder3.add(file3);
		folder3.add(file4);
		// 从folder1开始杀毒
		folder1.killVirus();
	}
}

5.运行截图

透明组合模式与安全组合模式

上面所诉的就是透明组合模式，即在抽象构件Component中声明了所有用于管理成员对象的方法，包括add()、remove()以及getChild()等方法。这样做的好处是确保所有构件类都有相同的接口。在客户端看来，叶子构件和容器构件所提供的方法一致。但这样是不安全的，叶子构件不可能有下一层次对象，因此为其提供add等方法是没有意义的，如果客户端调用这些方法可能会出错。

在安全组合模式中，抽象构件中没有声明任何用于管理成员对象的方法如add等方法，而是在容器构件类Composite中声明并实现这些方法，对于叶子构件，客户端不可能代用到这些方法。

优点

1.让客户端忽略层次的差异，方便对整个层次结构进行控制。

2.客户端可以一致地使用一个组合构件或其中单个对象，不必关系是处理的单个对象还是组合结构，简化了客户端代码。

3.通过叶子对象和容器对象的递归组合可以形成复杂的树形结构。

4.符合开闭原则

缺点

在增加新构件时很难对容器中的构件类型进行限制。有时候希望一个容器中只能有某类型特定的对象时，例如在某文件夹中只能有文本文件。这种情况只能通过在运行时进行类型检查实现，较为复杂。