我所知道设计模式之组合模式

前言介绍

---

接下里介绍的是Java 的设计模式之一：组合模式

我们还是以一个问题进行展开，引入组合模式

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

要求：在页面中展示出学校的院系组成

一个学校有多个学院， 一个学院有多个系

一、传统方式解决问题

一般我们的思路是：先写一个学校、学校下有学院、学院下有系

但我们想一想，学校与学院是继承关系吗？学院与系又是吗？

我们准确的关系应该是组合关系：学院包含系，学校包含学院

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

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

实际上我们的要求是 ：在页面中展示出学校的院系组成

一个学校有多个学院， 一个学院有多个系

因此这种方案，不能很好实现的管理的操作，比如对学院、系的添加，删除，遍历等

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

二、什么是组合模式

组合模式（Composite Pattern），又叫部分整体模式

它创建了对象组的树形结构，将对象组合成树状结构以表示“整体-部分”的层次关系。

组合模式依据树形结构来组合对象，用来表示部分以及整体层次。

这种类型的设计模式属于结构型模式。

组合模式使得用户对单个对象和组合对象的访问具有一致性，即：组合能让客户以一致的方式处理个别对象以及组合对象

组合模式原理类图

• Component :这是组合中对象声明接口

在适当情况下，实现所有类共有的接口默认行为,用于访问和管理

• Component 子部件, Component可以是抽象类或者接口
• Leaf : 在组合中表示叶子节点，叶子节点没有子节点
• Composite :非叶子节点，用于存储子部件

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

组合模式解决的问题

当我们的要处理的对象可以生成一颗树形结构，而我们要对树上的节点和叶子进行操作时

它能够提供一致的方式，而不用考虑它是节点还是叶子，对应的示意图

三、使用组合模式解决问题

我们按照思路，县创建一个组织者类：OrganizationComponent

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();
}

接下来我们完成非叶子节点学校的Composite 实现

//University 就是 Composite ,  可以管理 College
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();
        }
    }
}

接下来我们完成非叶子节点学院的Composite 实现

//College  就是 Composite ,  可以管理 Department
class College  extends OrganizationComponent {

    List<OrganizationComponent> organizationComponents = new ArrayList<OrganizationComponent>();

    // 构造器
    public College (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();
        }
    }
}

接下来我们编写叶子节点的系left 实现

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());
    }
}

那么接下来我们使用demo 来看看组合模式下的样子

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();
}

运行结果如下：
-------清华大学----------
-------计算机学院---------
计算机科学与技术
软件工程
网络工程
-------信息工程学院-------
通信工程
信息工程

参考资料

---

尚硅谷：设计模式（韩顺平老师）：组合模式

Refactoring.Guru：《深入设计模式》