结构型模式：组合模式(Composite Pattern)

一、设计模式的分类

(如果以前看过关于设计模式的分类的话，这部分可以忽略！)

经过很多大神的总结，目前Java中一共23种经典的设计模式！

按照目的，设计模式可以分为以下三种用途：

1.创建型模式：用来处理对象的创建过程

2.结构型模式：用来处理类或者对象的组合

3.行为型模式：用来对类或对象怎样交互和怎样分配职责进行描述

创建型模式用来处理对象的创建过程，主要包含以下5种设计模式：

 工厂方法模式（Factory Method Pattern）

 抽象工厂模式（Abstract Factory Pattern）

 建造者模式（Builder Pattern）

 原型模式（Prototype Pattern）

 单例模式（Singleton Pattern）

结构型模式用来处理类或者对象的组合，主要包含以下7种设计模式：

 适配器模式（Adapter Pattern）

 桥接模式（Bridge Pattern）

 组合模式（Composite Pattern）

 装饰者模式（Decorator Pattern）

 外观模式（Facade Pattern）

 享元模式（Flyweight Pattern）

 代理模式（Proxy Pattern）

行为型模式用来对类或对象怎样交互和怎样分配职责进行描述，主要包含以下11种设计模式：

 责任链模式（Chain of Responsibility Pattern）

 命令模式（Command Pattern

 解释器模式（Interpreter Pattern）

 迭代器模式（Iterator Pattern）

 中介者模式（Mediator Pattern）

 备忘录模式（Memento Pattern）

 观察者模式（Observer Pattern）

 状态模式（State Pattern）

 策略模式（Strategy Pattern）

 模板方法模式（Template Method Pattern）

 访问者模式（Visitor Pattern） 

本篇文章主要为讲解一下组合模式（Composite Pattern）！

注：概念性的东西可以忽略不看，可以在看完例子以后再看概念，这样更有利于理解！

二、组合模式概述

(注：建议没有看过组合模式的朋友们，先看实例，然后再看枯燥的概念)

看到Composite组合模式的时候你就应该往树形结构图上去想，这样更有利于你去理解组合模式!
组合模式定义：将对象以树形结构组织起来,以达成"部分－－整体"的层次结构，使得客户端对单个对象和组合对象的使用具有一致性，方便客户端的使用。
组合体内所有的对象都有共同的接口,当组合体中某一个对象的方法被调用执行时，组合模式Composite将遍历整个树形结构,寻找同样包含这个方法的对象并实现调用执行（可以在实例中感受一下，只看概念你会感觉知识点很空洞）。

组合模式让你可以优化处理递归或分级数据结构。有许多关于分级数据结构的例子，使得组合模式非常有用武之地。关于分级数据结构的一个普遍性的例子是你每次使用电脑时所遇到的：文件系统。文件系统由目录和文件组成，每个目录都可以装内容。目录的内容可以是文件，也可以是目录。按照这种方式，计算机的文件系统就是以递归结构来组织的。如果你想要描述这样的数据结构，那么你可以使用组合模式Composite。

组合模式涉及角色：

1、Component是组合模式中的对象声明接口，在适当的情况下，它实现所有类共有接口的默认行为。声明一个接口用于访问和管理Component子部件。
　　2、Leaf 在组合模式中表示叶子结点对象(没有子节点)。

　　3、Composite用来定义有枝节点行为，存储子部件，在Component接口中实现与子部件有关操作，如增加(add)和删除(remove)等。

三、类图

四、实例说明

如果你想要创建层次结构，并可以在其中以相同的方式对待所有元素，那么组合模式就是最理想的选择。

下面使用一个文件系统的例子来举例说明组合模式的用途。在例子中，文件和目录都继承相同的接口，这是组合模式的关键。通过继承相同的接口，你就可以用相同的方式对待文件和目录，从而实现将文件或者目录储存为目录的子级元素。

举例如下：

注：虽然下面的例子并没有真正的生成文件目录结构，我们就假设生成的是目录结构，而下面的name属性就当做是文件或者目录的名字！

1. public abstract class Company {  
2.     private String name;  
3.     public Company(String name) {  
4.         this.name = name;  
5.     }  
6.     public Company() {  
7.     }  
8.     public String getName() {  
9.         return name;  
10.     }  
11.     public void setName(String name) {  
12.         this.name = name;  
13.     }  
14.     protected abstract void add(Company company);   //添加
15.     protected abstract void romove(Company company);//删除  
16.     protected abstract void display(int depth);     //显示
17. }  

1. import java.util.ArrayList;  
2. import java.util.List;  
3. 
   
4. public class ConcreteCompany extends Company {  
5.     private List<Company> cList;  
6.   
7.     public ConcreteCompany() {  
8.         cList = new ArrayList<Company>();  
9.     }  
10.     public ConcreteCompany(String name) {  
11.         super(name);   
12.         cList = new ArrayList<Company>() ;   
13.     }  
14.     @Override  
15.     protected void add(Company company) {  
16.         cList.add(company);  
17.     }  
18.     @Override  
19.     protected void display(int depth) {//深度
20.         StringBuilder sb = new StringBuilder("");  
21.         for (int i = 0; i < depth; i++) {  
22.             sb.append("-");   
23.         }
24.         System.out.println(new String(sb) + this.getName());  
25.         for (Company c : cList) {  
26.             c.display(depth + 2);  
27.         }  
28.     }  
29.     @Override  
30.     protected void romove(Company company) {  
31.         cList.remove(company);  
32.     }  
33. }    

1. public class FinanceDepartment extends Company {//叶子节点
2.     public FinanceDepartment(){  
3.     }  
4.     public FinanceDepartment(String name){  
5.         super(name);  
6.     }  
7.     @Override  
8.     protected void add(Company company) {  
9.     }  
10.     @Override  
11.     protected void display(int depth) {  
12.         StringBuilder sb = new StringBuilder("");  
13.         for (int i = 0; i < depth; i++) {  
14.             sb.append("-");  
15.         }  
16.         System.out.println(new String(sb) + this.getName() ) ;   
17.     }  
18.     @Override  
19.     protected void romove(Company company) {
20.     }       
21. }  

1. public class HRDepartment extends Company {  
2.     public HRDepartment(){  
3.     }  
4.     public HRDepartment(String name){  
5.         super(name);  
6.     }  
7.     @Override  
8.     protected void add(Company company) {  
9.     }  
10.     @Override  
11.     protected void display(int depth) {  
12.         StringBuilder sb = new StringBuilder("");  
13.         for (int i = 0; i < depth; i++) {  
14.             sb.append("-");   
15.         }  
16.         System.out.println(new String(sb) + this.getName() ) ;   
17.     }  
18.     @Override  
19.     protected void romove(Company company) {     
20.     }  
21. }  

1. public class Client {  
2.     public static void main(String[] args) {  
3.         Company root = new ConcreteCompany();  
4.         root.setName("北京总公司");  
5.         root.add(new HRDepartment("总公司人力资源部"));  
6.         root.add(new FinanceDepartment("总公司财务部"));  
7.         Company shandongCom = new ConcreteCompany("山东分公司");  
8.         shandongCom.add(new HRDepartment("山东分公司人力资源部"));  
9.         shandongCom.add(new FinanceDepartment("山东分公司账务部"));  
10.         Company zaozhuangCom = new ConcreteCompany("枣庄办事处");  
11.         zaozhuangCom.add(new FinanceDepartment("枣庄办事处财务部"));  
12.         zaozhuangCom.add(new HRDepartment("枣庄办事处人力资源部"));  
13.         Company jinanCom = new ConcreteCompany("济南办事处");  
14.         jinanCom.add(new FinanceDepartment("济南办事处财务部"));  
15.         jinanCom.add(new HRDepartment("济南办事处人力资源部"));   
16.         shandongCom.add(jinanCom);  
17.         shandongCom.add(zaozhuangCom);  
18.         Company huadongCom = new ConcreteCompany("上海华东分公司");  
19.         huadongCom.add(new HRDepartment("上海华东分公司人力资源部"));  
20.         huadongCom.add(new FinanceDepartment("上海华东分公司账务部"));  
21.         Company hangzhouCom = new ConcreteCompany("杭州办事处");  
22.         hangzhouCom.add(new FinanceDepartment("杭州办事处财务部"));  
23.         hangzhouCom.add(new HRDepartment("杭州办事处人力资源部"));  
24.         Company nanjingCom = new ConcreteCompany("南京办事处");  
25.         nanjingCom.add(new FinanceDepartment("南京办事处财务部"));  
26.         nanjingCom.add(new HRDepartment("南京办事处人力资源部"));  
27.         huadongCom.add(hangzhouCom);  
28.         huadongCom.add(nanjingCom);   
29.         root.add(shandongCom);  
30.         root.add(huadongCom);  
31.         root.display(0);  
32.     }  
33.   
34. }  

运行结果如下：

=====================================================

北京总公司

--总公司人力资源部

--总公司财务部

--山东分公司

----山东分公司人力资源部

----山东分公司账务部

----济南办事处

------济南办事处财务部

------济南办事处人力资源部

----枣庄办事处

------枣庄办事处财务部

------枣庄办事处人力资源部

--上海华东分公司

----上海华东分公司人力资源部

----上海华东分公司账务部

----杭州办事处

------杭州办事处财务部

------杭州办事处人力资源部

----南京办事处

------南京办事处财务部

------南京办事处人力资源部

=====================================================

(注：把各种解决方案的实现拿来对比一下更有利于你去理解组合模式的好处!)

五、安全性与透明性

组合模式中必须提供对子对象的管理方法，不然无法完成对子对象的添加删除等等操作，也就失去了灵活性和扩展性。但是管理方法是在Component中就声明还是在Composite中声明呢？

一种方式是：在Component里面声明所有的用来管理子类对象的方法，以达到Component接口的最大化（如下图所示）。目的就是为了使客户看来在接口层次上树叶和分支没有区别——透明性。但树叶是不存在子类的，因此Component声明的一些方法对于树叶来说是不适用的。这样也就带来了一些安全性问题。

另一种方式是：只在Composite里面声明所有的用来管理子类对象的方法(如下图所示)。这样就避免了上一种方式的安全性问题，但是由于叶子和分支有不同的接口，所以又失去了透明性。

但是在组合模式中，相对于安全性来说，我们比较看中透明性。对于第一种方式中叶子节点内不需要的方法可以使用空处理或者异常报告的方式来解决。

组合Composite模式的优缺点： 
1、使客户端的调用变得简单，客户端可以一致的使用组合结构或其中单个对象，用户就不必关系自己处理的是单个对象还是整个组合结构，这就简化了客户端代码。 
        2、更容易在组合体内加入对象部件. 客户端不必因为加入了新的对象部件而更改代码。

        当然组合模式也少不了缺点：组合模式不容易限制组合中的构件。

六、组合模式的优缺点  

1、使客户端的调用变得简单，客户端可以一致的使用组合结构或其中单个对象，用户就不必关系自己处理的是单个对象还是整个组合结构，这就简化了客户端代码。 
        2、更容易在组合体内加入对象部件. 客户端不必因为加入了新的对象部件而更改代码。

        当然组合模式也少不了缺点：组合模式不容易限制组合中的构件。

到此为止相信大家已经看懂了上面的例子。但是很多人或许还有疑惑，似乎我们自己很难想象到一个需要使用组合模式的场景，大家不要急，等用到的时候你自然会想到组合模式，我们学习设计模式多是用来储备知识的，项目开发未必会用到所有的设计模式！

最后，希望大家共同进步！那里有问题，望指出！

组合Composite模式的优缺点： 
1、使客户端的调用变得简单，客户端可以一致的使用组合结构或其中单个对象，用户就不必关系自己处理的是单个对象还是整个组合结构，这就简化了客户端代码。 
        2、更容易在组合体内加入对象部件. 客户端不必因为加入了新的对象部件而更改代码。

        当然组合模式也少不了缺点：组合模式不容易限制组合中的构件。