设计模式——组合模式

一、基本介绍

1）、组合模式（Composite Pattern）：又叫部分整体模式，它创建了对象组的树形结构，将对象组合成树状结构以表示“整体-部分”的层次关系。
2）、组合模式依据树形结构来组合对象，用来表示部分以及整体层次。
3）、这种设计模式属于结构型模式。
4）、组合模式使得用户对单个对象和组合对象的访问具有一致性，即：组合能让客户以一致的方式处理个别对象以及组合对象。
5）、优点：组合模式使得客户端代码可以一致地处理单个对象和组合对象，无需关系自己处理的是单个对象，还是组合对象，这简化了客户端代码；更容易在组合体内加入新的对象，客户端不会因为加入了新的对象而更改源代码，满足 "开闭原则 OCP"。
6）、缺点：设计复杂，客户端需要花更多时间理清类之间的层次关系。不容易限制容器中构建，不容易用继承的方式增加构建的新功能。

二、组合模式——结构类图

组合模式分为透明式的组合模式和安全式组合模式：
1）、透明方式：在该方法中，由于抽象构建声明了所有子类中的全部方法，所以客户端无需区别树叶对象和树枝对象。对客户端来说是透明的。其缺点是：树叶构件本来没有 Add()、Remove() 及 GetChild() 方法，却要实现它们（空实现或抛异常），这样会带来一些安全性问题。
2）、安全方式：在该方式中，将管理子构件的方法移到树枝构件中，抽象构件和树叶构件没有对子对象的管理方法，这样就避免了上一种方式的安全性问题，但由于叶子和分支有不同的接口，客户端在调用时要知道树叶对象和树枝对象的存在，所以失去了透明性。

三、组合模式代码案例分析

【1】抽象构件（Component）角色：主要作用是为树叶和树枝构件生命公共接口，并实现他们的默认行为。在透明式的组合模式中，抽象构件还声明访问和管理子类的接口（add/remove)。在安全式的组合模式中不声明访问和管理子类的接口，管理工作由树枝构建完成。

 1 public abstract class AbstractComponent {
 2     //学校的名称
 3     private String name;
 4     //备注
 5     private String remark;
 6     //定义一个输入的抽象方法
 7     public abstract void output();
 8     
 9     //非叶子节点都具有的增加和删除方法
10     public void add(AbstractComponent abstractComponent) {
11         //当重写此方法直接调用时，就会抛出此异常。与Arrays.asList()内部类中的add与remove写法一致
12         throw new UnsupportedOperationException();
13     }
14     public void remove(AbstractComponent abstractComponent) {
15         throw new UnsupportedOperationException();
16     }
17 
18     //构造器
19     public AbstractComponent(String name, String remark) {
20         super();
21         this.name = name;
22         this.remark = remark;
23     }
24         //get/set方法 tostring方法 略
25     }
26 }

【2】树枝构件（Composite）角色：是组合中的分支节点对象，它有子节点。它实现了抽象构件角色中声明的接口，它的主要作用是

 1 public class University extends AbstractComponent{
 2     //构造器
 3     public University(String name, String remark) {
 4         super(name, remark);
 5     }
 6     //大学中包含多个学院
 7     List<AbstractComponent> college = new ArrayList<AbstractComponent>();
 8     //重写输出方法:输出叶子节点
 9     @Override
10     public void output() {
11         System.out.println("===="+super.getName()+"====");
12         for (AbstractComponent abstractComponent : college) {
13             abstractComponent.output();
14         }
15     }
16     //组合类也就是树枝节点，需要重写add与remove方法
17     @Override
18     public void add(AbstractComponent abstractComponent) {
19         college.add(abstractComponent);
20     }
21     @Override
22     public void remove(AbstractComponent abstractComponent) {
23         college.remove(abstractComponent);
24     }
25 }

【3】学院类也是树枝构件（Composite）角色，与上述基本一致。

 1 public class College extends AbstractComponent{
 2     //构造器
 3     public College(String name, String remark) {
 4         super(name, remark);
 5     }
 6     
 7     List<AbstractComponent> list = new ArrayList<>();
 8     //输入
 9     @Override
10     public void output() {
11         for (AbstractComponent abstractComponent : list) {
12             abstractComponent.output();
13         }
14         
15     }
16     //重写添加和删除方法
17     @Override
18     public void add(AbstractComponent abstractComponent) {
19         list.add(abstractComponent);
20     }
21     @Override
22     public void remove(AbstractComponent abstractComponent) {
23         list.remove(abstractComponent);
24     }
25 }

【4】树叶构件（Leaf）角色：是组合中的叶节点对象，它没有子节点，用于实现抽象构件角色中声明的公共接口。

 1 public class Major extends AbstractComponent{
 2     //构造器
 3     public Major(String name, String remark) {
 4         super(name, remark);
 5     }
 6     //add , remove 就不用写了，因为他是叶子节点
 7     //输入
 8     @Override
 9     public void output() {
10         System.out.println(getName());
11     }
12 
13 }

【5】测试类

 1 public class Client {
 2     public static void main(String[] args) {
 3         //定义一个大学
 4         AbstractComponent university = new University("浙江大学", "浙江人的骄傲");
 5         //定义一个学院
 6         AbstractComponent college = new College("计算机学院", "简称妓院");
 7         //将妓院添加至学校
 8         university.add(college);
 9         //定义一个专业
10         AbstractComponent major = new Major("计算机科学与技术", "考研大专业");
11         //添加至学院
12         college.add(major);
13         //输出：计算机科学与技术 输入的都是叶子节点的output方法
14         major.output();
15         college.output();
16         university.output();
17     }
18 }

四、组合模式源码分析

【1】HashMap 组合模式：首先定义了抽象构建角色 Map<K,V>

public interface Map<K,V> {....}

【2】使用接口适配器模式，定义了抽象实现：AbstractMap

1 public abstract class AbstractMap<K,V> implements Map<K,V> {
2         public V put(K key, V value) {
3         //由子类实现
4         throw new UnsupportedOperationException();
5     }
6     ......
7 }

【3】HashMap 等实现类属于树枝构建角色：组合了 Node 叶子节点类

 1 public class HashMap<K,V> extends AbstractMap<K,V>
 2     implements Map<K,V>, Cloneable, Serializable {
 3     public V put(K key, V value) {
 4         return putVal(hash(key), key, value, false, true);
 5     }
 6     public void putAll(Map<? extends K, ? extends V> m) {
 7         putMapEntries(m, true);
 8     }
 9     ......
10     final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
11                    boolean evict) {
12         Node<K,V>[] tab; Node<K,V> p; int n, i;
13         ......
14     }
15 }

【4】Node 类是上述类的内部类，也就是组合模式中的树叶构建：数组存储时，通过 put 方法存入 Node 对象中，叶子节点 Node 中不包含添加方法等，只包含一些属性和其 get/set 方法

 1  public class HashMap<K,V> extends AbstractMap<K,V>
 2     implements Map<K,V>, Cloneable, Serializable {
 3     ......
 4     static class Node<K,V> implements Map.Entry<K,V> {
 5         final int hash;
 6         final K key;
 7         V value;
 8         Node<K,V> next;
 9 
10         Node(int hash, K key, V value, Node<K,V> next) {
11             this.hash = hash;
12             this.key = key;
13             this.value = value;
14             this.next = next;
15         }
16 
17         public final K getKey()        { return key; }
18         public final V getValue()      { return value; }
19         public final String toString() { return key + "=" + value; }
20 
21      public final int hashCode() {
22             return Objects.hashCode(key) ^ Objects.hashCode(value);
23         }
24 
25         public final V setValue(V newValue) {
26             V oldValue = value;
27             value = newValue;
28             return oldValue;
29         }
30 
31         public final boolean equals(Object o) {
32             if (o == this)
33                 return true;
34             if (o instanceof Map.Entry) {
35                 Map.Entry<?,?> e = (Map.Entry<?,?>)o;
36                 if (Objects.equals(key, e.getKey()) &&
37                     Objects.equals(value, e.getValue()))
38                     return true;
39             }
40             return false;
41         }
42     }
43     ......
44 }

五、组合模式的注意事项和细节

☛ 简化客户端操作。客户端只需要面对一致的对象而不用考虑整体部分或者节点叶子的问题。
☛ 具有较强的扩展性。当我们要更改组合对象时，我们只需要调整内部的层次关系，客户端不用做任何改动。
☛ 方便创建出复杂的层次结构。客户端不用理会组合里面的组成细节,容器添加节点或者叶子。从而创建出复杂的树形结构。
☛ 需要遍历组织机构，或者处理的对象具有树形结构时，非常适合使用组合模式。
☛ 当要求较高的抽象性时，如果节点和叶子有很多差异的话，例如很多方法和属性都不一样，不适合使用组合模式。

posted @ 2020-11-19 14:32 Java程序员进阶阅读(128) 评论(0) 编辑收藏举报

刷新页面返回顶部

Java程序员进阶