组合模式（Composite）：“将对象组合成树形结构以表示‘部分-整体’的层次结构。组合模式使得用户对单个对象和组合对象的使用具有一致性。

他的例子很多，比如我们的文件系统，每一个文件夹可以复制，可以删除，每一个文件也可以复制和删除

再比如我们现实中的电脑

电脑的机箱里可以装上硬盘和主板，还有电源，而主板上还有内存卡等 这里面的所有部件都可以换掉，有些部件甚至可以用2个或三个。比如硬盘和内存，网卡等

这里我就模拟这个电脑，用java来实现

第一步：创建它们的共有接口 Composite

public abstract class Computer {
	private String name;
	public Computer(String name){
		this.name = name;
	}
	
	public abstract double Price();
	
	public boolean add(Computer computer){
		return false;	
	}

	public Iterator iter() {  
        return null;  
    } 

}

以上代码，我们定义了一个抽象类，并且有一个抽象方法，抽象方法是获得这个部件的价格，比如主板，比如内存，比如主板和内存

还定义了一个添加部件的普通方法

还定义了一个用于遍历的iter方法

第二步：定义每一个部件的行为（Computerposite），比如在机箱上添加（add）一个硬盘，在主板上添加一个内存，他的作用就是实现与子部件相关的操作，当然它肯定是需要继承或实现Composite的

public abstract class Computerposite extends Computer{
	private List<Computer> equipment = new ArrayList<Computer>(); 
	
	private int i = 0;
	
	public Computerposite(String name) {
		super(name);
		// TODO Auto-generated constructor stub
	}

	@Override
	public double Price() {
		double nprice = 0;
		Iterator iter = equipment.iterator();		
		while(iter.hasNext()){
			Computer computer = (Computer) iter.next();
			if(computer instanceof Memory){
				System.out.println("在主板上发现一个内存，价格："+Memory.price); 
			}else if(computer instanceof Board){
				System.out.println("在机箱里发现一个主板，价格："+Board.price);
			}
			nprice += computer.Price();
		}
		return nprice;
	}
	public boolean add(Computer computer){
		if(computer instanceof Board && this instanceof Chassis){
			System.out.println("在机箱上添加一个主板");
		}else if(computer instanceof Memory && this instanceof Board){
			System.out.println("在主板上添加一个内存");
		}
		return equipment.add(computer);	
	}
	
    public Iterator<Computer> iter() {  
        return equipment.iterator();  
    }  
  
    // 重载Iterator方法  
    public boolean hasNext() {  
        return i < equipment.size();  
    }  
  
    // 重载Iterator方法  
    public Object next() {  
        if (hasNext())  
            return equipment.get(i++);  
        else  
            throw new NoSuchElementException();  
    }  

}

简要说明以上代码：

A:list数组中保存的是每一个部件哦

B:price方法，就是遍历当前的对象里的list，比如当前对象如果是主板，它就会得到主板里面的部件的价格，比如主板上有内存，他就得到内存的价格

C:add方法，里面的if语句主要是用于限制，本例几乎没做限制，因为我将添加到list的add语句写在了最后。比如，你的内存条不能安装在机箱上吧，所以这里是用于限定的，不能随便添加的

this表示当前的对象，而computer表示待添加的对象

D:其它方法就是重写了

最后一步，列出各个部件，用于调用

主板（Board）

public class Board extends Computerposite{
	
	public Board(String name) {
		super(name);
		// TODO Auto-generated constructor stub
	}
	public static double price = 80;
	@Override
	public double Price() {
		// TODO 自动生成的方法存根
		return price+super.Price();
	}

}

机箱（chassis）

public class Chassis extends Computerposite{

	public Chassis(String name) {
		super(name);
		// TODO Auto-generated constructor stub
	}
	public static double price = 50;
	
	@Override
	public double Price() {
		// TODO Auto-generated method stub
		return price+super.Price();
	}

}

内存（Memory）

public class Memory extends Computerposite{
	public Memory(String name) {
		super(name);
		// TODO Auto-generated constructor stub
	}

	public static double price = 100;


	@Override
	public double Price() {
		// TODO Auto-generated method stub
		return price+super.Price();
	}

}

接下来，我们创建一个客户端测试下吧

public class demo {

	public static void main(String[] args) {
		Chassis chassis = new Chassis("机箱");
		Board board = new Board("主板");
		board.add(new Memory("内存"));
		chassis.add(board);
		
		
		System.out.println("价格是："+chassis.Price());

	}

}

结果如下：

在主板上找到一个内存
在机箱上找到一个主板
在机箱里发现一个主板，价格：80.0
在主板上发现一个内存，价格：100.0
价格是：230.0

这个例子不是很好的，因为如果我们再新增一个硬盘，除了新增硬盘类，还需要修改Computerposite的add方法，因为硬盘总不能放在内存上吧，是不是。当然，电脑也就那么几样部件，您也可以全部写完哦

有时间的话，我再写个文件系统的组合模式吧，因为它就只有两种，文件和文件夹。