设计模式之组合模式（结构型）

1、组合模式定义

组合模式（Composite），将对象组合成树形结构以表示 部分-整体的层次结构。组合模式使用户对单个对象和组合对象的使用具有一致性

2、组合模式结构

Component 为组合中的对象声明接口，在适当情况下，实现所有类共有接口的默认行为，声明一个接口用于访问和管理 Component 的子节点

import lombok.Data;

@Data
public abstract class Component {

    protected String name;

    public abstract void add(Component component);

    public abstract void remove(Component component);

    public abstract void display();

}

Leaf 表示叶子结点，叶子节点没有子节点

/**
 * 叶子节点
 */
public class Leaf extends Component {

    /**
     * 叶子节点没有下级节点，不做处理
     *
     * @param component
     */
    @Override
    public void add(Component component) {
        System.out.println("当前节点为叶子结点，无法新增节点 " + component.name);
    }

    /**
     * 叶子节点没有下级节点，不做处理
     *
     * @param component
     */
    @Override
    public void remove(Component component) {
        System.out.println("当前节点为叶子结点，无法删除节点 " + component.name);
    }

    @Override
    public void display() {
        System.out.println(name);
    }

    public Leaf(String name) {
        this.name = name;
    }

}

Composite 定义有枝节点，用来存储子节点，在 Component 中实现与子节点有关的操作

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

public class Composite extends Component {

    // 存储下级节点
    private List<Component> childList = new ArrayList<>();

    @Override
    public void add(Component component) {
        childList.add(component);
    }

    @Override
    public void remove(Component component) {
        childList.remove(component);
    }

    @Override
    public void display() {
        System.out.println(name);
        childList.forEach(Component::display);
    }

    public Composite(String name) {
        this.name = name;
    }
}

调用方代码

public class ComponentClient {

    public static void main(String[] args) {
        // 根节点，包括叶子节点 A 和叶子节点 B
        Composite root = new Composite("root");
        root.add(new Leaf("Leaf A"));
        root.add(new Leaf("Leaf B"));

        // 分支 CompositeX 包括叶子节点 A 和 B
        Composite compositeX = new Composite("Composite X");
        compositeX.add(new Leaf("Leaf XA"));
        compositeX.add(new Leaf("Leaf XB"));

        root.add(compositeX);
        root.display();

    }

}
// root
//    Leaf A
//    Leaf B
// 	  Composite X
//      Leaf XA
//      Leaf XB

3、组合模式应用场景

• 需求中是提现部分与整体的层次结构的时候，并且希望用户可以忽略组合对象与单个对象的不同，统一使用组合结构中的所有对象时，就可以考虑使用组合模式

4、组合模式实例

某公司总部新增加一个管理系统，该存在人力资源、财务、运营等部门，因公司再多个城市设有分公司，总部的人力资源部、财务部等功能在所有的分公司都要有，总部、分部、再到具体办事处是具有组织结构的，需要对不同的部分执行相应的方法

4.1 结构图

4.2 代码实现

Company：公司

import lombok.Data;

@Data
public abstract class Company {

    protected String name;

    /**
     * 增加
     */
    public abstract void add(Company company);

    /**
     * 移除
     */
    public abstract void remove(Company company);

    /**
     * 显示
     */
    public abstract void display();

    /**
     * 工作
     */
    public abstract void working();

}

ConcreteCompany：具体公司

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

/**
 * 具体公司
 */
public class ConcreteCompany extends Company {

    // 存储下级节点
    private List<Company> childList = new ArrayList<>();

    @Override
    public void add(Company company) {
        childList.add(company);
    }

    @Override
    public void remove(Company company) {
        childList.remove(company);
    }

    @Override
    public void display() {
        System.out.println(name);
        childList.forEach(Company::display);
    }

    @Override
    public void working() {
        childList.forEach(Company::working);
    }

    public ConcreteCompany(String name) {
        this.name = name;
    }
}

叶子节点，财务部门和HR部门

/**
 * 人力资源部
 */
public class HRDepartment extends Company {

    @Override
    public void add(Company company) {
    }

    @Override
    public void remove(Company company) {
    }

    @Override
    public void display() {
        System.out.println(name);
    }

    @Override
    public void working() {
        System.out.println(name + " 员工管理");
    }

    public HRDepartment(String name) {
        this.name = name;
    }

}





/**
 * 财务部
 */
public class FinanceDepartment extends Company {

    @Override
    public void add(Company company) {
    }

    @Override
    public void remove(Company company) {
    }

    @Override
    public void display() {
        System.out.println(name);
    }

    @Override
    public void working() {
        System.out.println(name + "  财务管理");
    }

    public FinanceDepartment(String name) {
        this.name = name;
    }

}

调用代码：

public class CompanyClient {

    public static void main(String[] args) {
        ConcreteCompany root = new ConcreteCompany("总公司");
        root.add(new HRDepartment("总公司人力资源部"));
        root.add(new FinanceDepartment("总公司财务部"));

        ConcreteCompany company = new ConcreteCompany("华东分公司");
        company.add(new HRDepartment("华东分公司人力资源部"));
        company.add(new FinanceDepartment("华东分公司财务部"));
        root.add(company);

        ConcreteCompany shanghai = new ConcreteCompany("上海分公司");
        shanghai.add(new HRDepartment("上海分公司人力资源部"));
        shanghai.add(new FinanceDepartment("上海分公司财务部"));
        company.add(shanghai);

        root.display();
        // 总公司
        //    总公司人力资源部
        //    总公司财务部
        //    华东分公司
        //       华东分公司人力资源部
        //       华东分公司财务部
        //       上海分公司
        //          上海分公司人力资源部
        //          上海分公司财务部
        root.working();
        // 总公司人力资源部 员工管理
        // 总公司财务部  财务管理
        // 华东分公司人力资源部 员工管理
        // 华东分公司财务部  财务管理
        // 上海分公司人力资源部 员工管理
        // 上海分公司财务部  财务管理
    }

}

组合模式这样定义了包含人力资源部和财务部这些基本对象和分公司等组合对象的层次结构，基本对象可以被组合成更复杂的对象，这个组合对象又可以被组合，组合模式可以让客户更一致的使用组合结构和单个对象