java设计模式－组合模式(合成模式 Composite)-3

look_w

透明式组合模式的结构

与安全式的组合模式不同的是，透明式的组合模式要求所有的具体构建类，不论树枝构件还是树叶构件，均符合一个固定接口。

透明式的组合模式
示例代码

抽象构件角色类

    public abstract class Component {
        /**
         * 打印组件自身的名称
         * @param preStr 前缀，用于实现缩进
         */
        public abstract void printStruct(String preStr);
        
        /**
         * 聚集管理方法，增加一个子构件对象
         * @param child 子构件对象
         */
        public void addChild(Component child) {
            /**
             * 缺省实现，抛出异常，因为树叶对象没有此功能
             * 或者子组件没有实现这个功能
             */
            throw new UnsupportedOperationException("对象不支持此功能");
        }
        
        /**
         * 聚集管理方法，删除一个子构件对象
         * @param index 子构件对象的下标
         */
        public void removeChild(int index) {
            /**
             * 缺省实现，抛出异常，因为树叶对象没有此功能
             * 或者子组件没有实现这个功能
             */
            throw new UnsupportedOperationException("对象不支持此功能");
        }
        
        /**
         * 聚集管理方法，返回所有子构件对象
         * @return 返回所有子构件对象
         */
        public List<Component> getChild() {
            /**
             * 缺省实现，抛出异常，因为树叶对象没有此功能
             * 或者子组件没有实现这个功能
             */
            throw new UnsupportedOperationException("对象不支持此功能");
        }
    }

树枝构件角色类，此类将implements Component改为extends Component，其他地方无变化。

    public class Composite extends Component {
        /**
         * 用来存储对象中包含的子构件对象
         */
        private List<Component> childComponents = new ArrayList<Component>();
        
        /**
         * 组合对象的名称
         */
        private String name;
        
        /**
         * 构造方法，传入组合对象的名称
         * @param name 组合对象的名称
         */
        public Composite(String name) {
            this.name = name;
        }
     
        /**
         * 聚集管理方法，增加一个子构件对象
         * @param child 子构件对象
         */
        public void addChild(Component child) {
            childComponents.add(child);
        }
     
        /**
         * 聚集管理方法，删除一个子构件对象
         * @param index 子构件对象的下标
         */
        public void removeChild(int index) {
            childComponents.remove(index);
        }
     
        /**
         * 聚集管理方法，返回所有子构件对象
         * @return 返回所有子构件对象
         */
        public List<Component> getChild() {
            return childComponents;
        }
     
        public void printStruct(String preStr) {
            //首先输出自身
            System.out.println(preStr + '+' + this.name);
            
            //如果还包含有子组件，那么就输出这些子组件对象
            if (this.childComponents != null) {
                //添加前缀空格，表示向后缩进
                preStr += "  ";
               
                //循环递归输出每个子对象
                for (Component component : childComponents) {
                    component.printStruct(preStr);
                }
            }
        }
    }

树叶构件角色类，此类将implements Component改为extends Component，其他地方无变化。

    public class Leaf extends Component {
        /**
         * 组合对象的名称
         */
        private String name;
        
        /**
         * 构造方法，传入组合对象的名称
         * @param name 组合对象的名称
         */
        public Leaf(String name) {
            this.name = name;
        }
     
        /**
         * 输出叶子对象，因为叶子对象没有字对象，也就是输出叶子对象的名称。
         * @param preStr 前缀，主要是按照层级进行拼接的空格，用于实现向后缩进
         */
        @Override
        public void printStruct(String preStr) {
            System.out.println(preStr + "-" + name);
        }
    }

客户端类的主要变化是不在区分树枝构件角色Composite对象和树叶构件角色Leaf对象。

    public class Client {
        public static void main(String[] args) {
            Component root = new Composite("服装");
            Component c1 = new Composite("男装");
            Component c2 = new Composite("女装");
            
            Component leaf1 = new Leaf("衬衫");
            Component leaf2 = new Leaf("夹克");
            Component leaf3 = new Leaf("裙子");
            Component leaf4 = new Leaf("套装");
            
            root.addChild(c1);
            root.addChild(c2);
            c1.addChild(leaf1);
            c1.addChild(leaf2);
            c2.addChild(leaf3);
            c2.addChild(leaf4);
            
            root.printStruct("");
        }
    }

可以看出，客户端无需再区分操作的是树枝对象还是树叶对象了，对于客户端而言，操作的都是Component对象。