目录

• 定义
• 原理类图
• 案例
• 需求
• 方案
• 分析
• 总结

定义

组合模式，又叫部分整体模式，它创建了对象组的数据结构（将对象组合成树状结构，用来表示部分整体的层级关系）组合模式使得用户对单个对象和组合对象的访问具有一致性

原理类图

Component ：这是组合模式中的抽象构件，他里面定义了所有类共有的默认行为，用来访问和管理Component的子部件，Component可以是抽象类，也可以是接口

leaf ：在组合模式中表示叶子节点，叶子节点没有子节点了，他是最末端存放数据的结构

Composite：非叶子节点，下面仍然有分支，用来存储分支，实现了Component 定义的默认行为

案例

需求

商场的服装店，专卖店，衣服，裤子的关系

方案

定义组合模式的抽象构件

public abstract class Component {
    private String name;
    private String desc;

    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;
    }

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

    public void add(Component component){
        throw new UnsupportedOperationException();
    }

    public void remove(Component component){
        throw new UnsupportedOperationException();
    }

    public abstract void show();
}

定义服装商铺类

public class Store extends Component{

    List<Component> componentList = new ArrayList<Component>();

    public Store(String name, String desc){
        super(name, desc);
    }

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

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

    @Override
    public void add(Component component) {
        System.out.println("添加：" + getName());
        componentList.add(component);
    }

    @Override
    public void remove(Component component) {
        System.out.println("移除：" + getName());
        componentList.remove(component);
    }

    @Override
    public void show() {
        for (Component component : componentList) {
            System.out.println(component.getName());
            component.show();
        }
    }
}

定义服装专卖店商铺

public class BrandStore extends Component{

    List<Component> componentList = new ArrayList<Component>();

    public BrandStore(String name, String desc) {
        super(name, desc);
    }

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

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

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

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

    @Override
    public void show() {
        for (Component component : componentList) {
            System.out.println(component.getName());
            component.show();
        }
    }
}

定义运动装

public class Sportswear extends Component{

    List<Component> componentList = new ArrayList<Component>();

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

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

    public Sportswear(String name, String desc) {
        super(name, desc);
    }

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

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

    @Override
    public void show() {
        for (Component component: componentList) {
            System.out.println(component.getName());
        }
    }
}

定义测试类

public class Test {
    public static void main(String[] args) {
        // 服装店
        Component store = new Store("服装店","服装店");

        // 专卖店
        Component brandStore1 = new BrandStore("李宁服装专卖店","李宁服装专卖店");
        Component brandStore2 = new BrandStore("361服装专卖店","361服装专卖店");

        // 运动装
        Component sportswear1 = new Sportswear("运动装","运动装");
        Component sportswear2 = new Sportswear("休闲装","休闲装");

        brandStore1.add(sportswear1);
        brandStore2.add(sportswear2);

        store.add(brandStore1);
        store.add(brandStore2);
        store.show();
    }
}

查看测试结果

分析

该案例中，服装店（Store）,专卖店（BrandStore）,运动装（Sportswear）都继承了抽象构件（Component）,通过持有一个list来管理自身持有的对象，这样客户端就可以一致处理单个对象和组合对象，屏蔽了对象层次的差异性，这样的话，一致的行为就可以控制不同的层次了。

总结

优势

组合模式可以使得客户端代码可以一致的处理单个对象和组合对象，无须关心自己处理的是单个还是组合，屏蔽了对象系统的层次差异性，这样的话一致的行为就可以控制不同层次了

扩展性非常高，可以很方便的增加叶子节点和非叶子节点，并且对于现有的类库无侵入，满足开闭原则

劣势

如果说各个节点有很大差异的话，不适合使用组合模式

使用场景

处理树形结构，具备统一行为，建议大家使用组合模式

想体现对象的部分，整体结构的时候，可以使用组合模式，典型一点例如文件和文件夹