[结构型模式]组合模式（Composite）的安全模式与透明模式

落日映苍穹つ 2022-04-11 05:10 286阅读 0赞

转自\[url\]http://haolloyin.blog.51cto.com/1177454/347308/\[/url\]  
  
\[b\]\[color=red\]组合模式（Composite）：\[/color\]\[/b\]将对象组合成树形结构以表示“部分-整体”的层次结构，使得用户对单个对象和组合对象的使用具有一致性。  
\[color=red\]\[b\]使用场景\[/b\]\[/color\]：  
1、用于对象的部分-整体层次结构，如树形菜单、文件夹菜单、部门组织架构图等；  
2、对用户隐藏组合对象与单个对象的不同，使得用户统一地使用组合结构中的所有对象。  
通用类图：  
\[img\]http://img1.51cto.com/attachment/201007/132836881.jpg\[/img\]  
  
说到树，“数据结构”这门课上都学习过了，树的遍历问题最重要了。下面按照类图直接用简单的代码实现一番。

// 抽象构件类、节点类
    abstract class Component {
       
    	public String name;
    
    	public Component(String name) {
       
    		this.name = name;
    	}
    
    	// 公有操作
    	public void getName() {
       
    		System.out.println(this.name);
    	}
    }
    
     // 树枝构件类
    class Composite extends Component {
       
    
    	private LinkedList<Component> children;
    
    	public Composite(String name) {
       
    		super(name);
    		this.children = new LinkedList<Component>();
    	}
    
    	// 添加一个节点，可能是树枝、叶子
    	public void add(Component child) {
       
    		this.children.add(child);
    	}
    
    	// 删除一个节点，可能是树枝、叶子
    	public void remove(String child) {
       
    		this.children.remove(child);
    	}
    
    	// 获取子树
    	public LinkedList<Component> getChildren() {
       
    		return this.children;
    	}
    }
    
     // 树叶构件类
    class Leaf extends Component {
       
    
    	public Leaf(String name) {
       
    		super(name);
    	}
    }
    
     // 测试类，负责构建整棵树
    public class Client {
       
    	public static void main(String[] args) {
       
    
    		Composite root = new Composite("树根");
    
    		Composite branch01 = new Composite("树枝01");
    		Composite branch02 = new Composite("树枝02");
    
    		root.add(branch01);
    		root.add(branch02);
    
    		Component leaf01 = new Leaf("树叶01");
    		Component leaf02 = new Leaf("树叶02");
    		Component leaf03 = new Leaf("树叶03");
    		Component leaf04 = new Leaf("树叶04");
    		Component leaf05 = new Leaf("树叶05");
    
    		branch01.add(leaf01);
    		branch01.add(leaf02);
    
    		branch02.add(leaf03);
    		branch02.add(leaf04);
    		branch02.add(leaf05);
    
    		displayTree(root);
    
    	}
    
    	// 递归遍历整棵树
    	public static void displayTree(Composite root) {
       
    		LinkedList<Component> children = root.getChildren();
    
    		for (Component c : children) {
       
    			if (c instanceof Leaf) {
       
    				System.out.print("\t");
    				c.getName();
    			} else {
       
    				c.getName();
    				// 递归
    				displayTree((Composite)c);
    			}
    		}
    	}
    }

测试结果：
    树枝01
    	树叶01
    	树叶02
    树枝02
    	树叶03
    	树叶04
    	树叶05

上面的 Client 类构建树的代码让人看了觉得烦，如果整棵树下来有几百个节点，这样子的工作效率太糟糕了。其实，在实际应用中，并不是这样子手工地构建一棵复杂的树的，应该是我们已经将整棵树的节点内容、逻辑关系都存储在数据库表中（更重要的是这录入工作应该不是我们开发人员做的），由于表中的各个节点记录都保存有自身的一些相关信息，包括是否为树叶、父节点等等，开发人员需要的就是让程序从数据库中的表中读取记录来构建整棵树。  
此外，上面的代码中只能从根节点往下遍历，不能够从某一节点开始往上遍历，解决这个问题可以在抽象构件类 Component 类中添加一个 parent 属性，再添加相应 setParent() 、 getParent()方法即可。而关于不同的遍历方法再具体实现一下就完成了。  
上面的类图是属于安全模式的，因为 Leaf 类不具有 add 、 remove 等方法，这些具体方法是被下置到 Composite 类（树枝节点类）中去具体实现了。  
如果要实现透明模式，类图如下：  
\[img\]http://img1.51cto.com/attachment/201007/132904206.jpg\[/img\]  
  
差别仅在于将 add 、remove 等方法上升到抽象构件类 Component 中去了。那么此时 Leaf 类在具体实现时就必须将继承而来的 add 、remove 等不可用、不合逻辑的方法给注解 Deprecated 掉，并抛出适当的异常，不提供给用户使用。看起来这种透明模式似乎更加麻烦，没事找事。其实，这种模式下使得我们在遍历整棵树的时候可以不进行强制类型转换。看看上面的 displayTree() 方法，里面在使用递归遍历时就使用到了 （Composite）c 强制类型转换了。

Leaf 类代码如下：
    // 树叶构件类
    class Leaf extends Component {
       
    
    	public Leaf(String name) {
       
    		super(name);
    	}
    
    	@Deprecated // 抛出不支持的操作异常
    	public void add(Component child) throws UnsupportedOperationException{
       
    		throws new UnsupportedOperationException();
    	}
    
    	@Deprecated
    	public void remove(String child) throws UnsupportedOperationException{
       
    		throws new UnsupportedOperationException();
    	}
    
    	@Deprecated
    	public LinkedList<Component> getChildren() throws UnsupportedOperationException{
       
    		throws new UnsupportedOperationException();
    	}
    }

具体怎么使用安全模式或透明模式，看具体情况咯。  
  
  
转自\[url\]http://www.cnblogs.com/jiese/p/3168844.html\[/url\]  
  
Composite组合模式  
作用：将对象组合成树形结构以表示“部分-整体”的层次结构。Composite使得用户对单个对象和组合对象的使用具有一致性。  
  
UML图如下：  
\[img\]http://images.cnitblog.com/blog/159936/201307/03094313-57059ecfa6164fe58e12cb8a7f4a167b.png\[/img\]  
  
在Component中声明所有用来管理子对象的方法，其中包括Add、Remove等，这样实现Component接口的所有子类都具备了Add和Remove。  
这样做的好处就是叶节点和枝节点对于外界没有区别，它们具备 完全一致的行为 接口。  
但问题也很明显，因为Leaf类本身不具备Add()、Remove()方法的 功能，所以实现它是没有意义的。  
  
何时使用组合模式：  
当你发现需求中是体现部分与整体层次的结构时，以及你希望用户可以忽略组合对象与单个对象的不同，统一地使用组合结构中的所有对象时，就应该考虑用组合模式了。  
  
基本对象可以被组合成更复杂的组合对象，而这个组合对象又可以被组合，这样不断地递归下去，客户代码中，任何用到基本对象的地方都可以使用组合对象了。  
  
用户不用关心到底是处理一个叶节点还是处理一个组合组件，也就用不着为定义组合二写一些选择判断语句了。  
  
组合模式让客户可以一致地使用组合结构和单个对象。  
  
抽象基类:  
1)Component:为组合中的对象声明接口，声明了类共有接口的缺省行为(如这里的Add,Remove,GetChild函数)，声明一个接口函数可以访问Component的子组件.  
  
接口函数:  
1)Component::Operatation:定义了各个组件共有的行为接口，由各个组件的具体实现.  
2)Component::Add添加一个子组件  
3)Component::Remove::删除一个子组件.  
4)Component::GetChild:获得子组件的指针.  
  
说明:  
Component模式是为解决组件之间的递归组合提供了解决的办法，它主要分为两个派生类：  
  
1)、Leaf是叶子结点,也就是不含有子组件的结点  
  
2)、Composite是含有子组件的类.  
  
举一个例子来说明这个模式，在UI的设计中,最基本的控件是诸如Button、Edit这样的控件，相当于是这里的Leaf组件，而比较复杂的控件比如Panel则可也看做是由这些基本的组件组合起来的控件，相当于这里的Composite，它们之间有一些行为含义是相同的，比如在控件上作一个点击,移动操作等等的，这些都可以定义为抽象基类中的接口虚函数，由各个派生类去实现之，这些都会有的行为就是这里的Operation函数，而添加、删除等进行组件组合的操作只有非叶子结点才可能有，所以虚拟基类中只是提供接口而且默认的实现是什么都不做。  
  
代码如下：  
  
Composite.h

#ifndef _COMPOSITE_H_
    #define _COMPOSITE_H_
    
    #include <vector>
    
    using namespace std;
    
    /*
    Component抽象基类，为组合中的对象声明接口,声明了类共有接口的缺省行为(如这里的Add,Remove,GetChild函数),
    声明一个接口函数可以访问Component的子组件.
    */
    class Component
    {
       
    public:
        //纯虚函数，只提供接口，没有默认的实现
        virtual void Operation()=0;    
    
        // 虚函数,提供接口,有默认的实现就是什么都不做
        virtual void Add(Component*);
        virtual void Remove(Component*);
        virtual Component* GetChild(int index);
        virtual ~Component();
    protected:
        Component();
    };
    
    //Leaf是叶子结点,也就是不含有子组件的结点类，所以不用实现Add、Remove、GetChild等方法
    class Leaf:public Component
    {
       
    public:
        //只实现Operation接口
        virtual void Operation();            
        Leaf();
        ~Leaf();
    };
    
    //Composite：含有子组件的类
    class Composite:public Component
    {
       
    public:
        Composite();
        ~Composite();
        //实现所有接口
        void Operation();
        void Add(Component*);
        void Remove(Component*);
        Component* GetChild(int index);
    private:
        //这里采用vector来保存子组件
        vector<Component*> m_ComVec;        
    };
    #endif

Compostie.cpp

#include "Composite.h"
    #include <iostream>
    
    using namespace std;
    
    Component::Component()
    {}
    
    Component::~Component()
    {}
    
    void Component::Add(Component* com)
    {
       
        cout << "add" << endl;
    }
    
    void Component::Remove(Component* com)
    {
       
    }
    
    void Component::Operation()
    {
       
        cout << "Component::Operation" << endl;
    }
    
    Component* Component::GetChild(int index)
    {
       
        return NULL;
    }
    
    
    Leaf::Leaf()
    {}
    
    Leaf::~Leaf()
    {}
    
    void Leaf::Operation()
    {
       
        cout<< "Leaf::Operation" <<endl;
    }
    
    Composite::Composite()
    {
       
    }
    
    Composite::~Composite()
    {}
    
    void Composite::Add(Component* com)
    {
       
        this->m_ComVec.push_back(com);
    }
    
    void Composite::Remove(Component* com)
    {
       
        this->m_ComVec.erase(&com);
    }
    
    void Composite::Operation()
    {
       
        cout << "Composite::Operation" << endl;
        vector<Component*>::iterator iter = this->m_ComVec.begin();
        for(;iter!= this->m_ComVec.end();iter++)
        {
       
            (*iter)->Operation();
        }
    }
    
    Component* Composite::GetChild(int index)
    {
       
        if(index < 0 || index > this->m_ComVec.size())
        {
       
            return NULL;
        }
        return this->m_ComVec[index];
    }

main.cpp

#include "Composite.h"
    #include <iostream>
    
    using namespace std;
    
    int main()
    {
       
        /*
          不管是叶子Leaf还是Composite对象pRoot、pCom都实现了Operation接口，所以可以一致对待，直接调用Operation()
          体现了“使得用户对单个对象和组合对象的使用具有一致性。”
        */
        Composite* pRoot = new Composite();
    
        //组合对象添加叶子节点
        pRoot->Add(new Leaf());
    
        Leaf* pLeaf1 = new Leaf();
        Leaf* pLeaf2 = new Leaf();
    
        //这里的叶子再添加叶子是没有意义的。
        //由于叶子与组合对象继承了相同的接口，所以语法上是对的，实际上什么也没做(继承自基类Component的Add方法)。
        //叶子节点只实现了Operation方法，其他Add、Remove、GetChild都继承自基类，没有实际意义。
        pLeaf1->Add(pLeaf2);
        pLeaf1->Remove(pLeaf2);
        //执行叶子Operation操作
        pLeaf1->Operation();
    
        //组合对象实现了基类Component的所有接口，所以可以做各种操作(Add、Remove、GetChild、Operation)。
        Composite* pCom = new Composite();
        //组合对象添加叶子节点
        pCom->Add(pLeaf1);
        //组合对象添加叶子节点
        pCom->Add(pLeaf2);
        //执行组合对象Operation操作
        pCom->Operation();
    
        //组合对象添加组合对象
        pRoot->Add(pCom);
    
        //执行组合对象Operation操作
        pRoot->Operation();
    
        //Component* cp = pCom->GetChild(0);
        //cp->Operation();
    
        //pCom->Remove(pLeaf1);
    
        return 0;
    }

组合的另一个例子：摘自http://blog.csdn.net/wuzhekai1985/article/details/6667564  
  
DP书上给出的定义：将对象组合成树形结构以表示“部分-整体”的层次结构。组合使得用户对单个对象和组合对象的使用具有一致性。注意两个字“树形”。这种树形结构在现实生活中随处可见，比如一个集团公司，它有一个母公司，下设很多家子公司。不管是母公司还是子公司，都有各自直属的财务部、人力资源部、销售部等。对于母公司来说，不论是子公司，还是直属的财务部、人力资源部，都是它的部门。整个公司的部门拓扑图就是一个树形结构。  
  
下面给出组合模式的UML图。从图中可以看到，FinanceDepartment、HRDepartment两个类作为叶结点，因此没有定义添加函数。而ConcreteCompany类可以作为中间结点，所以可以有添加函数。那么怎么添加呢？这个类中定义了一个链表，用来放添加的元素。  
\[img\]http://images.cnitblog.com/blog/159936/201307/03095325-6d4e14fb112a4ef69c9352a8097a9e9f.png\[/img\]  
  
相应的代码实现为：

class Company  
    {
       
    public:
        Company(string name) { m_name = name; }
        virtual ~Company(){}
        virtual void Add(Company *pCom){}
        virtual void Show(int depth) {}
    protected:
        string m_name;
    };
    //具体公司
    class ConcreteCompany : public Company  
    {
       
    public:
        ConcreteCompany(string name): Company(name) {}
        virtual ~ConcreteCompany() {}
        void Add(Company *pCom) { m_listCompany.push_back(pCom); } //位于树的中间，可以增加子树
        void Show(int depth)
        {
       
            for(int i = 0;i < depth; i++)
                cout<<"-";
            cout<<m_name<<endl;
            list<Company *>::iterator iter=m_listCompany.begin();
            for(; iter != m_listCompany.end(); iter++) //显示下层结点
                (*iter)->Show(depth + 2);
        }
    private:
        list<Company *> m_listCompany;
    };
    //具体的部门，财务部
    class FinanceDepartment : public Company 
    {
       
    public:
        FinanceDepartment(string name):Company(name){}
        virtual ~FinanceDepartment() {}
        virtual void Show(int depth) //只需显示，无限添加函数，因为已是叶结点
        {
       
            for(int i = 0; i < depth; i++)
                cout<<"-";
            cout<<m_name<<endl;
        }
    };
    //具体的部门，人力资源部
    class HRDepartment :public Company  
    {
       
    public:
        HRDepartment(string name):Company(name){}
        virtual ~HRDepartment() {}
        virtual void Show(int depth) //只需显示，无限添加函数，因为已是叶结点
        {
       
            for(int i = 0; i < depth; i++)
                cout<<"-";
            cout<<m_name<<endl;
        }
    };

客户使用方式：

int main()
    {
       
        Company *root = new ConcreteCompany("总公司");
        Company *leaf1=new FinanceDepartment("财务部");
        Company *leaf2=new HRDepartment("人力资源部");
        root->Add(leaf1);
        root->Add(leaf2);
    
        //分公司A
        Company *mid1 = new ConcreteCompany("分公司A");
        Company *leaf3=new FinanceDepartment("财务部");
        Company *leaf4=new HRDepartment("人力资源部");
        mid1->Add(leaf3);
        mid1->Add(leaf4);
        root->Add(mid1);
        //分公司B
        Company *mid2=new ConcreteCompany("分公司B");
        FinanceDepartment *leaf5=new FinanceDepartment("财务部");
        HRDepartment *leaf6=new HRDepartment("人力资源部");
        mid2->Add(leaf5);
        mid2->Add(leaf6);
        root->Add(mid2);
        root->Show(0);
    
        delete leaf1; delete leaf2;
        delete leaf3; delete leaf4;
        delete leaf5; delete leaf6;    
        delete mid1; delete mid2;
        delete root;
        return 0;
    }

上面的实现方式有缺点，就是内存的释放不好，需要客户自己动手，非常不方便。有待改进，比较好的做法是让ConcreteCompany类来释放。因为所有的指针都是存在ConcreteCompany类的链表中。C++的麻烦，没有垃圾回收机制。上面的实现方式有缺点，就是内存的释放不好，需要客户自己动手，非常不方便。有待改进，比较好的做法是让ConcreteCompany类来释放。因为所有的指针都是存在ConcreteCompany类的链表中。C++的麻烦，没有垃圾回收机制。