组合模式(Composite Pattern)

转：http://www.cnblogs.com/doubleliang/archive/2011/12/27/2304104.html

简而言之，就是让所有的叶子节点执行相同的操作！！！！！！！！！！！！！！！

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

有时候又叫做部分-整体模式，它使我们树型结构的问题中，模糊了简单元素和复杂元素的概念，客户程序可以像处理简单元素一样来处理复杂元素,从而使得客户程序与复杂元素的内部结构解耦。

组合模式让你可以优化处理递归或分级数据结构。有许多关于分级数据结构的例子，使得组合模式非常有用武之地。关于分级数据结构的一个普遍性的例子是你每次使用电脑时所遇到的:文件系统。文件系统由目录和文件组成。每个目录都可以装内容。目录的内容可以是文件，也可以是目录。按照这种方式，计算机的文件系统就是以递归结构来组织的。如果你想要描述这样的数据结构，那么你可以使用组合模式Composite。

先看看组合模式的定义吧，在《大话设计模式一书中》组合模式的定义为：“将对象组合成树形结构以表示‘部分-整体’的层次结构。组合模式使得用户对单个对象和组合对象的使用具有一致性。”

       那就拿我剪发办卡的事情来分析一下吧。

       首先，一张卡可以在总部，分店，加盟店使用，那么总部可以刷卡，分店也可以刷卡，加盟店也可以刷卡，这个属性结构的店面层级关系就明确啦。

       那么，总店刷卡消费与分店刷卡消费是一样的道理，那么总店与分店对会员卡的使用也具有一致性。

      1.组合模式的例子

        组合模式结构图：

        那么组合模式的实例如下：

 //抽象的部件类描述将来所有部件共有的行为
    public abstract class Component
    {
        protected string name;
        public string Name
        {
            get
            {
                return name;
            }
            set
            {
                name = value;
            }
        }
        //添加部件
        public abstract void Add(Component component);
        //删除部件
        public abstract void Remove(Component component);
        //遍历所有子部件
        public abstract void eachChild();
    }

    //组合部件类
    public class Leaf : Component
    {
        //叶子节点不具备添加的能力，所以不实现
        public override void Add(Component component)
        {
            throw new NotImplementedException();
        }

        //叶子节点不具备添加的能力必然也不能删除
        public override void Remove(Component component)
        {
            throw new NotImplementedException();
        }

        //叶子节点没有子节点所以显示自己的执行结果
        public override void eachChild()
        {
            Console.WriteLine("{0}执行了..",name);
        }
    }

    //组合类
    public class Composite : Component
    {
        //用来保存组合的部件
        List<Component> myList = new List<Component>();

        //添加节点 添加部件
        public override void Add(Component component)
        {
            myList.Add(component);
        }

        //删除节点 删除部件
        public override void Remove(Component component)
        {
            myList.Remove(component);
        }

        //遍历子节点
        public override void eachChild()
        {
            Console.WriteLine("{0}执行了..", name);
            foreach (Component c in myList)
            {
                c.eachChild();
            }
        }
    }
    static void Main(string[] args)
    {
            //构造根节点
            Composite rootComponent = new Composite();
            rootComponent.Name = "根节点";

            //添加两个叶子几点，也就是子部件
            Leaf l = new Leaf();
            l.Name = "叶子节点一";
            Leaf l1 = new Leaf();
            l1.Name = "叶子节点二";

            rootComponent.Add(l);
            rootComponent.Add(l1);

            //遍历组合部件
            rootComponent.eachChild();
     }

        运行结果如下：

      

      2.应用组合模式的会员卡消费

        那么我们就根据我们会员卡的消费，来模拟一下组合模式的实现吧！let's go！

        首先：

               1.我们的部件有，总店，分店，加盟店！

               2.我们的部件共有的行为是：刷会员卡

               3.部件之间的层次关系，也就是店面的层次关系是，总店下有分店、分店下可以拥有加盟店。

        有了我们这几个必要条件后，我的要求就是目前店面搞活动当我在总店刷卡后，就可以累积相当于在所有下级店面刷卡的积分总额，设计的代码如下：

 /// <summary>
    /// 店面类 抽象出来的店面部件
    /// </summary>
    public abstract class Storefront
    {
        //店名
        protected string storeName = string.Empty;
        public string StoreName
        {
            get
            {
                return storeName;
            }
        }

        //添加店面
        public abstract void Add(Storefront store);
        //删除店面
        public abstract void Remove(Storefront store);

        //定义所有部件公用的行为 刷卡行为
        public abstract void PayByCard();
    }

    public class StoreOrBranch : Storefront
    {
        //构造函数
        public StoreOrBranch() { }
        public StoreOrBranch(string storeName)
        {
            this.storeName = storeName;
        }
        List<Storefront> myStoreList = new List<Storefront>();
        //刷卡消费
        public override void PayByCard()
        {
            Console.WriteLine("店面{0}的积分已累加进该会员卡", storeName);
            foreach (Storefront sf in myStoreList)
            {
                sf.PayByCard();
            }
        }

        //增加店面
        public override void Add(Storefront store)
        {
            myStoreList.Add(store);
        }

        //解除店面
        public override void Remove(Storefront store)
        {
            myStoreList.Remove(store);
        }
    }

    public class JoinInStore : Storefront
    {
        //构造函数
        public JoinInStore() { }
        public JoinInStore(string storeName)
        {
            this.storeName = storeName;
        }
        //刷卡消费
        public override void PayByCard()
        {
            Console.WriteLine("店面{0}的积分已累加进该会员卡", storeName);
        }

        public override void Add(Storefront store)
        {
            throw new NotImplementedException();
        }

        public override void Remove(Storefront store)
        {
            throw new NotImplementedException();
        }
    }

   static void Main(string[] args)
   {
            StoreOrBranch store = new StoreOrBranch("朝阳总店");
            StoreOrBranch brach = new StoreOrBranch("东城分店");
            JoinInStore jstore = new JoinInStore("海淀加盟店一");
            JoinInStore jstore1 = new JoinInStore("上地加盟店二");

            brach.Add(jstore);
            brach.Add(jstore1);
            store.Add(brach);

            store.PayByCard();
    }

      运行结果如下：

      

       这样在累积所有子店面积分的时候，就不需要去关心子店面的个数了，也不用关系是否是叶子节点还是组合节点了，也就是说不管是总店刷卡，还是加盟店刷卡，都可以正确有效的计算出活动积分。

      3.什么情况下使用组合模式

       引用大话设计模式的片段：“当发现需求中是体现部分与整体层次结构时，以及你希望用户可以忽略组合对象与单个对象的不同，统一地使用组合结构中的所有对象时，就应该考虑组合模式了。”