设计模式：结构型-组合模式

朱雀 2022-10-22 07:59 197阅读 0赞

### 目录 ###

*  第一章 组合模式介绍
 *  第二章 组合模式实现（透明式）
 *   *  2.1、透明式介绍
     *  2.2、抽象构件
     *  2.3、树叶构件
     *  2.4、树枝构件
     *  2.5、客户端测试
 *  第三章 组合模式实现（安全式）
 *   *  3.1、安全式介绍
     *  3.2、抽象构件
     *  3.3、树叶构件
     *  3.4、树枝构件
     *  3.5、客户端测试
 *  第四章 组合模式应用

--------------------

> 项目地址：https://gitee.com/caochenlei/design-pattern

# 第一章 组合模式介绍 #

组合模式的介绍：

组合模式（Composite Pattern）又叫“整体-部分”模式，是用于把一组相似的对象当作一个单一的对象。它是一种将对象组合成树状的层次结构的模式，用来表示“整体-部分”的关系，使用户对单个对象和组合对象具有一致的访问性，属于结构型设计模式。组合模式分为透明式的组合模式和安全式的组合模式。

组合模式一般用来描述整体与部分的关系，它将对象组织到树形结构中，顶层的节点被称为根节点，根节点下面可以包含树枝节点和叶子节点，树枝节点下面又可以包含树枝节点和叶子节点，树形结构图如下：

![dae3398febafb42f26ab7dea9c313085.png][]

由上图可以看出，其实根节点和树枝节点本质上属于同一种数据类型，可以作为容器使用，而叶子节点与树枝节点在语义上不属于同一种类型。但是在组合模式中，会把树枝节点和叶子节点看作属于同一种数据类型（用统一接口定义），让它们具备一致行为。

组合模式的优点：

*  组合模式使得客户端代码可以一致地处理单个对象和组合对象，无须关心自己处理的是单个对象，还是组合对象，这简化了客户端代码。
 *  更容易在组合体内加入新的对象，客户端不会因为加入了新的对象而更改源代码，满足“开闭原则”。

组合模式的缺点：

*  设计较复杂，客户端需要花更多时间理清类之间的层次关系。
 *  不容易限制容器中的构件。
 *  不容易用继承的方法来增加构件的新功能。

组合模式的场景：

*  算术表达式包括操作数、操作符和另一个操作数，其中，另一个操作符也可以是操作数、操作符和另一个操作数。
 *  在 Java awt 和 swing 中，对于 Button 和 Checkbox 是树叶，而 Container 是树枝。

组合模式的角色：

*  抽象构件（Component）角色：它的主要作用是为树叶构件和树枝构件声明公共接口，并实现它们的默认行为。在透明式的组合模式中抽象构件还声明访问和管理子类的接口；在安全式的组合模式中不声明访问和管理子类的接口，管理工作由树枝构件完成。
 *  树叶构件（Leaf）角色：是组合中的叶节点对象，它没有子节点，用于继承或实现抽象构件。
 *  树枝构件（Composite）角色 / 中间构件：是组合中的分支节点对象，它有子节点，用于继承和实现抽象构件。它的主要作用是存储和管理子部件，通常包含 Add()、Remove()、GetChild() 等方法。

# 第二章 组合模式实现（透明式） #

## 2.1、透明式介绍 ##

在该方式中，由于抽象构件声明了所有子类中的全部方法，所以客户端无须区别树叶对象和树枝对象，对客户端来说是透明的。但其缺点是：树叶构件本来没有 Add()、Remove() 及 GetChild() 方法，却要实现它们（空实现或抛异常），这样会带来一些安全性问题。其结构如下图：

![5e4f41038dc7cd94a8dd8384653d5a77.gif][]

## 2.2、抽象构件 ##

Component

public interface Component { 
        public void add(Component c);
    
        public void remove(Component c);
    
        public Component getChild(int i);
    
        public void operation();
    }

## 2.3、树叶构件 ##

Leaf

public class Leaf implements Component { 
        private String name;
    
        public Leaf(String name) { 
            this.name = name;
        }
    
        public void add(Component c) { 
        }
    
        public void remove(Component c) { 
        }
    
        public Component getChild(int i) { 
            return null;
        }
    
        public void operation() { 
            System.out.println("树叶" + name + "：被访问！");
        }
    }

## 2.4、树枝构件 ##

Composite

public class Composite implements Component { 
        private ArrayList<Component> children = new ArrayList<>();
    
        public void add(Component c) { 
            children.add(c);
        }
    
        public void remove(Component c) { 
            children.remove(c);
        }
    
        public Component getChild(int i) { 
            return children.get(i);
        }
    
        public void operation() { 
            for (Object obj : children) { 
                ((Component) obj).operation();
            }
        }
    }

## 2.5、客户端测试 ##

CompositePattern

public class CompositePattern { 
        public static void main(String[] args) { 
            Component c0 = new Composite();
            Component c1 = new Composite();
            Component leaf1 = new Leaf("1");
            Component leaf2 = new Leaf("2");
            Component leaf3 = new Leaf("3");
            c0.add(leaf1);
            c0.add(c1);
            c1.add(leaf2);
            c1.add(leaf3);
            c0.operation();
        }
    }

树叶1：被访问！
    树叶2：被访问！
    树叶3：被访问！

# 第三章 组合模式实现（安全式） #

## 3.1、安全式介绍 ##

在该方式中，将管理子构件的方法移到树枝构件中，抽象构件和树叶构件没有对子对象的管理方法，这样就避免了上一种方式的安全性问题，但由于叶子和分支有不同的接口，客户端在调用时要知道树叶对象和树枝对象的存在，所以失去了透明性。其结构如下图：

![61d24a1eb6ac16fe2ac1de1fe8626426.gif][]

## 3.2、抽象构件 ##

Component

public interface Component { 
        public void operation();
    }

## 3.3、树叶构件 ##

Leaf

public class Leaf implements Component { 
        private String name;
    
        public Leaf(String name) { 
            this.name = name;
        }
    
        public void operation() { 
            System.out.println("树叶" + name + "：被访问！");
        }
    }

## 3.4、树枝构件 ##

Composite

## 3.5、客户端测试 ##

CompositePattern

public class CompositePattern { 
        public static void main(String[] args) { 
            Composite c0 = new Composite();
            Composite c1 = new Composite();
            Component leaf1 = new Leaf("1");
            Component leaf2 = new Leaf("2");
            Component leaf3 = new Leaf("3");
            c0.add(leaf1);
            c0.add(c1);
            c1.add(leaf2);
            c1.add(leaf3);
            c0.operation();
        }
    }

# 第四章 组合模式应用 #

HashMap中有一个putAll方法，参数是一个Map，这就是一种组合模式的体现：

![01d0980f68526cae5edb0c4b1dae2410.png][]

ArrayList中有一个addAll方法，参数是一个Collection，这就是一种组合模式的体现：

![c7b474df769b48450ebafbaaa749a5f4.png][]

[dae3398febafb42f26ab7dea9c313085.png]: /images/20221022/458f1b7576b74528aa2876fa9a76b390.png
[5e4f41038dc7cd94a8dd8384653d5a77.gif]: /images/20221022/189786e408904acba1ab458b0c186bfa.png
[61d24a1eb6ac16fe2ac1de1fe8626426.gif]: /images/20221022/aa400871e0e143119a10dd2da20f1c57.png
[01d0980f68526cae5edb0c4b1dae2410.png]: /images/20221022/5658b4cf8a9c4102acf0575bdc44488f.png
[c7b474df769b48450ebafbaaa749a5f4.png]: /images/20221022/b224f9a519b04e3aa686aae47664bc22.png