[设计模式]组合模式

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. 更容易扩展。

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