组合模式

举个例子：

总公司有A部门和B部门。现在总公司有多个分公司，当然，这几个分公司也有A部门和B部门。

现在的做法是为每一个分公司都用相同的代码，都是一个代码复制过来的。当然，这种方法不可取，有如下两个缺点：

1、这种做法明显违背了面向对象的原则，如果一行代码出现了问题，那就需要所有的公司都要修改代码，很麻烦。

2、没有等级划分，总公司的位置应该高于分公司，这些公司是有一定的组织结构的，不能进行平行管理。

所以就出现了一个设计模式——组合模式

总公司的A部门和B部门的功能复用于分公司，在处理总公司的A部门和B部门的功能和处理分公司的方法是一样的。也就是整体和部分可以被一致对待。

组合模式依据树形结构来组合对象，用来表示部分以及整体层次。

组合模式里面提到了枝和叶，在上面这个例子当中，分公司就相当于总公司的枝，而那些A部门和B部门就相当于叶。枝和叶都继承于总公司。

 具体代码如下：

总公司类：为分公司和部门提供了统一的一个接口

 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);
        public abstract void Display(int depth);
        public abstract void LineOfDuty();//不同的部门需要履行不同的职责
    }

具体公司类，使用总公司的接口：（相当于枝。在这里面放了一个泛型，用于存放分公司或者部门，可以定义添加或者移除的方法。）

class ConcreteCompany : Company//具体公司类
    {
        private List<Company> children = new List<Company>();
        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();
            }
        }
    }

具体部门类，使用总公司的接口：（相当于叶。最底层的部门，没有再继续添加部门的功能，所以没有泛型用来添加。）

 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);
        }
    }
     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);
        }

    }

客户端代码：

static void Main(string[] args)
        {
            ConcreteCompany root = new ConcreteCompany("北京总公司");
            root.Add(new HRDepartment("总公司人力资源部"));
            root.Add(new FinanceDepartment("总公司财务部"));

            ConcreteCompany comp = new ConcreteCompany("上海华东分公司");
            comp.Add(new HRDepartment("华东分公司人力资源部"));
            comp.Add(new FinanceDepartment("华东分公司财务部"));
            root.Add(comp);

            Console.WriteLine("结构图如下：");
            root.Display(1);

            Console.WriteLine("职责如下：");
            root.LineOfDuty();
            Console.ReadKey();
        }

简单分析：

1、在客户端实例化一个总公司，起名为“root”。然后总公司下面有两个部门：总公司人力资源部和总公司财务部。将这两个部门添加到总公司下面。先走括号里面的代码，也就是 new后面的，然后走括号外面的代码，也就是将两个部门添加到泛型当中。

2、“上海华东分公司”也是一样的道理，至于最后一句代码：“root.Add(comp)”的意思是将分公司加到总公司的泛型里面。

3、“root.Display(1)”这行代码因为首先传入的是北京总公司，又因为“depth”为1，所以“北京总公司”前面只有一个“-”，走到下一个的时候“depth”就变成了3，所以“总公司人力资源部”前面就会有3个“-”。具体看如下代码：

public override void Display(int depth)
        {
            Console.WriteLine(new String('-', depth) + name);
            foreach (Company component in children)
            {
                component.Display(depth + 2);
            }
        }

4、添加分公司的道理也是如此，是将分公司添加到了总公司下面，和总公司的部门是平级的。