菜鸟硕枫设计模式系列之9 组合模式

组合模式，顾名思义，采用了组合的方式，使得简单的对象可以组合成复杂的对象，同时保证了简单对象和复杂对象使用上的一致性。这是一种典型的has- a 关系。用过组合 使得简单对象成为了复杂对象的一部分，而在使用上，简单对象和复杂对象又是一致的。

组合模式类图：

[img]http://dl.iteye.com/upload/attachment/364541/b7cdc2de-4278-36e1-9acf-030e2091033d.jpg[/img]


具体实例demo:

抽象对象：

package compositePattern;

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

public abstract class Person {

	protected List<Person> personList;
	protected String name;
	public abstract void work();
	public  Person(List<Person> personList,String name){
		this.personList = personList;
		this.name = name;
	}

	public abstract void add(Person person);

	public abstract void remove(Person person);
	public abstract List<Person> getShouXia();
	public void setName(String name) {
		this.name = name;
	}
	public String getName() {
		return name;
	}

}

具体对象类：

package compositePattern;

import java.util.List;

public class Coder extends Person{

	public Coder(List<Person> personList,String name) {
		super(personList, name);
		// TODO Auto-generated constructor stub
	}

	@Override
	public void work() {
		System.out.println("miserable coder");
	}

	public void add(Person person){

	}

	public void remove(Person person){

	}
	public List<Person> getShouXia(){
		return null;
	}

}

具体对象类2：

package compositePattern;

import java.util.List;

public class LaoDa extends Person{

	public LaoDa(List<Person> personList,String name) {
		super(personList, name);
		// TODO Auto-generated constructor stub
	}
	@Override
	public void work() {
		// TODO Auto-generated method stub

	}
	public void add(Person person){
		personList.add(person);	
	}

	public void remove(Person person){
		personList.remove(person);	
	}
	public List<Person> getShouXia(){
		return personList;
	}

}

测试类：

package compositePattern;

import java.util.ArrayList;

public class CompositePatternTest {

	public static void main(String[]args){
		int  deep = 0;
		LaoDa[] laodas =new LaoDa[2];
		for(int i=0;i<2;i++){
			 laodas[i] = new LaoDa(new ArrayList<Person>(),i+"号老大");
		}
		Coder[] coders =new Coder[6];
		for(int j=0;j<6;j++){
			coders[j] = new Coder(null,j+"号码农");
		}

		for(int i =0;i<2;i++){
			laodas[i].add(coders[i]);
			laodas[i].add(coders[i+2]);
			laodas[i].add(coders[i+4]);
		}
		laodas[0].add(laodas[1]);
		show(laodas[0],0);
	}

	public static void show(Person p ,int deep){
		for(int i=0;i<=deep-1;i++)
			System.out.print("---");
		System.out.println(p.getName());
		if(p.personList!=null &&p.personList.size()>0)
			for(Person person : p.personList)
				show( person ,deep+1);
	}
}

说明;简单对象类对一些非自己的功能可以将抽象对象功能空实现，这样既保证了简单对性爱那个和复杂对象类的一致性，又保证了各自功能的相对区别。