Magic — Sun, 14 Feb 2016 06:36:00 GMT

1.概述

�l�合模式有时候又叫做部分-整体模式�Q�它使我们树(w��i)型结构的问题中，模糊了简单元素和复杂元素的概念，客户�E�序可以向处理简单元素一��h��处理复杂元素,从而��得客��L(f��ng)��序与复杂元素的内部结构解耦�?/span>

�l�合模式�Q�Composite Pattern�Q�：(x��)��对象组合成�?w��i)�Ş�l�构以表�C?#8216;部分-整体’的层�ơ结构，�l�合模式使得用户对单个对象和�l�合对象的��用具有一致性�?/strong>

     �l�合模式�l�构囑֦�下：(x��)

     �l�构图说明：(x��)

     �Q?�Q�Component�Q�组合中的对象声明接口，在适当情况下实现所有类共有的默认行为，声明一个接口用于访问和��理Component的子�l��g。在递归�l�构中定义一个接口，用于讉K��一个父部�g�Q��ƈ在合适的情况下实现它。（可选）

     �Q?�Q�Leaf:在组合中表示叶节点，叶节�Ҏ(gu��)��有子节点�Q�定义对象的基本行�ؓ(f��)�?/p>
     �Q?�Q�Composite�Q�定义有子部件的那些部�g的行为，存储子部件�ƈ在Component接口实现与子部�g有关的操作�?/p>
     �Q?�Q�Client:通过Component接口操作�l�合部�g的对象�?/p>
     �l�合模式基本代码�Q?/p>

  public abstract class Component
    {
        protected string name;

        public Component(string name)
        {
            this.name = name;
        }

        public abstract void Add(Component c);
        public abstract void Remove(Component c);
        public abstract void Display(int depth);
    }

     Composite:

public class Composite : Component
    {
        private List children = new List();

        public Composite(string name)
            : base(name)
        { }

        public override void Add(Component c)
        {
            children.Add(c);
        }

        public override void Remove(Component c)
        {
            children.Remove(c);
        }

        public override void Display(int depth)
        {
            Console.WriteLine(new String('-', depth) + name);

            foreach (Component component in children)
            {
                component.Display(depth + 2);
            }
        }
    }

     Leaf:

  public class Leaf : Component
    {
        public Leaf(string name)
            : base(name)
        { }

        public override void Add(Component c)
        {
            Console.WriteLine("Cannot add to a leaf");
        }

        public override void Remove(Component c)
        {
            Console.WriteLine("Cannot remove from a leaf");
        }

        public override void Display(int depth)
        {
            Console.WriteLine(new String('-', depth) + name);
        }
    }
客户端：(x��)

  public class Program
    {
        static void Main(string[] args)
        {
            Composite root = new Composite("root");
            root.Add(new Leaf("Leaf A"));
            root.Add(new Leaf("Leaf B"));

            Composite comp = new Composite("Composite X");
            comp.Add(new Leaf("Leaf XA"));
            comp.Add(new Leaf("Leaf XB"));

            root.Add(comp);

            Composite comp2 = new Composite("Composite XY");
            comp2.Add(new Leaf("Leaf XYA"));
            comp2.Add(new Leaf("Leaf XYB"));

            comp.Add(comp2);

            root.Add(new Leaf("Leaf C"));

            Leaf leaf = new Leaf("Leaf D");
            root.Add(leaf);
            root.Remove(leaf);

            root.Display(1);

            Console.Read();
        }
    }

     可以看出�Q�Composite�c�d��的对象可以包含其它Component�c�d��的对象。换而言之，Composite�c�d��对象可以含有其它的树(w��i)枝（Composite�Q�类型或�?w��i)叶�Q�Leaf�Q�类型的对象�?/p>
     �l�合模式的实现根据所实现接口的区别分��Z��U��Ş式，分别�U�Cؓ(f��)安全模式和透明模式。组合模式可以不提供父对象的��理�Ҏ(gu��)��Q�但�l�合模式必须在合适的地方提供子对象的��理�Ҏ(gu��)��Q�诸如：(x��)add、remove�{�）。安全式的组合模式要求管理聚集的�Ҏ(gu��)��只出现在�?w��i)枝构�g�c�M��Q�而不出现在树(w��i)叶构件中。与安全式的�l�合模式不同的是�Q�透明式的�l�合模式要求所有的具体构�g�c�，不论�?w��i)枝构�g�q�是�?w��i)叶构�g�Q�均�W�合一个固定的接口�?/p>
     透明模式�Q?/strong>也就是说在Component中声明所有用来管理子对象的方法，其中包括Add、Remove�{�。这样实现Component接口的所有子�c�都具备了Add和Remove。这样做的好处就是叶节点和枝节点对于外界没有区别�Q�它们具有完全一致的行�ؓ(f��)接口�Q�但问题也很明显�Q�因为Leaf�c�L��w�不具备Add(),Remove()�Ҏ(gu��)��的功能，所以实��C��是没有意义的�?/p>
     安全模式�Q?/strong>��是在Component接口中不��d��明Add和Remove�Ҏ(gu��)��Q�那么子�cȝ��Leaf也就不需要去实现它，而是在Composite声明所有用来管理子�c�d��象的�Ҏ(gu��)��Q�这样就不会(x��)出现透明模式出现的问题，不过�׃��不够透明�Q�所以叶节点和枝节点��不��h��相同的接口，客户端调用需要做相应的判断，带来了不�ѝ�?/p>
     2.实例�Q�大话设计模式）

     大话设计模式中的公司��理�pȝ��的结构图如下�Q?/p>

     具体实现代码如下�Q?/p>
CompanyComposite
  public abstract class Company
    {
        protected string name;

        public Company(string name)
        {
            this.name = name;
        }

        public abstract void Add(Company c);//增加
        public abstract void Remove(Company c);//�U�除
        public abstract void Display(int depth);//昄��
        public abstract void LineOfDuty();//履行职责

    }

    public class ConcreteCompany : Company
    {
        private List children = new List();

        public ConcreteCompany(string name)
            : base(name)
        { }

        public override void Add(Company c)
        {
            children.Add(c);
        }

        public override void Remove(Company c)
        {
            children.Remove(c);
        }

        public override void Display(int depth)
        {
            Console.WriteLine(new String('-', depth) + name);

            foreach (Company component in children)
            {
                component.Display(depth + 2);
            }
        }

        //履行职责
        public override void LineOfDuty()
        {
            foreach (Company component in children)
            {
                component.LineOfDuty();
            }
        }

    }

    //人力资源�?/span>
    public class HRDepartment : Company
    {
        public HRDepartment(string name)
            : base(name)
        { }

        public override void Add(Company c)
        {
        }

        public override void Remove(Company c)
        {
        }

        public override void Display(int depth)
        {
            Console.WriteLine(new String('-', depth) + name);
        }

        public override void LineOfDuty()
        {
            Console.WriteLine("{0} 员工招聘培训��理", name);
        }
    }

    //财务�?/span>
    public class FinanceDepartment : Company
    {
        public FinanceDepartment(string name)
            : base(name)
        { }

        public override void Add(Company c)
        {
        }

        public override void Remove(Company c)
        {
        }

        public override void Display(int depth)
        {
            Console.WriteLine(new String('-', depth) + name);
        }

        public override void LineOfDuty()
        {
            Console.WriteLine("{0} 公司财务收支��理", name);
        }

    }

     客户端代码：(x��)

Code
public class Program
    {
        static void Main(string[] args)
        {
            ConcreteCompany root = new ConcreteCompany("北京��d��?);
            root.Add(new HRDepartment("��d��思h力资源部"));
            root.Add(new FinanceDepartment("��d��司胦(ch��)务部"));

            ConcreteCompany comp = new ConcreteCompany("上�v华东分公�?);
            comp.Add(new HRDepartment("华东分公�思h力资源部"));
            comp.Add(new FinanceDepartment("华东分公司胦(ch��)务部"));
            root.Add(comp);

            ConcreteCompany comp1 = new ConcreteCompany("南京办事�?);
            comp1.Add(new HRDepartment("南京办事处�h力资源部"));
            comp1.Add(new FinanceDepartment("南京办事处胦(ch��)务部"));
            comp.Add(comp1);

            ConcreteCompany comp2 = new ConcreteCompany("杭州办事�?);
            comp2.Add(new HRDepartment("杭州办事处�h力资源部"));
            comp2.Add(new FinanceDepartment("杭州办事处胦(ch��)务部"));
            comp.Add(comp2);

            Console.WriteLine("\n�l�构图：(x��)");

            root.Display(1);

            Console.WriteLine("\n职责�Q?);

            root.LineOfDuty();

            Console.Read();
        }
    }

     �?NET中，一个典型的�l�合模式实例��是.NET的控�Ӟ��如Button�Q�TextBox和Label�{�，�q�些控�g都是�l�承自Control�c�，该类自��n包含ControlCollection的集合Controls�Q�控件和子控件的逻辑关系如下图：(x��)

     3.�ȝ��

     何时采用�l�合模式�Q?/strong>

     1.需求重要体现部分与整体的层�ơ结构时

     2.你希望用户忽略组合对象与单个对象的不同，用户��统一��C��用组合结构中的所有对象�?/p>
     使用效果�Q?/strong>

     1�Q�Composite模式采用�?w��i)�Ş�l�构来实现普遍存在的对象容器�Q�从而将“一对多”的关�p��{�?#8220;一对一”的关�p�，使得客户代码可以一致地处理对象和对象容器，无需兛_��处理的是单个的对象，�q�是�l�合的对象容器�?br style="margin: 0px; padding: 0px;" />      2�Q�将“客户代码与复杂的对象容器�l�构”解耦是Composite模式的核心思想�Q�解耦之后，客户代码��与�U��a(b��)的抽象接�?#8212;—而非对象容器的复内部实现�l�构——发生依赖关系�Q�从而更�?#8220;应对变化”�?br style="margin: 0px; padding: 0px;" />      3�Q�Composite模式中，是将“Add和Remove�{�和对象容器相关的方�?#8221;定义�?#8220;表示抽象对象的Component�c?#8221;中，�q�是��其定义�?#8220;表示对象容器的Composite�c?#8221;中，是一个关�?#8220;透明�?#8221;�?#8220;安全�?#8221;的两��N��题，需要仔�l�权衡。这里有可能�q�背面向对象�?#8220;单一职责原则”�Q�但是对于这�U�特�D�结构，�q�又是必��M��出的代�h(hu��n)。ASP.NET控�g的实现在�q�方面�ؓ(f��)我们提供了一个很好的�C��?br style="margin: 0px; padding: 0px;" />      4�Q�Composite模式在具体实��C��Q�可以让父对象中的子对象反向�q�溯�Q�如果父对象有频�J�的遍历需求，可��用缓存技巧来改善效率�?br style="margin: 0px; padding: 0px;" />

     参考资料：(x��)

      大化设计模式

     http://terrylee.cnblogs.com/archive/2006/03/11/347919.html

原帖地址�Q?br />
http://www.cnblogs.com/peida/archive/2008/09/09/1284686.html

Magic 2016-02-14 14:36 发表评论

久久精品人人槡人妻人人玩AV,1000部精品久久久久久久久,人人狠狠综合久久88成人

[转]C++与Java比较