將物件組合成樹形結構，以表示“部分-整體”的層次結構，使得使用者對單個物件和組合物件的使用具有一致性。

一、公司組織架構1（介面篇）

1. 公司人員介面

public interface ICorp {
	//獲取自己的資訊（每個員工都有資訊，你想隱藏，門兒都沒有）
	public String getInfo();
}

public interface ILeaf extends ICorp{
	
}

public interface IBranch extends ICorp{
	//能夠增加小兵（樹葉節點）或者是經理（樹枝節點）—— 不管傳什麼都是向上造型
	public void addSubordinate(ICorp corp);
	//我還要能夠獲得下屬的資訊
	public ArrayList<ICorp> getSubordinate();
}
 

public class Leaf implements ILeaf{
	//葉子叫什麼名字
	private String name = "";
	//葉子的職位
	private String position = "";
	//葉子的薪水
	private int salary = 0;
	//通過建構函式傳遞資訊
	public Leaf(String name, String position, int salary) {
		this.name = name;
		this.position = position;
		this.salary = salary;
	}
	//最小的小兵只能獲得自己的資訊了
	public String getInfo() {
		String info = "";
		info = "名稱:"+this.name;
		info = info + "\t職位:"+this.position;
		info = info + "\t薪水:"+this.salary;
		return info;
	}
}
 

public class Branch implements IBranch{
	//儲存子節點的資訊
	private ArrayList subordinateList = new ArrayList();
	//樹枝節點的名稱
	private String name = "";
	//樹枝節點的職位
	private String position = "";
	//樹枝節點的薪水
	private int salary = 0;
	//通過建構函式傳遞樹枝節點的引數
	public Branch(String name, String position,int salary) {
		this.name = name;
		this.position = position;
		this.salary = salary;
	}
	//增加一個下屬，可能 是小頭目，也可能是個小兵
	public void addSubordinate(ICorp corp) {
		this.subordinateList.add(corp);
	}
	//我有哪些下屬
	public ArrayList<ICorp> getSubordinate() {
		return this.subordinateList;
	}
	//得到自己的資訊
	public String getInfo() {
		String info = "";
		info = "名稱:"+this.name;
		info = info + "\t職位:"+this.position;
		info = info + "\t薪水:"+this.salary;
		return info;
	}
}
 

public class Client {
	public static void main(String[] args) {
		//首先是組裝一個組織結構出來 
		Branch ceo = compositeCorpTree();
		//首先把ceo的資訊打印出來
		System.out.println(ceo.getInfo());
		//然後是所有員工資訊
		System.out.println(getTreeInfo(ceo));
	}
	
	public static Branch compositeCorpTree(){
		//首先產生總經理CEO
		Branch root = new Branch("王大麻子", "總經理", 100000);
		//把三個部門經理產生出來 
		Branch developDep = new Branch("劉大瘸子", "研發部門經理", 10000);
		Branch salesDep = new Branch("馬二柺子", "銷售部門經理", 20000);
		Branch financeDep = new Branch("趙三駝子", "財務部門經理", 30000);
		//再把三個小組長產生出來 
		Branch firstDevGroup = new Branch("楊三也斜","開發一組組長",5000);
		Branch secondDevGroup = new Branch("吳大植株","開發二組組長",6000);
		//把所有的小兵都產生出來 
		Leaf a = new Leaf("a","開發人員",2000);
		Leaf b = new Leaf("b","開發人員",2000);
		Leaf c = new Leaf("c","開發人員",2000);
		Leaf d = new Leaf("d","開發人員",2000);
		Leaf e = new Leaf("e","開發人員",2000);
		Leaf f = new Leaf("f","開發人員",2000);
		Leaf g = new Leaf("g","開發人員",2000);
		Leaf h = new Leaf("h", "銷售人員", 5000);
		Leaf i = new Leaf("i", "銷售人員", 4000);
		Leaf j = new Leaf("j", "財務人員", 5000);
		Leaf k = new Leaf("k", "CEO祕書", 8000);
		Leaf zhengLaoLiu = new Leaf("鄭老六", "研發部副經理", 20000);
		//開始組裝
		//CEO下有三個部門經理和一個祕書
		root.addSubordinate(developDep);
		root.addSubordinate(salesDep);
		root.addSubordinate(financeDep);
		root.addSubordinate(k);
		//研發部經理
		developDep.addSubordinate(firstDevGroup);
		developDep.addSubordinate(secondDevGroup);
		developDep.addSubordinate(zhengLaoLiu);
		//看看兩個開發小組下有什麼
		firstDevGroup.addSubordinate(a);
		firstDevGroup.addSubordinate(b);
		firstDevGroup.addSubordinate(c);
		secondDevGroup.addSubordinate(d);
		secondDevGroup.addSubordinate(e);
		secondDevGroup.addSubordinate(f);
		//再看銷售部下的人員情況
		salesDep.addSubordinate(h);
		salesDep.addSubordinate(i);
		//最後一個財務
		financeDep.addSubordinate(j);
		return root;
	}
	//遍歷整棵樹，只要給我根節點，我就能遍歷出所有的節點
	public static String getTreeInfo(Branch root){
		List<ICorp> subordinateList = root.getSubordinate();
		String info = "";
		for(ICorp s : subordinateList){
			if(s instanceof Leaf){
				info = info + s.getInfo() + "\n";
			}else{	//是個小頭目
				info = info + s.getInfo() + "\n" + getTreeInfo((Branch)s);
			}
		}
		return info;
	}
}

主要是把ICorp介面修改為Corp抽象類，抽象出來很多公共地方，方便很多。

1. 抽象公司職員類

public abstract class Corp {
	//公司每個人都有名稱
	private String name = "";
	//公司每個人都有職位
	private String position = "";
	//公司每個人都有薪水
	private int salary = 0;
	public Corp(String name, String position, int salary) {
		this.name = name;
		this.position = position;
		this.salary = salary;
	}
	//獲取員工資訊
	public String getInfo(){
		String info = "";
		info = "名稱:"+this.name;
		info = info + "\t職位:"+this.position;
		info = info + "\t薪水:"+this.salary;
		return info;
	}
}

public class Leaf extends Corp{
	//就寫一個建構函式，這個是必須 的
	public Leaf(String name, String position, int salary) {
		super(name, position, salary);
	}
}

public class Branch extends Corp{
	//儲存子節點的資訊
	private ArrayList subordinateList = new ArrayList();
	//建構函式是必須 的
	public Branch(String name, String position, int salary) {
		super(name, position, salary);
	}
	//增加一個下屬，可能 是小頭目，也可能是個小兵
	public void addSubordinate(Corp corp) {
		this.subordinateList.add(corp);
	}
	//我有哪些下屬
	public ArrayList<Corp> getSubordinate() {
		return this.subordinateList;
	}
}

程式碼太長，同上例，修改其中部分方法

//遍歷整棵樹，只要給我根節點，我就能遍歷出所有的節點
public static String getTreeInfo(Branch root){
	List<Corp> subordinateList = root.getSubordinate();
	String info = "";
	for(Corp s : subordinateList){
		if(s instanceof Leaf){
			info = info + s.getInfo() + "\n";
		}else{	//是個小頭目
			info = info + s.getInfo() + "\n" + getTreeInfo((Branch)s);
		}
	}
	return info;
}

Leaf葉子構件：葉子物件，其下再也沒有其它分支，也就是遍歷的最小單位。

Composite樹枝構件：樹枝物件，作用是組合樹枝節點和葉子節點形成一個樹形結構。

1. 抽象構件

public abstract class Component {
	//個體和整體都具有的共享
	public void doSomething(){
		//編寫業務邏輯
	}
}

public class Composite extends Component{
	//構件容器
	private List<Component> componentArrayList = new ArrayList<Component>();
	//增加一個葉子構件或樹枝構件
	public void add(Component component){
		this.componentArrayList.add(component);
	}
	//刪除一個葉子構件或樹枝構件
	public void remove(Component component){
		this.componentArrayList.remove(component);
	}
	//獲得分支下的所有葉子構件和樹枝構件
	public List<Component> getChildren(){
		return this.componentArrayList;
	}
}

public class Leaf extends Component{
	/*
	 * 可以覆寫父類方法
	 * public void doSomething(){
	 * 
	 * }
	 */
}

public class Client {
	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);
	}
	//通過遞迴遍歷樹
	public static void display(Composite root){
		for(Component c:root.getChildren()){	//葉子節點
			if(c instanceof Leaf){
				c.doSomething();
			}else{	//樹枝節點 
				display((Composite)c);
			}
		}
	}
}

1.優點：

高層模組呼叫簡單：一棵樹形機構中的所有節點都是Component，區域性和整體對呼叫者來說沒有任何區別，也就是說，高層模組不必關心自己處理的是單個物件還是整個組合結構，簡化了高層模組的程式碼。

節點自由增加：使用組合模式後，如果想增加一個樹枝節點、樹葉節點都很容易，只要找到它的父節點就成，符合開閉原則。

2. 缺點

看到在我們的場景類中定義，提到樹葉和樹枝使用時的定義了嗎？直接使用了實現類！這在面向介面程式設計上是很不恰當的，與依賴倒置原則衝突，讀者在使用時要考慮清楚，它限制了你介面的影響範圍

3. 使用用場景

1）維護和展示部分-整體關係的場景，如樹形選單、檔案和資料夾管理。

2）從一個整體中能夠獨立出部分模組或功能的場景。

4. 組合模式的注意事項

只要是樹形結構，就要考慮使用組合模式，這個一定要記住，只要是要體現區域性和整體的關係的時候，而且這種關係還可能比較深，考慮一下組合模式吧
五、組合模式的擴充套件
1. 真實的組合模式

上述Client程式沒沒有改變多少，樹的組裝是跑不了的，但樹的組裝並不是像例子中的new，而是一般先有一張資料庫的表，這張資料表定義了一個樹形結構，我們把它讀取出來，然後展現到前臺上，用for迴圈加上遞迴就可以完成這個讀取，

我們上面的例子是安全模式，下面將下透明模式，透明模式是把用來組合使用的方法放到抽象中，比如add()、remove()以及getChildren等方法（），不管葉子物件不是樹枝物件都有相同的結構，通過判斷是getChildren的返回值確認是葉子節點 不是樹枝節點，如果處理不當會在執行期出現錯誤，所以建議用上述例子中的安全模式。

1） 抽象構件

public abstract class Component {
	//個體和整體都具有的共享
	public void doSomething(){
		//編寫業務邏輯
	}
	//增加一個葉子構件或樹枝構件
	public abstract void add(Component component);
	//刪除一個葉子構件或樹枝構件
	public abstract void remove(Component component);
	//獲得分支下的所有葉子構件和樹枝構件
	public abstract ArrayList<Component> getChildren();
}

public class Leaf extends Component{
	public void add(Component component) {
		//空實現，直接拋一個“不支援請求”異常
		throw new UnsupportedOperationException();
	}
	public void remove(Component component) {
		//空實現，直接拋一個“不支援請求”異常
		throw new UnsupportedOperationException();
	}
	public ArrayList<Component> getChildren() {
		//空實現，直接拋一個“不支援請求”異常
		throw new UnsupportedOperationException();
	}
}

public class Client {
	public static void main(String[] args) {
		
	}
	//通過遞迴遍歷樹
	public static void display(Component root){
		for(Component c:root.getChildren()){
			if(c instanceof Leaf){
				c.doSomething();
			}else{	//樹枝節點
				display(c);
			}
		}
	}
}

上面例子是從上向下獲取子節點，如果我想獲取父節點，可以這樣做

1）抽象構件

public abstract class Corp {
	//公司每個人都有名稱
	private String name = "";
	//公司每個人都有職位
	private String position = "";
	//公司每個人都有薪水
	private int salary = 0;
	//父節點是誰
	private Corp parent = null;
	public Corp(String name, String position, int salary) {
		this.name = name;
		this.position = position;
		this.salary = salary;
	}
	//獲取員工資訊
	public String getInfo(){
		String info = "";
		info = "名稱:"+this.name;
		info = info + "\t職位:"+this.position;
		info = info + "\t薪水:"+this.salary;
		return info;
	}
	//設定父節點
	protected void setParent(Corp _parent){
		this.parent = _parent;
	}
	//得到父節點
	public Corp getParent(){
		return this.parent;
	}
}

public class Branch extends Corp{
	//儲存子節點的資訊
	private ArrayList subordinateList = new ArrayList();
	//建構函式是必須 的
	public Branch(String name, String position, int salary) {
		super(name, position, salary);
	}
	//增加一個下屬，可能 是小頭目，也可能是個小兵
	public void addSubordinate(Corp corp) {
		corp.setParent(this);	//設定父節點 
		this.subordinateList.add(corp);
	}
	//我有哪些下屬
	public ArrayList<Corp> getSubordinate() {
		return this.subordinateList;
	}
}

一般主頁左邊的導航選單或者有樹形結構的模組都可以考慮。