设计模式-组合模式

来源：《设计模式之禅》

定义：组合模式有叫合成模式或部分-总体模式，主要用来描述总体与部分的关系。

组合模式几个角色：

1. component 抽象构件角色：定义组合对象的共有方法和属性。

2. Leaf 叶子构件：叶子对象，没有其余分支，最小单位。

3. Composite 树枝构件：组合树枝节点和树叶造成一个树形结构。

类图：

代码：

抽象构件

/**
 * 
 */
package cc.rico.pattern.composition;

/**
 * @author rico
 * 抽象构件
 */
public abstract class Component {
	private String name;
	
	public Component(String name) {
		this.name = name;
	}
	
	public void doOption() {
		System.out.println("###name: " + name);
	}

	public String getName() {
		return name;
	}
}

叶子构件

/**
 * 
 */
package cc.rico.pattern.composition;

/**
 * @author rico
 * 叶子构件
 */
public class Leaf extends Component {

	public Leaf(String name) {
		super(name);
	}

	/* (non-Javadoc)
	 * @see cc.rico.pattern.composition.Component#doOption()
	 */
	@Override
	public void doOption() {
		System.out.println("###Leaf.name: " + getName());
	}

}

树枝构件

/**
 * 
 */
package cc.rico.pattern.composition;

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

/**
 * @author rico
 * 树枝构件
 */
public class Composite extends Component {
	private List<Component> children = new ArrayList<Component>();

	public Composite(String name) {
		super(name);
	}

	/* (non-Javadoc)
	 * @see cc.rico.pattern.composition.Component#doOption()
	 */
	@Override
	public void doOption() {
		System.out.println("###Composite.name: " + getName());
	}
	
	public void addChild(Component component) {
		this.children.add(component);
	}

	public List<Component> getChildren() {
		return children;
	}

}

场景类

/**
 * 
 */
package cc.rico.pattern.composition;

import java.util.List;

/**
 * @author rico
 * 场景类
 */
public class Client {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		Composite manager = new Composite("manager");
		Composite codeLeader = new Composite("teamLeader");
		Composite headDesigner = new Composite("headDesigner");
		
		Leaf dev1 = new Leaf("dev1");
		Leaf dev2 = new Leaf("dev2");
		Leaf dev3 = new Leaf("dev3");
		
		Leaf designer1 = new Leaf("designer1");
		Leaf designer2 = new Leaf("designer2");
		Leaf designer3 = new Leaf("designer3");
		
		manager.addChild(codeLeader);
		manager.addChild(headDesigner);
		
		codeLeader.addChild(dev1);
		codeLeader.addChild(dev2);
		codeLeader.addChild(dev3);
		
		headDesigner.addChild(designer1);
		headDesigner.addChild(designer2);
		headDesigner.addChild(designer3);
		
		System.out.println(getTreeInfo(manager));
	}
	
	private static String getTreeInfo(Component component) {
		String componentInfo = "";
		
		if(component instanceof Leaf) {
			componentInfo = "##" + component.getName();
			
		} else if(component instanceof Composite) {
			componentInfo = component.getName();
					
			List<Component> list = ((Composite) component).getChildren();
			for(Component child : list) {
				componentInfo =  componentInfo + "\r" + getTreeInfo(child);
			}
		}
		
		return componentInfo;
	}
}

组合模式优势：

1. 高层模式调用简单，全部的节点都是Component，高层模块不用关心处理的单位是单个对象仍是组合对象。

2. 节点添加自由，

组合模式缺点：

1. 在使用场景类中，直接使用了实现类，与依赖倒置原则冲突。

使用场景：

1. 维护和展现部分-总体关系的场景。如树形菜单，文件和文件夹管理。

2. 从成天中可以独立出部分模块或功能的场景。

扩展：