设计模式 —— Composite 模式

最新推荐文章于 2023-11-07 10:38:22 发布

开心小蜗牛

最新推荐文章于 2023-11-07 10:38:22 发布

阅读量1.9k

点赞数 1

分类专栏：设计模式文章标签：设计模式组合模式

本文链接：https://blog.csdn.net/kangsa998/article/details/91492737

版权

设计模式专栏收录该内容

10 篇文章 0 订阅

订阅专栏

文章目录

1 组合模式核心

组合模式将对象组合成 树形结构，以表示 “整体与部分” 的层次结构
组合模式包含3个成员：
- Leaf： 叶节点，叶节点没有子节点，是整体与部分中的部分
- Composite： 非叶节点(树枝节点或根节点)，存储子节点，是整体与部分的整体
- Component： 抽象组件，Leaf 和 Composite 都继承于它，这样才使得用户对整体和部分的使用是一致的（用户并不知道哪个是整体，哪个是部分！）。它定义了所有子类公共的缺省行为

2 公司管理系统示例

2.1 Component(抽象公司)

抽象组件，定义所有行为，使得整体与部分对用户具有透明性

public abstract class AbstractCompany {
    protected String name;
    public AbstractCompany(String name) {
        this.name = name;
    }
    //定义默认方法，抛出异常
    public boolean add(AbstractCompany company) {
        throw new UnsupportedOperationException("不支持的操作");
    }
    public boolean remove(AbstractCompany company) {
        throw new UnsupportedOperationException("不支持的操作");
    }
    public void display(int depth) {
        throw new UnsupportedOperationException("不支持的操作");
    }
    public void LineOfDuty() {
        throw new UnsupportedOperationException("不支持的操作");
    }
}

2.2 Composite(整体)

整体继承于抽象公司，并实现了所有方法
在display、LineOfDuty方法中递归调用了子节点方法，使得用户对整体的操作就像是对部分的操作一样，具有透明性

public class CompositeCompany extends AbstractCompany {
    public CompositeCompany(String name) {
        super(name);
    }
    private List<AbstractCompany> children = new ArrayList<>();
    public  boolean add(AbstractCompany company) {
        return children.add(company);
    }
    public boolean remove(AbstractCompany company) {
        return children.remove(company);
    }
    public void display(int depth) {
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < depth; i++) {
            sb.append("-");
        }
        System.out.println(sb.toString() + name);
        //递归调用子节点
        for (AbstractCompany child : children) {
            child.display(depth + 2);
        }
    }
    public void LineOfDuty() {
        for (AbstractCompany child : children) {
            child.LineOfDuty();
        }
    }
}

2.3 Leaf(部分：具体公司)

Leaf 也继承了抽象公司，且没有实现增加删除操作
使得用户调用 Leaf 的增加删除操作时返回异常

public class HRDepartment extends AbstractCompany {
    public HRDepartment(String name) {
        super(name);
    }
    public void display(int depth) {
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < depth; i++) {
            sb.append("-");
        }
        System.out.println(sb.toString() + name);
    }
    public void LineOfDuty() {
        System.out.println(name + "：员工招聘培训管理");
    }
}

3 适用场景

想表示对象的整体与部分的层次结构时
当用户不关心使用的是组合对象还是单个对象时（这时用户的意图应该是使用他直接或间接手下的所有单个对象的相关行为，但他只会对他直接手下下命令）

4 安全性与透明性的选择

透明性： 在类层次的根部定义所有子类的接口方法具有良好的透明性（这样就可以一致性的使用所有的子类节点），但是用户可能会做出一些无意义的事情，如在 Leaf 中增加和删除对象，这样就没有安全性
安全性： 在 Composite 类中定义单独的增删改操作具有安全性，这样用户就不可能调用到 Leaf 的增删改行为。但这样就失去了透明性，因为 Leaf 和 Composite 具有不同的接口了
一般情况下，都会选择透明性，在基类接口声明的行为中默认抛出异常，这样如果子类不重写它，在用户使用它时就会直接抛出异常