【设计模式】组合模式

组合模式

看一个学校院系展示需求　

　　编写程序展示一个学校院系结构：

　　需求是这样，要在一个页面中展示出学校的院系组成，一个学校有多个学院，一个学院有多个系。如图：

　　

　　传统方案解决学校院系展示，如图：

　　

　　传统方案解决学校院系展示存在的问题分析：

1. 将学院看做是学校的子类，系是学院的子类，这样实际上是站在组织大小来进行分层次的

2. 实际上我们的要求是：在一个页面中展示出学校的院系组成，一个学校有多个学院，一个学院有多个系，因此这种方案，不能很好实现的管理的操作，比如对学院、系的添加，删除，遍历等

3. 解决方案：把学校、院、系都看做是组织结构，他们之间没有继承的关系，而是一个树形结构，可以更好的实现管理操作。 => 组合模式

组合模式基本介绍

模式的结构

组合模式包含以下主要角色：

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

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

3. 树枝构件（Composite）角色：是组合中的分支节点对象，它有子节点。它实现了抽象构件角色中声明的接口，它的主要作用是存储和管理子部件，通常包含 Add()、Remove()、GetChild() 等方法

组合模式分为透明式的组合模式和安全式的组合模式：

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

　　

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

　　

下面给出透明式的组合模式的实现代码，与安全式的组合模式的实现代码类似，只要对其做简单修改就可以了。

package composite;
import java.util.ArrayList;
 
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(); 
    }
}
 
 
// 抽象构件
interface Component {
    public void add(Component c);
    public void remove(Component c);
    public Component getChild(int i);
    public void operation();
}
 
 
// 树叶构件
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 + "：被访问！"); 
    }
}
 
 
// 树枝构件
class Composite implements Component {
 
    private ArrayList<Component> children = new ArrayList<Component>();
   
    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();
        }
    }    
} 

程序运行结果如下：

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

组合模式解决学校院系展示的应用实例

应用实例要求：

　　接口中实现子部件的相关操作，比如增加(add)，

　　1）编写程序展示一个学校院系结构：需求是这样，要在一个页面中展示出学校的院系组成，一个学校有多个学院，一个学院有多个系。

　　2）思路分析和图解（类图）

　　

　　3）代码实现

package com.atguigu.composite;
 
public class Client {
 
    public static void main(String[] args) {
 
        // 从大到小创建对象学校
        OrganizationComponent university = new University("清华大学", " 中国顶级大学 ");
        // 创建学院
        OrganizationComponent computerCollege = new College("计算机学院", " 计算机学院 "); 
        OrganizationComponent infoEngineercollege = new College("信息工程学院", " 信息工程学院 ");
        // 创建各个学院下面的系（专业）
        computerCollege.add(new Department("软件工程", " 软件工程不错 "));
        computerCollege.add(new Department("网络工程", " 网络工程不错 "));
        computerCollege.add(new Department("计算机科学与技术", " 计算机科学与技术是老牌的专业 "));
 
        infoEngineercollege.add(new Department("通信工程", " 通信工程不好学 "));           
        infoEngineercollege.add(new Department("信息工程", " 信息工程好学 "));
        // 将学院加入到学校 
        university.add(computerCollege);         
        university.add(infoEngineercollege);
        // university.print();
        infoEngineercollege.print(); 
    }
}

 

package com.atguigu.composite;
import java.util.ArrayList; 
import java.util.List;
 
public class College extends OrganizationComponent {
 
    // List 中 存放的 Department
    List<OrganizationComponent> organizationComponents = new ArrayList<OrganizationComponent>();
 
    // 构造器
    public College(String name, String des) {
        super(name, des);
    }
 
    // 重写 add
    @Override
    protected void add(OrganizationComponent organizationComponent) {
        // 将来实际业务中，Colleage 的 add 和 University add 不一定完全一样
        organizationComponents.add(organizationComponent); 
    }
 
    // 重写 remove
    @Override
    protected void remove(OrganizationComponent organizationComponent) {
        organizationComponents.remove(organizationComponent); 
    }
 
    @Override
    public String getName() {
        return super.getName(); 
    }
 
    @Override
    public String getDes() {
        return super.getDes(); 
    }
 
    // print 方法，就是输出 University 包含的学院 
    @Override
    protected void print() {
        System.out.println("--------------" + getName() + "--------------");
        // 遍历 organizationComponents
        for (OrganizationComponent organizationComponent : organizationComponents) {
            organizationComponent.print(); 
        }
    }
}

package com.atguigu.composite;
 
public class Department extends OrganizationComponent {
 
    // 没有集合
    public Department(String name, String des) { 
        super(name, des);
    }
 
    // add , remove 就不用写了，因为他是叶子节点 
    @Override
    public String getName() {
        return super.getName();
    }
 
    @Override
    public String getDes() {
        return super.getDes(); 
    }
 
    @Override
    protected void print() {
        System.out.println(getName()); 
    }
}

 

package com.atguigu.composite;
 
public abstract class OrganizationComponent {
 
    // 名字 
    private String name; 
    // 说明
    private String des;
 
    protected void add(OrganizationComponent organizationComponent) { 
        // 默认实现
        throw new UnsupportedOperationException(); 
    }
 
    protected void remove(OrganizationComponent organizationComponent) { 
        // 默认实现
        throw new UnsupportedOperationException(); 
    }
 
    // 构造器
    public OrganizationComponent(String name, String des) {
        super();
        this.name = name; 
        this.des = des;
    }
 
    public String getName() { 
        return name;
    }
 
    public void setName(String name) { 
        this.name = name;
    }
 
    public String getDes() {
        return des; 
    }
 
    public void setDes(String des) { 
        this.des = des;
    }
 
    // 方法 print, 做成抽象的, 子类都需要实现 
    protected abstract void print();
}

package com.atguigu.composite;
import java.util.ArrayList; 
import java.util.List;
 
// University 就是 Composite , 可以管理 College
public class University extends OrganizationComponent {
 
    List<OrganizationComponent> organizationComponents = new ArrayList<OrganizationComponent>();
 
    // 构造器
    public University(String name, String des) {
        super(name, des);
    }
 
    // 重写 add
    @Override
    protected void add(OrganizationComponent organizationComponent) {
        organizationComponents.add(organizationComponent); 
    }
 
    // 重写 remove
    @Override
    protected void remove(OrganizationComponent organizationComponent) {
        organizationComponents.remove(organizationComponent); 
    }
 
    @Override
    public String getName() {
        return super.getName(); 
    }
 
    @Override
    public String getDes() {
        return super.getDes(); 
    }
 
    // print 方法，就是输出 University 包含的学院 @Override
    protected void print() {
        System.out.println("--------------" + getName() + "--------------");
        // 遍历 organizationComponents
        for (OrganizationComponent organizationComponent : organizationComponents) {
            organizationComponent.print(); 
        }
    } 
}

组合模式的应用场景

　　前面分析了组合模式的结构与特点，下面分析它适用的以下应用场景：

1. 在需要表示一个对象整体与部分的层次结构的场合

2. 要求对用户隐藏组合对象与单个对象的不同，用户可以用统一的接口使用组合结构中的所有对象的场合

组合模式在 JDK 集合的源码分析

　　1）Java 的集合类-HashMap 就使用了组合模式

　　2）代码分析+Debug 源码

　　

　　3）类图

　　

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

1. 简化客户端操作。客户端只需要面对一致的对象而不用考虑整体部分或者节点叶子的问题

2. 具有较强的扩展性。当我们要更改组合对象时，我们只需要调整内部的层次关系，客户端不用做出任何改动

3. 方便创建出复杂的层次结构。客户端不用理会组合里面的组成细节，容易添加节点或者叶子从而创建出复杂的树形结构

4. 需要遍历组织机构，或者处理的对象具有树形结构时，非常适合使用组合模式

5. 要求较高的抽象性，如果节点和叶子有很多差异性的话，比如很多方法和属性都不一样，不适合使用组合模式

组合模式的扩展

　　如果对前面介绍的组合模式中的树叶节点和树枝节点进行抽象，也就是说树叶节点和树枝节点还有子节点，这时组合模式就扩展成复杂的组合模式了，如 Java AWT/Swing 中的简单组件 JTextComponent 有子类 JTextField、JTextArea，容器组件 Container 也有子类 Window、Panel。复杂的组合模式的结构图如图 5 所示。

　　

 

原文链接：https://blog.csdn.net/qq784515681/article/details/106347131