设计模式----Composite(组合)模式

设计模式----Composite(组合)模式

 

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

组合体内这些对象都有共同接口,当组合体一个对象的方法被调用执行时，Composite将遍历(Iterator)整个树形结构,寻找同样包含这个方法的对象并实现调用执行。可以用牵一动百来形容。
 

Composite模式描述了并实现了树形目录结构，在该模式中要有一个组合体，它是一个抽象类或接口（Component），组合体中定义足够多的方法。当组合体（Component）一个对象的方法被调用执行时，Composite将遍历（Iterator）整个树形结构，寻找同样包含这个方法的对象并实现调用执行。
 

在Composite模式中要用到Iterator（迭代器）模式和Chain of Responsibility(职责链)模式。这两个模式我还没有学到，但是Java中的Iterator我用过。暂时先将Composite模式实现。
 

以组装电脑为例，首先需要一个组合体：
package Composite;
 

import java.util.Iterator;
 

public abstract class EquipmentComponent
{
    String E_name;
   
    public String getName()
    {
        return E_name;
    }//end getName(...)
   
    public void setName(String strName)
    {
        this.E_name = strName;
    }//end setName(...)
  
    public double getPrice(int eNumber, double price)
    {
        double equipmentPrice = 0;
        equipmentPrice = eNumber * price;
        return equipmentPrice;
    }//end getPrice()
   
    public abstract double equipmentPrice(int eNumber, double price);
   
    public boolean add(EquipmentComponent eq)
    {
        return false;
    }//end add(...)
   
    public boolean remove(EquipmentComponent eq)
    {
        return false;
    }//end remove(...)
   
    public Iterator iter()
    {
        return null;
    }//end iter()
}//end abstract class EquipmentComponent
 

接着我们实现一个软盘的类：
package Composite;
 

public class FloppyDisk extends EquipmentComponent
{
   
    public FloppyDisk()
    {
        //do something....
    }//end FloppyDisk()
   
    public double equipmentPrice(int eNumber, double price)
    {
        double equipmentPrice = getPrice(eNumber, price);
        return equipmentPrice;
    }//end equipmentPrice()
   
}//end class FloppyDisk
 

下面实现Composite类：
package Composite;
 

import java.util.ArrayList;
import java.util.Iterator;
 

public class EquipmentComposite extends EquipmentComponent
{
   
    /** Creates a new instance of EquipmentComposite */
    public EquipmentComposite()
    {
        //do something....
    }//end EquipmentComposite()
   
    private ArrayList equipment = new ArrayList();
   
    public double equipmentPrice(int eNumber, double price)
    {
        double equipmentPrice = 0;
        Iterator eIter = equipment.iterator();
        while(eIter.hasNext())
            equipmentPrice += ((EquipmentComponent)eIter.next()).getPrice(eNumber, price);
        return equipmentPrice;
    }//end equipmentPrice(...)
   
    public boolean add(EquipmentComponent eqc)
    {
        boolean addBool = equipment.add(eqc);
        if (addBool)
            return true;
        else
            return false;
    }//end add(...)
   
    public boolean remove(EquipmentComponent eqc)
    {
        if(equipment.size() == 0)
            return false;
        boolean removeBool = equipment.remove(eqc);
        if(removeBool)
            return true;
        else
            return false;
    }//end remove(...)
   
}//end class EquipmentComposite
 

接着实现一个箱子类：
package Composite;
 

public class Cabinet extends EquipmentComposite
{
    public Cabinet()
    {
        //do something....
    }//end Mosue()
   
    public double equipmentPrice(int eNumber, double price)
    {
        double chassisPrice = super.equipmentPrice(eNumber, price);
        return chassisPrice;
    }//end equipmentPrice(...)
   
}//class Cabinet
 

最后看看调用：
/*
 * CompositePattern.java
 *
 * Created on 2006年3月30日, 上午11:14
 *
 * To change this template, choose Tools | Template Manager
 * and open the template in the editor.
 */
 

package Composite;
 

/**
 *
 * @author Administrator
 */
public class CompositePattern
{
    Cabinet chassis = new Cabinet();
   
    /**
     * Creates a new instance of CompositePattern
     */
    public CompositePattern()
    {
        //do something....
    }//end CompositePattern()
   
    public void showCompositePattern()
    {
        chassis.setName("Power");
        String chassisName = chassis.getName();
        chassis.add(new FloppyDisk());
        double chassisPrice = chassis.equipmentPrice(1, 32.5);
        System.out.println("The chassis name is: " + chassisName);
        System.out.println("The chassis price is: " + chassisPrice);
    }//end showCompositePattern()
   
    public static void main(String[] args)
    {
        System.out.println("*--------------< Begin >-----------------*");
        System.out.println("The Composite Pattern!");
        CompositePattern cp = new CompositePattern();
        cp.showCompositePattern();
        System.out.println("*---------------< End >------------------*");
    }//end main(...)
   
}//end class CompositePattern
 

下面是Composite模式的UML图：

 


其中：
EquipmentComponent，为组合中的对象声明接口；在适当情况下实现所有类共有接口的缺省行为。
FloppyDisk，在组合中表示叶结点对象，叶结点没有子结点。
EquipmentComposite，定义有子部件的那些行为；存储子部件。
Chassis，子部件，用于存储叶结点。
在上例的代码中，我的实现非常的粗糙和不合理，但是已经表达出Composite模式的意思。以后在用到的时候要根据具体情况加以完善。
 

Composite模式是一种非常灵巧的模式，有些人说“设计模式不过是一种高超的编成技巧”，说这种话也是有一定道理的。只不过这种高超的技巧被上升为一种理论。并且实际大大提高了软件的合理性和强壮性。
 

论坛其实就是一个树形结构。在以后着手开发论坛的时候，我要尝试用用Composite模式。
 

 

Trackback: http://tb.blog.csdn.net/TrackBack.aspx?PostId=968327