設計模式-組合模式

來源：《設計模式之禪》

定義：組合模式有叫合成模式或部分-總體模式，主要用來描述總體與部分的關係。

組合模式幾個角色：

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. 從成天中可以獨立出部分模塊或功能的場景。

擴展：