1. 简介

组合模式跟面向对象设计中的“组合关系（通过组合来组装两个类）”，完全是两码事。这里讲的“组合模式”，主要是用来处理树形结构数据。这里的“数据”，你可以简单理解为一组对象集合。

正因为其应用场景的特殊性，数据必须能表示成树形结构，这也导致了这种模式在实际的项目开发中并不那么常用。但是，一旦数据满足树形结构，应用这种模式就能发挥很大的作用，能让代码变得非常简洁。

组合模式的原理与实现

在 GoF 的《设计模式》一书中，组合模式是这样定义的：

Compose objects into tree structure to represent part-whole hierarchies.Composite lets client treat individual objects and compositions of objects uniformly.

翻译成中文就是：将一组对象组织（Compose）成树形结构，以表示一种“部分-整体”的层次结构。组合让客户端（在很多设计模式书籍中，“客户端”代指代码的使用者。）可以统一单个对象和组合对象的处理逻辑。

2 一个Demo

2.1 需求

编写程序展示一个学校院系结构:需要是这样，要在一个页面中展示出学校的院系组成如图

清华大学
- 计算机学院
  - 计算机科学与技术
  - 软件工程
  - 网络工程
- 信息工程学院
  - 通信工程
  - 信息工程

概述

组合模式（Composite Pattern）又叫部分整体模式，他创建了对象组的树形结构，将对象组合树状结构以表示“整体-部分”的层次关系
组合模式依据树形结构来组合对象，用来表示部分以及整体层次
这种类型的设计模式属于结构型模式
组合模式使地用户对单个对象和组合对象的访问具有一致性，即：组合能让客户以一致的方式处理个别对象以及组合对象

组合模式原理类图

component:这是组合中对象声明的接口，再适合情况下，实现所有类共有的接口默认行为，用于访问和管理Component子部件，Component可以是抽象类也可以是接口
Leaf:在组合中表示叶子节点，叶子节点没有子节点
Composite:非叶子节点，用于存储子部件，在Component接口中实现子部件的相关操作，比如增删。

组合模式代码

package com.evan.composite;

/**
 * @Description
 * @ClassName OrganizationComponent
 * @Author Evan
 * @date 2019.12.04 22:33
 */
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.evan.composite;

import java.util.ArrayList;
import java.util.List;

/**
 * @Description 大学 包含很多院校
 * @ClassName Unvisity
 * @Author Evan
 * @date 2019.12.05 20:26
 */
public class University extends OrganizationComponent {

    List<OrganizationComponent> organizationComponents = new ArrayList<OrganizationComponent>();
    public University(String name, String des) {
        super(name, des);
    }

    @Override
    protected void add(OrganizationComponent organizationComponent) {
        organizationComponents.add(organizationComponent);
    }


    @Override
    protected void remove(OrganizationComponent organizationComponent) {
        organizationComponents.remove(organizationComponent);
    }


    // 输出应该输出University包含的学院
    @Override
    protected void print() {
        System.out.println("=============="+getName()+"====================");
        for (OrganizationComponent organizationComponent:organizationComponents)
        {
            organizationComponent.print();
        }
    }
}

package com.evan.composite;

import java.util.ArrayList;
import java.util.List;

/**
 * @Description 院校里面有很多专业
 * @ClassName College
 * @Author Evan
 * @date 2019.12.04 22:38
 */
public class College extends OrganizationComponent {

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


    // 构造器
    public College(String name, String desc) {
        super(name, desc);
    }

    @Override
    protected void add(OrganizationComponent organizationComponent) {
        // 将来实际业务中，College的add和University add不一定完全一样
        organizationComponents.add(organizationComponent);
    }

    @Override
    protected void remove(OrganizationComponent organizationComponent) {
        organizationComponents.remove(organizationComponent);
    }

    @Override
    public String getName() {
        return super.getName();
    }

    @Override
    public String getDes() {
        return super.getDes();
    }


    // 就是输出University包含的学院
    @Override
    protected void print() {
        System.out.println("---------" + getName() + "-----------------");
        for (OrganizationComponent organizationComponent : organizationComponents) {
            organizationComponent.print();
        }
    }
}

package com.evan.composite;

/**
 * @Description
 * @ClassName Department
 * @Author Evan
 * @date 2019.12.05 20:37
 */
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.evan.composite;

/**
 * @Description
 * @ClassName Client
 * @Author Evan
 * @date 2019.12.05 20:42
 */
public class Client {

    public static void main(String[] args) {
        // TODO Auto-generated method stub

        //从大到小创建对象 学校
        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();
    }

}

实际上，刚才讲的这种组合模式的设计思路，与其说是一种设计模式，倒不如说是对业务场景的一种数据结构和算法的抽象。其中，数据可以表示成树这种数据结构，业务需求可以通过在树上的递归遍历算法来实现。

3 总结

组合模式的优缺点

优点：

高层模块调用简单。
节点自由增加。

缺点：在使用组合模式时，其叶子和树枝的声明都是实现类，而不是接口，违反了依赖倒置原则。

使用场景：部分、整体场景，如树形菜单，文件、文件夹的管理。

组合模式的细节

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

组合模式，将一组对象组织成树形结构，将单个对象和组合对象都看做树中的节点，以统一处理逻辑，并且它利用树形结构的特点，递归地处理每个子树，依次简化代码实现。使用组合模式的前提在于，你的业务场景必须能够表示成树形结构。所以，组合模式的应用场景也比较局限，它并不是一种很常用的设计模式。