OO模式-Composite

组合模式也叫做“部分-总体”模式，这样事实上定义也就非常明显了，正好和数据结构的知识相相应。把对象组合成树形结构以表示“部分-总体”的层次结构。

先看类图：

watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvaHVvMDY1MDAw/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/SouthEast" width="447" height="304" alt="">

首先分析一下这个类图，Leaf和Composite是同辈的，都是继承父类Component，又由于Component中存在Leaf子类，所以他和Component还存在着聚合关系

举一个非经常见的样例，我们天天对着电脑。和各种文件，目录打交道，这不就是一个非常好地组合模式吗？

来看看类图：

来看看详细的实现代码：

AbstractFile为组合中的对象声明接口，实现全部类共同拥有接口的默认行为。

package composite;
 
import java.util.*;    //加入引用
 
public abstract class AbstractFile {
	protected String name; // 定义name字段
 
	public void printName() {
		System.out.println(name);
	}
 
	// 通常都用add和remove方法来提供添加或移除树叶或树枝的功能
	public abstract boolean addChild(AbstractFile file); // 添加
 
	public abstract boolean removeChild(AbstractFile file); // 移除
	// 一个集合，存放摘要文件的子文件的对象
 
	public abstract List<AbstractFile> getChildren();
}

File为子类文件，继承父类，也是树中所谓的叶子节点。叶子节点是没有子节点的，所以父类所谓的方法并不能实现，返回true和null

package composite;
 
import java.util.*;
 
public class File extends AbstractFile {
	public File(String name) {
		this.name = name;
	}
//文件并没有加入的能力，它仅仅是一个单独的个体
	public boolean addChild(AbstractFile file) {
		return false;
	}
//对于文件本身，已经是叶子节点了。所以也无删除子文件的功能
	public boolean removeChild(AbstractFile file) {
		return false;
	}
 
	// 因为File已经是叶子节点了。所以就不存在集合这一说，所以这种方法返回的是空值
	public List<AbstractFile> getChildren() {
		return null;
	}
}

Folder为子类目录，相同也继承于父类。可是此类仅仅是一个普通的节点，里边依然包括叶子节点。

package composite;
 
import java.util.*;
 
public class Folder extends AbstractFile {
 
	private List<AbstractFile> childList ;
 
	public Folder(String name) {
		this.name = name;
		//用来建立一个集合保存子文件
		this.childList = new ArrayList<AbstractFile>();
	}
	//加入子文件
	public boolean addChild(AbstractFile file) {
		return childList.add(file);
	}
	//删除子文件
	public boolean removeChild(AbstractFile file) {
		return childList.remove(file);
	}
 
	// 子类的返回类型应该和父类的定义保持一致
	public List<AbstractFile> getChildren() {
		return childList;
	}
 
}

最后来看看client是怎样调用和打印的

package composite;
 
import java.util.List;
 
public class Client {
	public static void main(String[] args) {
		// TODO 自己主动生成的方法存根
		// 构造一个树形的文件、文件夹结构
		AbstractFile rootFolder = new Folder("c:\\");
		AbstractFile compositeFolder = new Folder("composite");
		AbstractFile windowsFolder = new Folder("windows");
		AbstractFile file = new File("TestComposite.java");
 
		rootFolder.addChild(compositeFolder);
		rootFolder.addChild(windowsFolder);
		compositeFolder.addChild(file);
		// 打印文件夹文件树
		printTree(rootFolder);
	}
 
	private static void printTree(AbstractFile ifile) {
		ifile.printName();
		List<AbstractFile> children = ifile.getChildren();
		if (children == null)
			return;
		for (AbstractFile file : children) {
			printTree(file); // 打印方法的调用
		}
	}
}

透明方式与安全方式

在File子类中，他所谓的各种方法都是不实行的，可是却依然存在。这样的方式就叫做“透明方式”；这样做的优点就是叶子节点和枝节点对于外界没有差别，它们具备全然一致的行为接口；可是问题也会非常明显的。那就是在File中那些所谓的方法的存在是毫无意义的；

假设不想让其做无用功，也就是把File子类中的无意义的方法都去掉，这样的方式叫做“安全方式”；可是因为是不透明的，所以他们就不能具有一致的接口了，这样反而添加了其复杂性，client的调用须要再添加其对应的推断。

什么时候使用组合模式？

1）需求中体现的是“部分-总体”的层次的结构时，使用此模式；

2）用户希望忽略组合对象与单个对象的不同，统一地使用组合结构中的全部的对象的时候，使用此模式；

最后总结：

每一个模式事实上都是须要慢慢理解的，真正的懂得了它的精髓所在，那当再看到类似的字眼的时候就会有亲近的感觉，对于组合模式总结为下面几点：

• 组合模式提供一个结构，可同一时候包容个别对象和组合对象；
• 同意客户对个别对象以及组合对象一视同仁；
• 组合结构内的随意对象都称为组件，组件能够是组合，也能够是叶子节点；
• 在实现组合模式时，有很多设计上的折衷。

  这时候就要就情况选择透明方式还是安全方式了。

     Composite是构造型的设计模式之中的一个。通过递归手段来构造诸如文件系统之类的属性的对象结构。知识之间是相互连通的，就看你是不是选择最短路径了。