定义:将对象组合成树形结构以表示“部分-整体”的层次结构，使得用户对单个对象和组合对象的使用具有一致性。

一般模式:

Component抽象构件角色
--|定义参与组合对象的共有方法和属性，可以定义一些默认的行为或属性。
Leaf叶子构件
--|叶子对象，其下再也没有其他的分支，也是遍历的最小单位。
Composite树枝构件

--|树枝对象，他的作用是组合树枝节点和叶子节点形成一个树形结构。

public class CompositeTest {
	public static void main(String[] args) {
		//创建一个根节点
		Composite root = new Composite();
		root.doSomething();
		//创建一个分支
		Composite branch = new Composite();
		//创建一个叶子节点
		Leaf leaf = new Leaf();
		//添加分支
		root.add(branch);
		//添加叶子
		branch.add(leaf);
		branch.add(leaf);
		branch.add(leaf);
		//遍历所有节点
		display(root);
	}
	/**
	 * 从上到下遍历，所有节点
	 * @param root
	 */
	public static void display(Composite root){
		for(Component c : root.getChildren()){
			if(c instanceof Leaf){  //如果是叶子节点，就是从
				c.doSomething();
			}else{
				//递归调用
				display((Composite)c);
			}
		}
	}
}
abstract class Component{
	//抽象构件，参与组合构架的共有方法和属性
	public void doSomething(){
		System.out.println("执行共有的业务逻辑...");
	}
}
/**
 * 树枝构件，组合树枝节点和叶子节点，形成一个树形结构
 * @author admin
 *
 */
class Composite extends Component{
	//构件容器
	private ArrayList<Component> componentList = new ArrayList<Component>();
	//增加一个叶子节点或树枝节点
	public void add(Component component){
		this.componentList.add(component);
	}
	//删除一个叶子节点或树枝节点
	public void remove(Component component){
		this.componentList.remove(component);
	}
	//遍历所有的节点
	public ArrayList<Component> getChildren(){
		return this.componentList;
	}
}
/**
 * 叶子节点，没有任何的分支
 * @author admin
 *
 */
class Leaf extends Component{
	//重写父类的方法
	@Override
	public void doSomething() {
		// TODO Auto-generated method stub
		System.out.println("叶子节点，执行方法....");
	}
}

一个例子:

如图是公司员工的树形图，要求可以动态的添加员工和部门经理等。并且遍历输出。
1、抽取共有方法和属性作为抽象构件Corp。
2、定义树枝节点，提供添加节点方法和获取所有节点的方法CompanyBranch
3、定义叶子节点。CompanyLeaf

UML类图

public class CompositeT {
	public static void main(String[] args) {
		
		CompanyBranch CEO = getBranch();
		System.out.println(CEO.getInfo());
		System.out.println(display(CEO));
	}
	public static CompanyBranch getBranch(){
		//添加一个ceo
				CompanyBranch CEO = new CompanyBranch("wb", "ceo", 10);
				//添加一个财务经理
				CompanyBranch FD = new CompanyBranch("xy", "财务经理", 10);
				//添加一个销售经理
				CompanyBranch XS = new CompanyBranch("ll", "销售经理", 10);
				//添加一个技术总监
				CompanyBranch CTO = new CompanyBranch("lzl", "技术总监", 10);
				//添加财务人员
				CompanyLeaf a = new CompanyLeaf("小A", "财务人员", 10);
				//添加销售组长
				CompanyBranch b = new CompanyBranch("小B", "销售组长", 10);
				//添加销售组员
				CompanyLeaf c = new CompanyLeaf("小C", "销售组员", 10);
				//添加销售组员
				CompanyLeaf e = new CompanyLeaf("小e", "销售组员", 10);
				//添加技术组长
				CompanyBranch f = new CompanyBranch("小f", "A项目组长", 10);
				//添加技术组长
				CompanyBranch g = new CompanyBranch("小g", "B项目组长", 10);
				//项目组员
				CompanyLeaf h = new CompanyLeaf("小h", "项目A组员", 10);
				CompanyLeaf i = new CompanyLeaf("小i", "项目A组员", 10);
				CompanyLeaf j = new CompanyLeaf("小j", "项目A组员", 10);
				CompanyLeaf k = new CompanyLeaf("小k", "项目B组员", 10);
				CompanyLeaf l = new CompanyLeaf("小l", "项目B组员", 10);
				CompanyLeaf m = new CompanyLeaf("小m", "项目B组员", 10);
				//经理小秘
				CompanyLeaf n = new CompanyLeaf("小花", "经理秘书", 10);
				
				
				//ceo下面是三大经理
				CEO.addCorp(FD);
				CEO.addCorp(CTO);
				CEO.addCorp(XS);
				CEO.addCorp(n);
				//财务经理的手下
				FD.addCorp(a);
				//销售经理的手下
				XS.addCorp(b);
				//销售组长的手下
				b.addCorp(c);
				b.addCorp(e);
				//CTO的手下
				CTO.addCorp(f);
				CTO.addCorp(g);
				//项目组长的手下
				f.addCorp(h);
				f.addCorp(i);
				f.addCorp(j);
				g.addCorp(k);
				g.addCorp(l);
				g.addCorp(m);
		return CEO;
	}
	public static String display(CompanyBranch corp){
		String info = "";
		for(Corp c : corp.getChildren()){
			if(c instanceof CompanyLeaf){
				info = info + c.getInfo();
			}else{
				info = info + c.getInfo()+display((CompanyBranch)c);
			}
		}
		return info;
	}
}
/**
 * 抽象构件，提取共有方法和属性。
 * @author admin
 *
 */
abstract class Corp{
	//每个员工都有姓名，薪水，职称
	private String name;
	private double salary;
	private String position;
	public Corp(String name,String position,double salary) {
		this.name = name;
		this.position = position;
		this.salary = salary;
	}
	public String getInfo(){
		return "姓名:"+this.name+"\t 职称:"+this.position+"\t薪水："+this.salary+"\n";
	}
}
/**
 * 树枝构件，提供添加分支的方法和获取所有节点的方法。
 * @author admin
 *
 */
class CompanyBranch extends Corp{
	//必须有一个私有集合存储
	private ArrayList<Corp> corpList= new ArrayList<Corp>();
	public CompanyBranch(String name, String position, double salary) {
		super(name, position, salary);
	}
	//添加分支，树枝节点或者叶子节点
	public void addCorp(Corp corp){
		this.corpList.add(corp);
	}
	//获取集合。
	public ArrayList<Corp> getChildren(){
		return this.corpList;
	}
}
/**
 * 叶子节点，没有任何分支。
 * @author admin
 *
 */
class CompanyLeaf extends Corp{

	public CompanyLeaf(String name, String position, double salary) {
		super(name, position, salary);
	}
}

组合模式不太理解，只能暂时这么总结了。。