繼承是is-a的關系。組合和聚合有點像，有些書上沒有作區分，都稱之為has-a，有些書上對其進行了較為嚴格區分，組合是contains-a關系，聚合是has-a關系。

組合方式中被組合的對象生命周期不能超過整體，一般寫代碼時是直接在整體類的構造方法中創建被組合類的對象。如人和手之間的關系，人都沒了，還何來手？

聚合方式中對于對象的生命周期則沒有此類限制，一般可以在聚合類的構造函數中通過外部傳參以賦值給整體（或通過其他set等函數形式），如人有一臺電腦的關系。

總體說來，組合關系相對聚合而言整體和部分關系感更強一些。

回到正題，組合模式中當然在組合對象中含有被組合對象的引用，只是不同的是，組合模式在概念上更加嚴格，通常是指引用的被組合對象類型就是組合對象的類型。如此一來，使得組合對象和被組合對象處理起來具有一致性。當然，前提是組合被對象和被組合對象在本身的概念層次上具有此一致性。

最為經典的體現組合模式的例子是具有樹形結構特點的類定義。對于樹形結構中的每個結點，由于父結點的孩子節點有可能是有自己的孩子結點，因此，利用組合模式，將所有結點統一設計成同一種類型即可。

1.定義樹中結點類， 每個結點都有結點名稱，父節點和孩子結點：

class TreeNode {? ? private String name;? ? private TreeNode parent;? ? private Vectorchildren = new Vector();? ? public TreeNode() {? ? }? ? public TreeNode(String name) {? ? ? ? this.name = name;? ? }? ? public String getName() {? ? ? ? return name;? ? }? ? public void setName(String name) {? ? ? ? this.name = name;? ? }? ? public TreeNode getParent() {? ? ? ? return parent;? ? }? ? public void setParent(TreeNode parent) {? ? ? ? this.parent = parent;? ? }? ? public VectorgetChildren() {? ? ? ? return children;? ? }? ? public void setChildren(Vectorchildren) {? ? ? ? this.children = children;? ? }? ? // 添加孩子結點? ? public void addChild(TreeNode child) {? ? ? ? children.add(child);? ? }? ? // 刪除子結點? ? public void removeChild(TreeNode child) {? ? ? ? children.remove(child);? ? }? ? // 獲取子結點? ? public EnumerationgetChileren() {

return children.elements();

}}

public class Tree {

private TreeNode root;

public Tree() {}

public Tree(String treeName) {root = new TreeNode(treeName);}

public static void main(String[] args) {

Tree tree = new Tree("A");

TreeNode nodeB = new TreeNode("B");TreeNode nodeC = new TreeNode("C");

nodeB.addChild(nodeC);tree.root.addChild(nodeB);

System.out.println("build the tree finished!");}}

在數據結構中我們了解到可以通過調用某個方法來遍歷整個樹，當我們找到某個葉子節點后，就可以對葉子節點進行相關的操作。我們可以將這顆樹理解成一個大的容器，容器里面包含很多的成員對象，這些成員對象即可是容器對象也可以是葉子對象。但是由于容器對象和葉子對象在功能上面的區別，使得我們在使用的過程中必須要區分容器對象和葉子對象，但是這樣就會給客戶帶來不必要的麻煩，作為客戶而已，它始終希望能夠一致的對待容器對象和葉子對象。這就是組合模式的設計動機：組合模式定義了如何將容器對象和葉子對象進行遞歸組合，使得客戶在使用的過程中無須進行區分，可以對他們進行一致的處理。

一、 模式定義

組合模式組合多個對象形成樹形結構以表示“整體-部分”的結構層次。

組合模式對單個對象(葉子對象)和組合對象(組合對象)具有一致性，它將對象組織到樹結構中，可以用來描述整體與部分的關系。同時它也模糊了簡單元素(葉子對象)和復雜元素(容器對象)的概念，使得客戶能夠像處理簡單元素一樣來處理復雜元素，從而使客戶程序能夠與復雜元素的內部結構解耦。

上面的圖展示了計算機的文件系統，文件系統由文件和目錄組成，目錄下面也可以包含文件或者目錄，計算機的文件系統是用遞歸結構來進行組織的，對于這樣的數據結構是非常適用使用組合模式的。

在使用組合模式中需要注意一點也是組合模式最關鍵的地方：葉子對象和組合對象實現相同的接口。這就是組合模式能夠將葉子節點和對象節點進行一致處理的原因。

二、 模式結構

組合模式主要包含如下幾個角色：

1.Component ：組合中的對象聲明接口，在適當的情況下，實現所有類共有接口的默認行為。聲明一個接口用于訪問和管理Component子部件。

2.Leaf：葉子對象。葉子結點沒有子結點。

3.Composite：容器對象，定義有枝節點行為，用來存儲子部件，在Component接口中實現與子部件有關操作，如增加(add)和刪除(remove)等。

從模式結構中我們看出了葉子節點和容器對象都實現Component接口，這也是能夠將葉子對象和容器對象一致對待的關鍵所在。

三、 模式實現

在文件系統中，可能存在很多種格式的文件，如果圖片，文本文件、視頻文件等等，這些不同的格式文件的瀏覽方式都不同，同時對文件夾的瀏覽就是對文件夾中文件的瀏覽，但是對于客戶而言都是瀏覽文件，兩者之間不存在什么差別，現在只用組合模式來模擬瀏覽文件。UML結構圖：

首先是文件類：File.java

public abstract class File {String name;

public File(String name){this.name = name;}

public String getName() {return name;}

public void setName(String name) {this.name = name;}

public abstract void display();}

然后是文件夾類：Folder.java，該類包含對文件的增加、刪除和瀏覽三個方法

public class Folder extends File{

private List files;

public Folder(String name){super(name);files = new ArrayList();}

public void display() {for(File file : files){file.display();}}

public void add(File file){files.add(file);}

public void remove(File file){files.remove(file);}}

然后是三個文件類：TextFile.java、ImageFile.java、VideoFile.java

TextFile.java

public class TextFile extends File{public TextFile(String name) {super(name);}

public void display() {System.out.println("這是文本文件，文件名：" + super.getName());}}

ImageFile.java

public class ImagerFile extends File{public ImagerFile(String name) {super(name);}

public void display() {System.out.println("這是圖像文件，文件名：" + super.getName());}}

VideoFile.java

public class VideoFile extends File{public VideoFile(String name) {super(name);}

public void display() {System.out.println("這是影像文件，文件名：" + super.getName());}}

最后是客戶端

public class Client {

public static void main(String[] args) {//總文件夾

Folder zwjj = new Folder("總文件夾");

//向總文件夾中放入三個文件：1.txt、2.jpg、1文件夾

TextFile aText= new TextFile("a.txt");

ImagerFile bImager = new ImagerFile("b.jpg");

Folder cFolder = new Folder("C文件夾");

zwjj.add(aText);zwjj.add(bImager);zwjj.add(cFolder);

//向C文件夾中添加文件：c_1.txt、c_1.rmvb、c_1.jpg

TextFile cText = new TextFile("c_1.txt");

ImagerFile cImage = new ImagerFile("c_1.jpg");

VideoFile cVideo = new VideoFile("c_1.rmvb");

cFolder.add(cText);cFolder.add(cImage);cFolder.add(cVideo);//遍歷C文件夾

cFolder.display();//將c_1.txt刪除

cFolder.remove(cText);System.out.println("-----------------------");cFolder.display();}}

運行結果

四、 模式優缺點

優點

1、可以清楚地定義分層次的復雜對象，表示對象的全部或部分層次，使得增加新構件也更容易。

2、客戶端調用簡單，客戶端可以一致的使用組合結構或其中單個對象。

3、定義了包含葉子對象和容器對象的類層次結構，葉子對象可以被組合成更復雜的容器對象，而這個容器對象又可以被組合，這樣不斷遞歸下去，可以形成復雜的樹形結構。

4、更容易在組合體內加入對象構件，客戶端不必因為加入了新的對象構件而更改原有代碼。

缺點

1、使設計變得更加抽象，對象的業務規則如果很復雜，則實現組合模式具有很大挑戰性，而且不是所有的方法都與葉子對象子類都有關聯

五、 模式適用場景

1、需要表示一個對象整體或部分層次，在具有整體和部分的層次結構中，希望通過一種方式忽略整體與部分的差異，可以一致地對待它們。

2、讓客戶能夠忽略不同對象層次的變化，客戶端可以針對抽象構件編程，無須關心對象層次結構的細節。

六、 模式總結

1、組合模式用于將多個對象組合成樹形結構以表示“整體-部分”的結構層次。組合模式對單個對象（葉子對象）和組合對象（容器對象）的使用具有一致性。

2、 組合對象的關鍵在于它定義了一個抽象構建類，它既可表示葉子對象，也可表示容器對象，客戶僅僅需要針對這個抽象構建進行編程，無須知道他是葉子對象還是容器對象，都是一致對待。

3、組合模式雖然能夠非常好地處理層次結構，也使得客戶端程序變得簡單，但是它也使得設計變得更加抽象，而且也很難對容器中的構件類型進行限制，這會導致在增加新的構件時會產生一些問題。