设计模式之组合模式

组合模式基本介绍

1. 组合模式(Composite Pattern)，又明部分整体模式，它创建了对象组的树形结构，将对象组合成树状结构以表示“整体部分”的层次关系；
2. 组合模式依据树形结构来组合对象，用来表示部分以及整体层次；
3. 这种类型的设计模式属于结构型模式；
4. 组合模式使得用户对单个对象和组合对象的访问具有一致性，即:组合能让客户以一致的方式处理个别对象以及组合对象

示例

package com.lesson10.composite;

/**
 * @author 朝花不迟暮
 * @version 1.0
 * @date 2020/8/31 16:36
 */
public abstract class OragizationComposite
{
    private String name;
    private String desc;

    public OragizationComposite(String name, String desc)
    {
        this.name = name;
        this.desc = desc;
    }

    protected void add(OragizationComposite o){
        throw new UnsupportedOperationException();
    }

    protected void remove(OragizationComposite o){
        throw new UnsupportedOperationException();
    }

    public String getName()
    {
        return name;
    }

    public void setName(String name)
    {
        this.name = name;
    }

    public String getDesc()
    {
        return desc;
    }

    public void setDesc(String desc)
    {
        this.desc = desc;
    }

    protected abstract void print();
}

package com.lesson10.composite;

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

/**
 * @author 朝花不迟暮
 * @version 1.0
 * @date 2020/8/31 16:39
 */
public class University extends OragizationComposite
{
    public University(String name, String desc)
    {
        super(name, desc);
    }

    List<OragizationComposite> oz =new ArrayList<>();

    @Override
    public void print()
    {
        System.out.println("============="+getName()+"==============");
        for (OragizationComposite composite : oz)
        {
            composite.print();
        }
    }

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

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

    @Override
    protected void add(OragizationComposite o)
    {
        oz.add(o);
    }

    @Override
    protected void remove(OragizationComposite o)
    {
        oz.remove(o);
    }
}

package com.lesson10.composite;

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

/**
 * @author 朝花不迟暮
 * @version 1.0
 * @date 2020/8/31 16:46
 */
public class Collect extends OragizationComposite
{
    public Collect(String name, String desc)
    {
        super(name, desc);
    }

    List<OragizationComposite> oz =new ArrayList<>();

    @Override
    public void print()
    {
        System.out.println("============="+getName()+"==============");
        for (OragizationComposite composite : oz)
        {
            composite.print();
        }
    }

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

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

    @Override
    protected void add(OragizationComposite o)
    {
        oz.add(o);
    }

    @Override
    protected void remove(OragizationComposite o)
    {
        oz.remove(o);
    }
}

package com.lesson10.composite;

/**
 * @author 朝花不迟暮
 * @version 1.0
 * @date 2020/8/31 16:48
 */
public class Department extends OragizationComposite
{
    public Department(String name, String desc)
    {
        super(name, desc);
    }

    //add，remove 就不用写了，因为他是叶子节点
    @Override
    public void print()
    {
        System.out.println(getName());
    }

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

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

package com.lesson10.composite;

/**
 * @author 朝花不迟暮
 * @version 1.0
 * @date 2020/8/31 16:50
 */
public class Client
{
    public static void main(String[] args)
    {
        OragizationComposite u = new University("清华大学", "中国最好");
        OragizationComposite c1 = new Collect("计算机学院","计算机学院");
        OragizationComposite c2 = new Collect("计算机学院","工程学院");

        c1.add(new Department("软件工程","软件工程"));
        c1.add(new Department("网络工程","网络工程"));

        c2.add(new Department("软件工程","软件工程c2"));
        c2.add(new Department("网络工程","网络工程c2"));

        u.add(c1);
        u.add(c2);

        u.print();
    }
}

=============清华大学==============
=============计算机学院==============
软件工程
网络工程
=============计算机学院==============
软件工程
网络工程

小结

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