组合模式

https://www.cnblogs.com/V1haoge/p/6489827.html

定义

属于对象的结构模式，有时又叫做“部分——整体”模式。组合模式将对象组织到树结构中，可以用来描述整体和部分的关系。组合模式可以使客户端将单纯元素与复合元素同等看待。

组合模式

组合模式把部分和整体的关系用树结构表示出来。组合模式使得客户端把一个个单独的成分对象和由它们复合而成的复合对象同等看待。

例如：一个文件系统就是典型的组合模式系统。下面是常见的Windows文件系统中的一部分。

 

文件系统的组合模式

从上图可以看出，文件系统是一个树结构，树上长有节点。树的节点有两种，一种是树枝节点，也就是目录，有内部树结构，在图中涂有颜色；另一种是树叶节点，也就是文件，没有内部树结构。

显然，可以把目录和文件当做同一种对象同等对待和处理，这也就是组合模式的应用。

组合模式可以不提供父对象的管理方法，但是组合模式必须在合适的地方提供子对象的管理方法，诸如：add()、remove()、以及getChild()等。

组合模式的实现根据所实现的借口的区别分为两种形式，分别称为安全式和透明式。

安全式组合模式的结构

安全模式的组合模式要求管理聚集的方法只出现在树枝构件类中，而不出现在树叶构件类中。

 

安全式的组合模式

这种形式涉及到三个角色：

• 抽象构件(Component)角色：这是一个抽象角色，它给参加组合的对象定义出公共的接口及其默认行为，可以用来管理所有的子对象。组合对象通常把它所包含的子对象当做类型为Component的对象。在安全式的组合模式里，构建角色并不定义出管理子对象的方法，这一定义由树枝构件对象给出。
• 树叶构件(Leaf)角色：树叶对象没有下级子对象的对象，定义出参加组合的原始对象的行为。
• 树枝构件(Composite)角色：代表参加组合的有下级子对象的对象。树枝构件类给出所有的管理子对象的方法，如add()、remove()、以及getChild()等。

示例代码

抽象构件角色类

public interface Component {
    /**
     * 输出组件自身的名称
     * @param preStr 前缀
     */
    public void printStruct(String preStr);
}

树枝构件角色类

public class Composite implements Component {
    /**
     * 用来存储组合对象中包含的子组件对象
     */
    private List<Component> childComponents = new ArrayList<Component>();
    /**
     * 组合对象的名称
     */
    private String name;
    /**
     * 构造方法，传入组合对象的名称
     * @param name 组合对象的名称
     */
    public Composite(String name) {
        this.name = name;
    }
    
    /**
     * 聚集管理方法，增加一个子构建对象
     * @param child 子构建对象
     */
    public void addChild(Component child) {
        this.childComponents.add(child);
    }
    
    /**
     * 聚集管理方法，删除一个子构建对象
     * @param index 子构建对象的下标
     */
    public void removeChild(int index) {
        this.childComponents.remove(index);
    }
    
    /**
     * 聚集管理方法，返回所有子构建对象
     * @return 子构建对象列表
     */
    public List<Component> getChild() {
        return this.childComponents;
    }

    /**
     * 输出对象的自身结构
     * @param preStr 前缀，主要是按照层级拼装空格，实现向后缩进
     */
    @Override
    public void printStruct(String preStr) {
        //首先输出自身
        System.out.println(preStr + '+' + this.name);
        
        //如果还包含有子组件，那么就输出这些子组件对象
        if (this.childComponents != null) {
            //添加前缀空格，表示向后缩进
            preStr += "  ";
            
            //循环递归输出每个子对象
            for (Component component : childComponents) {
                component.printStruct(preStr);
            }
        }
    }

}

树叶构件角色类

public class Leaf implements Component {
    /**
     * 叶子对象的名称
     */
    private String name;
    /**
     * 构造方法，传入叶子对象的名称
     * @param name 叶子对象的名称
     */
    public Leaf(String name) {
        this.name = name;
    }
    /**
     * 输出叶子对象，因为叶子对象没有字对象，也就是输出叶子对象的名称。
     * @param preStr 前缀，主要是按照层级进行拼接的空格，用于实现向后缩进
     */
    @Override
    public void printStruct(String preStr) {
        System.out.println(preStr + "-" + name);
    }

}

客户端类

public class Client {
    public static void main(String[] args) {
        Composite root = new Composite("服装");
        Composite c1 = new Composite("男装");
        Composite c2 = new Composite("女装");
        
        Leaf leaf1 = new Leaf("衬衫");
        Leaf leaf2 = new Leaf("夹克");
        Leaf leaf3 = new Leaf("裙子");
        Leaf leaf4 = new Leaf("套装");
        
        root.addChild(c1);
        root.addChild(c2);
        c1.addChild(leaf1);
        c1.addChild(leaf2);
        c2.addChild(leaf3);
        c2.addChild(leaf4);
        
        root.printStruct("");
    }
}

可以看出，树枝构件类Composite给出了add()、remove()、以及getChild()等方法的声明和实现，而树叶构件类则没有给出这些方法的声明或实现。这样的做法是安全的做法，由于这个特点，客户端应用程序不可能错误的调用树叶构件的聚集方法，因为树叶构件没有这些方法，调用会导致编译错误。

安全式组合模式的缺点是不够透明，因为树叶类和树枝类将具有不同的接口。

透明式组合模式的结构

与安全式的组合模式不同的是，透明式的组合模式要求所有的具体构建类，不论树枝构件还是树叶构件，均符合一个固定接口。

 

透明式的组合模式

示例代码

抽象构件角色类

public abstract class Component {
    /**
     * 打印组件自身的名称
     * @param preStr 前缀，用于实现缩进
     */
    public abstract void printStruct(String preStr);
    
    /**
     * 聚集管理方法，增加一个子构件对象
     * @param child 子构件对象
     */
    public void addChild(Component child) {
        /**
         * 缺省实现，抛出异常，因为树叶对象没有此功能
         * 或者子组件没有实现这个功能
         */
        throw new UnsupportedOperationException("对象不支持此功能");
    }
    
    /**
     * 聚集管理方法，删除一个子构件对象
     * @param index 子构件对象的下标
     */
    public void removeChild(int index) {
        /**
         * 缺省实现，抛出异常，因为树叶对象没有此功能
         * 或者子组件没有实现这个功能
         */
        throw new UnsupportedOperationException("对象不支持此功能");
    }
    
    /**
     * 聚集管理方法，返回所有子构件对象
     * @return 返回所有子构件对象
     */
    public List<Component> getChild() {
        /**
         * 缺省实现，抛出异常，因为树叶对象没有此功能
         * 或者子组件没有实现这个功能
         */
        throw new UnsupportedOperationException("对象不支持此功能");
    }
}

树枝构件角色类，此类将implements Component改为extends Component，其他地方无变化。

public class Composite extends Component {
    /**
     * 用来存储对象中包含的子构件对象
     */
    private List<Component> childComponents = new ArrayList<Component>();
    
    /**
     * 组合对象的名称
     */
    private String name;
    
    /**
     * 构造方法，传入组合对象的名称
     * @param name 组合对象的名称
     */
    public Composite(String name) {
        this.name = name;
    }

    /**
     * 聚集管理方法，增加一个子构件对象
     * @param child 子构件对象
     */
    public void addChild(Component child) {
        childComponents.add(child);
    }

    /**
     * 聚集管理方法，删除一个子构件对象
     * @param index 子构件对象的下标
     */
    public void removeChild(int index) {
        childComponents.remove(index);
    }

    /**
     * 聚集管理方法，返回所有子构件对象
     * @return 返回所有子构件对象
     */
    public List<Component> getChild() {
        return childComponents;
    }

    public void printStruct(String preStr) {
        //首先输出自身
        System.out.println(preStr + '+' + this.name);
        
        //如果还包含有子组件，那么就输出这些子组件对象
        if (this.childComponents != null) {
            //添加前缀空格，表示向后缩进
            preStr += "  ";
            
            //循环递归输出每个子对象
            for (Component component : childComponents) {
                component.printStruct(preStr);
            }
        }
    }
}

树叶构件角色类，此类将implements Component改为extends Component，其他地方无变化。

public class Leaf extends Component {
    /**
     * 组合对象的名称
     */
    private String name;
    
    /**
     * 构造方法，传入组合对象的名称
     * @param name 组合对象的名称
     */
    public Leaf(String name) {
        this.name = name;
    }

    /**
     * 输出叶子对象，因为叶子对象没有字对象，也就是输出叶子对象的名称。
     * @param preStr 前缀，主要是按照层级进行拼接的空格，用于实现向后缩进
     */
    @Override
    public void printStruct(String preStr) {
        System.out.println(preStr + "-" + name);
    }
}

客户端类的主要变化是不在区分树枝构件角色Composite对象和树叶构件角色Leaf对象。

public class Client {
    public static void main(String[] args) {
        Component root = new Composite("服装");
        Component c1 = new Composite("男装");
        Component c2 = new Composite("女装");
        
        Component leaf1 = new Leaf("衬衫");
        Component leaf2 = new Leaf("夹克");
        Component leaf3 = new Leaf("裙子");
        Component leaf4 = new Leaf("套装");
        
        root.addChild(c1);
        root.addChild(c2);
        c1.addChild(leaf1);
        c1.addChild(leaf2);
        c2.addChild(leaf3);
        c2.addChild(leaf4);
        
        root.printStruct("");
    }
}

可以看出，客户端无需再区分操作的是树枝对象还是树叶对象了，对于客户端而言，操作的都是Component对象。

两种实现方式的选择

这里所说的安全式组成模式是指：从客户端使用组成模式上看是否更安全，如果是安全的，那么就不会有发生误操作的可能，能访问的方法都是被支持的。
这里所说的透明性组成模式是指：从客户端使用组成模式上，是否需要区分到底是“树枝对象”还是“树叶对象”。如果是透明的，那就不用区分，对于客户而言，都是Component对象，具体的类型对于客户端而言是透明的，是无需关心的。

对于组合模式而言，在安全性和透明性上，会更看重透明性，毕竟组合模式的目的是：让客户端不再区分操作的是树枝对象还是树叶对象，而是以一个统一的方式来操作。

而且对于安全性的实现，需要区分的是树枝对象还是树叶对象。有时候，需要将对象进行类型转换，却发现类型信息丢失了，只好强行转换，这种类型转换必然是不够安全的。

因此在使用组合模式的时候，建议多采用透明式的实现方式。

##################################################################################

　组合模式，就是在一个对象中包含其他对象，这些被包含的对象可能是终点对象（不再包含别的对象），也有可能是非终点对象（其内部还包含其他对象，或叫组对象），我们将对象称为节点，即一个根节点包含许多子节点，这些子节点有的不再包含子节点，而有的仍然包含子节点，以此类推。很明显，这是树形结构，终结点叫叶子节点，非终节点（组节点）叫树枝节点，第一个节点叫根节点。同时也类似于文件目录的结构形式：文件可称之为终节点，目录可称之为非终节点（组节点）。

1、我们首先来看一个目录结构的普通实现：

目录节点：Noder

 1 import java.util.ArrayList;
 2 import java.util.List;
 3 /**
 4  * 目录节点
 5  * 包含：
 6  *         1、目录名
 7  *         2、下级文件列表
 8  *         3、下级目录列表
 9  *         4、新增文件方法
10  *         5、新增目录方法
11  *         6、显示下级内容方法
12  */
13 public class Noder {
14     String nodeName;//目录名
15     //通过构造器为目录命名
16     public Noder(String nodeName){
17         this.nodeName = nodeName;
18     }
19     List<Noder> nodeList = new ArrayList<Noder>();//目录的下级目录列表
20     List<Filer> fileList = new ArrayList<Filer>();//目录的下级文件列表
21     //新增下级目录
22     public void addNoder(Noder noder){
23         nodeList.add(noder);
24     }
25     //新增文件
26     public void addFiler(Filer filer){
27         fileList.add(filer);
28     }
29     //显示下级目录及文件
30     public void display(){
31         for(Noder noder:nodeList){
32             System.out.println(noder.nodeName);
33             noder.display();//递归显示目录列表
34         }
35         for(Filer filer:fileList){
36             filer.display();
37         }
38     }
39 }

文件节点：Filer

 1 /**
 2  * 文件节点
 3  * 文件节点是终节点，无下级节点
 4  * 包含：
 5  *         1、文件名
 6  *         2、文件显示方法
 7  */
 8 public class Filer {
 9     String fileName;//文件名
10     public Filer(String fileName){
11         this.fileName = fileName;
12     }
13     //文件显示方法
14     public void display(){
15         System.out.println(fileName);
16     }
17 }

测试类：Clienter

 1 import java.io.File;
 2 
 3 public class Clienter {
 4     public static void createTree(Noder node){
 5         File file = new File(node.nodeName);
 6         File[] f = file.listFiles();
 7         for(File fi : f){
 8             if(fi.isFile()){
 9                 Filer filer = new Filer(fi.getAbsolutePath());
10                 node.addFiler(filer);
11             }
12             if(fi.isDirectory()){
13                 Noder noder = new Noder(fi.getAbsolutePath());
14                 node.addNoder(noder);
15                 createTree(noder);//使用递归生成树结构
16             }
17         }
18     }
19     public static void main(String[] args) {
20         Noder noder = new Noder("E://ceshi");
21         createTree(noder);//创建目录树形结构
22         noder.display();//显示目录及文件
23     }
24 }

运行结果：

E:ceshi目录1
E:ceshi目录1目录3
E:ceshi目录1文件2.txt
E:ceshi目录2
E:ceshi目录2文件3.txt
E:ceshi文件1.txt

2、组合模式

　　从上面的代码中可以看出，我们分别定义了文件节点对象与目录节点对象，这是因为文件与目录之间的操作不同，文件没有下级节点，而目录可以有下级节点，但是我们能不能这么想：既然文件与目录都是可以作为一个节点的下级节点而存在，那么我们可不可以将二者抽象为一类对象，虽然二者的操作不同，但是我们可以在实现类的方法实现中具体定义，比如文件没有新增下级节点的方法，我们就可以在文件的这个方法中抛出一个异常，不做具体实现，而在目录中则具体实现新增操作。显示操作二者都有，可以各自实现。而且由于我们将文件与目录抽象为一个类型，那么结合多态我们可以进行如下实现：

抽象类：Node

 1 /**
 2  * 将文件与目录统一看作是一类节点，做一个抽象类来定义这种节点，然后以其实现类来区分文件与目录，在实现类中分别定义各自的具体实现内容
 3  */
 4 public abstract class Node {
 5     protected String name;//名称
 6     //构造器赋名
 7     public Node(String name){
 8         this.name = name;
 9     }
10     //新增节点：文件节点无此方法，目录节点重写此方法
11     public void addNode(Node node) throws Exception{
12         throw new Exception("Invalid exception");
13     }
14     //显示节点：文件与目录均实现此方法
15     abstract void display();
16 }

文件实现类：Filter

 1 /**
 2  * 实现文件节点
 3  */
 4 public class Filer extends Node {
 5     //通过构造器为文件节点命名
 6     public Filer(String name) {
 7         super(name);
 8     }
 9     //显示文件节点
10     @Override
11     public void display() {
12         System.out.println(name);
13     }
14 }

目录实现类：Noder

 1 import java.util.*;
 2 /**
 3  * 实现目录节点
 4  */
 5 public class Noder extends Node {
 6     List<Node> nodeList = new ArrayList<Node>();//内部节点列表（包括文件和下级目录）
 7     //通过构造器为当前目录节点赋名
 8     public Noder(String name) {
 9         super(name);
10     }
11     //新增节点
12     public void addNode(Node node) throws Exception{
13         nodeList.add(node);
14     }
15     //递归循环显示下级节点
16     @Override
17     void display() {
18         System.out.println(name);
19         for(Node node:nodeList){
20             node.display();
21         }
22     }
23 }

测试类：Clienter

 1 import java.io.File;
 2 
 3 public class Clienter {
 4     public static void createTree(Node node) throws Exception{
 5         File file = new File(node.name);
 6         File[] f = file.listFiles();
 7         for(File fi : f){
 8             if(fi.isFile()){
 9                 Filer filer = new Filer(fi.getAbsolutePath());
10                 node.addNode(filer);
11             }
12             if(fi.isDirectory()){
13                 Noder noder = new Noder(fi.getAbsolutePath());
14                 node.addNode(noder);
15                 createTree(noder);//使用递归生成树结构
16             }
17         }
18     }
19     public static void main(String[] args) {
20         Node noder = new Noder("E://ceshi");
21         try {
22             createTree(noder);
23         } catch (Exception e) {
24             e.printStackTrace();
25         }
26         noder.display();
27     }
28 }

E://ceshi
E:ceshi文件1.txt
E:ceshi目录1
E:ceshi目录1文件2.txt
E:ceshi目录1目录3
E:ceshi目录2
E:ceshi目录2文件3.txt

　　从上述实现中可以看出：所谓组合模式，其实说的是对象包含对象的问题，通过组合的方式（在对象内部引用对象）来进行布局，我认为这种组合是区别于继承的，而另一层含义是指树形结构子节点的抽象（将叶子节点与数枝节点抽象为子节点），区别于普通的分别定义叶子节点与数枝节点的方式。

3、组合模式应用场景

　　这种组合模式正是应树形结构而生，所以组合模式的使用场景就是出现树形结构的地方。比如：文件目录显示，多及目录呈现等树形结构数据的操作。

##################################################################################

https://www.jianshu.com/p/4ac5f330dedc