java设计模式-组合模式

java设计模式-组合模式

传统方案解决院系展示（类图）

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

1. 将学院看做是学校的子类，系是学院的子类，这样实际上是站在组织大小来进行分层次的
2. 实际上我们的要求是:在一个页面中展示出学校的院系组成，一个学校有多个
   学院，一个学院有多个系，因此这种方案，不能很好实现的管理的操作，比如对学院、系的添加，删除，遍历等
3. 解决方案:把学校、院、系都看做是组织结构，他们之间没有继承的关系，而是 一个树形结构，可以更好的实现管理操作。=>组合模式

---

组合模式

基本介绍
1)组合模式(Composite Pattern)，又叫部分整体模式，它创建了对象组的树形结构，将对象组合成树状结构以表示“整体-部分”的层次关系。

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

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

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

---

1）组合模式解决这样的问题，当我们的要处理的对象可以生成一颗树形结构，而我们要对树上的节点和叶子进行操作时，它能够提供一致的方式，而不用考虑它是节点还是叶子 2)对应的示意图

将上面的问题 的类图

例子

//总节点接口
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();
}

具体的大学

//University 就是Composite  ,可以管理college
public class University extends OrganizationComponent{

    List<OrganizationComponent> organizationComponents=new ArrayList<OrganizationComponent>();
    
    public University(String name, String des) {
        super(name, des);
    }
    @Override
    public String getName() {
        return super.getName();
    }
    @Override
    public String getDes() {
        return super.getDes();
    }
    @Override
    protected void add(OrganizationComponent organizationComponent) {
        this.organizationComponents.add(organizationComponent);
    }
    @Override
    protected void remove(OrganizationComponent organizationComponent) {
        this.organizationComponents.remove(organizationComponent);
    }
    @Override
    protected void print() {
        System.out.println(getName());
        System.out.println("-------------------");
        for (OrganizationComponent i:organizationComponents){
            i.print();
        }

    }
}

学院

//学院
public class College extends OrganizationComponent {
    
    //这个list中存放的是Depart
    List<OrganizationComponent> organizationComponents=new ArrayList<OrganizationComponent>();
    
    public College(String name, String des) {
        super(name, des);
    }

    @Override
    public String getName() {
        return super.getName();
    }
    @Override
    public String getDes() {
        return super.getDes();
    }
    @Override
    protected void add(OrganizationComponent organizationComponent) {
        this.organizationComponents.add(organizationComponent);
    }
    @Override
    protected void remove(OrganizationComponent organizationComponent) {
        this.organizationComponents.remove(organizationComponent);
    }
    @Override
    protected void print() {
        System.out.println(super.getName());
        System.out.println("-------------------");
        for (OrganizationComponent i:organizationComponents){
            i.print();
        }

    }
}

系 叶子节点没有增删方法 没有子节点

public class Department extends OrganizationComponent{
    
    public Department(String name, String des) {
        super(name, des);
    }

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

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

    @Override
    protected void print() {
        System.out.println(getName());
    }
}

测试

public static void main(String[] args) {
        //从大到小创建对象
        OrganizationComponent university=new University("清华大学","清华大学1");

        //创建学院
        OrganizationComponent tumu=new College("土木学院","土木学院");
        OrganizationComponent dianxin=new College("电信学院","电信学院");
        
        //创建学院下面各个系
        dianxin.add(new Department("软件工程","软工不好学"));
        dianxin.add(new Department("网络工程","网络工程好学"));

		//添加系到学院
        tumu.add(new Department("土木工程","土木"));
		//添加学院 到学校中
        university.add(tumu);
        university.add(dianxin);
        university.print();

这样就像树一样一层一层的 可以添加和删除

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

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

源码中 HashMap使用了组合模式