zoukankan      html  css  js  c++  java
  • [设计模式]组合模式

    1. 定义

      组合模式将对象组合成树结构以表示“部分-整体”的层析结构。组合模式使得用户对单个对象和组合对象的使用具有一致性。

    2. 类图

      

      Component: 抽象的组件对象,为组合中对象声明借口,客户端可以访问和管理整个对象结构,也可以在里面为定义的功能提供缺省的实现。

         Composite: 组合对象,通常会存储子组件,定义包含了子组件的那些组件行为,并实现在组件借口中定义的与子组件有关的操作。

      Leaf:叶子节点对象,定义和实现叶子对象的行为,不再包含其他子组件对象。

      Client:客户端,通过组件借口来操作组件结构中的组件对象。

    3. 实例

      

    package com.jerry.designpattern;
    /**
     * 
     * @author Jerry
     * @date 2015年1月28日 下午11:35:34
     */
    public abstract class Component {
        /**
         * 输出名称
         */
        public abstract void printName();
        
        /**
         * 添加子组件
         * @param c
         * @throws UnsupportedOperationException
         */
        public void addChild(Component c) {
            throw new UnsupportedOperationException("对象不支持这个方法");
        }
        
        /**
         * 移除子组件
         * @param c
         */
        public void removeChild(Component c) {
            throw new UnsupportedOperationException("对象不支持这个方法");
        }
        
        /**
         * 获得子组件
         * @param index
         * @return
         */
        public Component get(int index) {
            throw new UnsupportedOperationException("对象不支持这个方法");
        }
    }
    
    package com.jerry.designpattern;
    
    import java.util.ArrayList;
    import java.util.List;
    
    /**
     * 
     * @author Jerry
     * @date 2015年1月28日 下午11:42:40
     */
    public class Composite extends Component{
        private String name;
        private List<Component> components;
        
        public Composite(String name) {
            this.name = name;
            components =  new ArrayList<>();
        }
    
        @Override
        public void printName() {
            // TODO Auto-generated method stub
            System.out.println("name: " + this.name + "-------------------");
            for (Component c: components) {
                c.printName();
            }
            System.out.println("-----------------------");
        }
        
        @Override
        public void addChild(Component c) {
            // TODO Auto-generated method stub
            components.add(c);
        }
        
        @Override
        public void removeChild(Component c) {
            // TODO Auto-generated method stub
            components.remove(c);
        }
        
        @Override
        public Component get(int index) {
            // TODO Auto-generated method stub
            return components.get(index);
        }
    }
    
    package com.jerry.designpattern;
    /**
     * 
     * @author Jerry
     * @date 2015年1月28日 下午11:41:22
     */
    public class Leaf extends Component{
        
        private String name;
        
        public Leaf(String name) {
            this.name = name;
        }
        
        @Override
        public void printName() {
            // TODO Auto-generated method stub
            System.out.println("name: " + this.name);
        }
    
    }
    
    package com.jerry.designpattern;
    /**
     * 
     * @author Jerry
     * @date 2015年1月28日 下午11:47:44
     */
    public class Client {
        public static void main(String[] args) {
            Component root = new Composite("漫画");
            Component c1 = new Composite("热血漫画");
            Component c2 = new Composite("体育漫画");
            
            Component c11 = new Leaf("七龙珠");
            Component c12 = new Leaf("海贼王");
            c1.addChild(c11);
            c1.addChild(c12);
            
            Component c21 = new Leaf("灌篮高手");
            Component c22 = new Leaf("足球小将");
            c2.addChild(c21);
            c2.addChild(c22);
            
            root.addChild(c1);
            root.addChild(c2);
            
            root.printName();
        }
    }

    4. 组合模式的优缺点

      优点:a. 定义了包含基本对象和组合对象的层次结构。

         b. 统一了叶子对象和组合对象。

         c. 简化了客户端的调用。

         d. 更容易扩展。

      缺点: 很难限制组合中的组件类型。

  • 相关阅读:
    [HIHO1223]不等式(离散化,枚举)
    [NYIST15]括号匹配(二)(区间dp)
    [HIHO1328]逃离迷宫(bfs,位压)
    [Topcoder]AvoidRoads(dp,hash)
    [POJ1159]Palindrome(dp,滚动数组)
    [Topcoder]ZigZag(dp)
    [NYIST32]组合数(状压,枚举,暴力)
    [NYIST737]石子合并(一)(区间dp)
    [HIHO1322]树结构判定(并查集)
    [HIHO1143]骨牌覆盖问题·一(矩阵快速幂,递推)
  • 原文地址:https://www.cnblogs.com/jerry19890622/p/4257426.html
Copyright © 2011-2022 走看看