Java设计模式之组合模式的示例详解

定义

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

原理类图

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来管理自身持有的对象，这样客户端就可以一致处理单个对象和组合对象，屏蔽了对象层次的差异性，这样的话，一致的行为就可以控制不同的层次了。

总结

优势

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

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

劣势

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

使用场景

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

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

到此这篇关于Java设计模式之组合模式的示例详解的文章就介绍到这了,更多相关Java组合模式内容请搜索猪先飞以前的文章或继续浏览下面的相关文章希望大家以后多多支持猪先飞！