设计模式学习笔记之组合模式

  |   0 评论   |   0 浏览

什么是组合模式?

组合模式的定义

Compose objects into tree structures to represent part-whole hierarchies.Composite lets clients treat individual objects and compositions of objects uniformly.
将对象组合成树形结构以表示 “部分-整体” 的层次结构,使得用户对单个对象和组合对象的使用具有一致性。

主要优缺点

优点:
当需要在组合内添加新对象的时候,不需要修改源码,复合开闭原则。
对外提供的是同一个对象,使用起来不必关心使用的是单个对象还是组合对象。
缺点:
设计起来比较复杂,需要理清类之间的层次关系。

使用场景

系统对象之间存在整体--部分的关系,并有一定的相同行为。(JAVA中的swing,公司组织架构等等)

组合模式的结构和实现

组合模式结构

抽象根角色(Component):定义系统层级之间的相同行为,是树枝和叶子构建角色的公共抽象接口。
树枝角色(Composite):定义树枝角色的行为,可以存储子节点,子节点可以是树枝角色也可以是叶子角色,通过组合树枝角色和叶子角色形成一个树形结构。
叶子角色(Leaf):定义叶子角色的行为,其下再无分支。

主要有两种实现方式:透明性组合模式和安全性组合模式

透明性组合模式实现

在透明性组合模式当中,抽象根角色(Component)包含了树枝角色和叶子角色的所有行为。所以在叶子角色当中会存在树枝角色的行为,但是这些行为叶子角色是不支持的。就违背了接口隔离原则。

public class ComponentTest {
    public static void main(String[] args) {
        // 创建一个根节点
        Component root = new Composite("根节点");
        // 创建树枝节点
        Component branchA = new Composite("---树枝A");
        Component branchB = new Composite("------树枝B");
        // 来一个叶子节点
        Component leafA = new Leaf("------叶子A");
        Component leafB = new Leaf("------叶子B");
        Component leafC = new Leaf("---叶子C");

        root.addChild(branchA);
        root.addChild(leafC);
        branchA.addChild(leafA);
        branchA.addChild(branchB);
        branchB.addChild(leafB);

        String result = root.operation();
        System.out.println(result);
    }

    // 抽象构建角色
    static abstract class Component {
        String name;

        Component(String name) {
            this.name = name;
        }

        public abstract String operation();

        public boolean addChild(Component component) {
            throw new UnsupportedOperationException("addChild not supported!");
        }
        public Component getChild(int index) {
            throw new UnsupportedOperationException("getChild not supported!");
        }
    }

    //树枝构建角色
    static class Composite extends Component {
        private List<Component> childComponent;

        public Composite(String name) {
            super(name);
            this.childComponent = new ArrayList<>();
        }

        @Override
        public String operation() {
            StringBuilder builder = new StringBuilder(this.name);
            if(this.childComponent.size()>0){
                for (Component component : this.childComponent) {
                    builder.append("\n");
                    builder.append(component.operation());

                }
            }
            return builder.toString();
        }

        @Override
        public boolean addChild(Component component) {
            return this.childComponent.add(component);
        }

        @Override
        public Component getChild(int index) {
            return this.childComponent.get(index);
        }
    }

    //叶子构建角色
    static class Leaf extends Component {

        public Leaf(String name) {
            super(name);
        }

        @Override
        public String operation() {
            return this.name;
        }
    }

}

安全性组合模式实现

在安全性组合模式当中,抽象根角色(Component)包含了树枝角色和叶子角色的公共行为。在叶子角色当中就不再存在树枝角色的行为。

public class ComponentTest2 {
    public static void main(String[] args) {
        // 创建一个根节点
        Composite root = new Composite("根节点");
        // 创建树枝节点
        Composite branchA = new Composite("---树枝A");
        Composite branchB = new Composite("------树枝B");
        // 来一个叶子节点
        Component leafA = new Leaf("------叶子A");
        Component leafB = new Leaf("------叶子B");
        Component leafC = new Leaf("---叶子C");

        root.addChild(branchA);
        root.addChild(leafC);
        branchA.addChild(leafA);
        branchA.addChild(branchB);
        branchB.addChild(leafB);

        String result = root.operation();
        System.out.println(result);
    }

    // 抽象构建角色
    static abstract class Component {
        String name;

        Component(String name) {
            this.name = name;
        }

        public abstract String operation();

    }

    //树枝构建角色
    static class Composite extends Component {
        private List<Component> childComponent;

        public Composite(String name) {
            super(name);
            this.childComponent = new ArrayList<>();
        }

        @Override
        public String operation() {
            StringBuilder builder = new StringBuilder(this.name);
            if(this.childComponent.size()>0){
                for (Component component : this.childComponent) {
                    builder.append("\n");
                    builder.append(component.operation());

                }
            }
            return builder.toString();
        }


        public boolean addChild(Component component) {
            return this.childComponent.add(component);
        }


        public Component getChild(int index) {
            return this.childComponent.get(index);
        }
    }

    //叶子构建角色
    static class Leaf extends Component {

        public Leaf(String name) {
            super(name);
        }

        @Override
        public String operation() {
            return this.name;
        }
    }

}


标题:设计模式学习笔记之组合模式
作者:hjljy
地址:https://www.hjljy.cn/articles/2019/12/24/1577116855811.html