《大话设计模式》--分公司=一部门--组合模式<Composite>(19)

整体与部分可以被一致对待。

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

透明方式：也就是说Component中声明所有用来管理子对象的方法，其中包括Add、Remove等。这样实现Component接口的所有子类都具备了Add和Remove。这样做的好处就是叶节点和枝节点对于外界没有区别，它们具备完全一致的行为接口。但问题也很明显，因为Leaf类本身不具备Add()，Remove()方法的功能，所以实现它是没有意义的。

安全方式：也就是Component接口中不去声明Add和Remove方法，那么子类的Leaf也就不需要去实现它，而是在Composite声明所有用来管理子类对象的方法，不过由于不够透明，所以树叶和树枝类将不具有相同的接口，客户端的调用需要做相应的判断，带来了不便。

When use?

需求中体现部分与整体层次的结构时，希望用户可以忽略组合对象与单个对象的不同，统一地使用组合结构中的所有对象时，就应该考虑用组合模式了。

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 deepth);
        public abstract void LineOfDuty();
    }

 

class FinancialDepartment:Company
    {
        public FinancialDepartment(string name)
            : base(name)
        { }

        public override void Add(Company c)
        {
            
        }

        public override void Remove(Company c)
        {
            
        }

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

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

 

class HumanResourcesDepartment:Company
    {
        public HumanResourcesDepartment(string name)
            : base(name)
        { }

        public override void Add(Company c)
        {
            
        }

        public override void Remove(Company c)
        {
            
        }

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

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

 

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 deepth)
        {
            Console.WriteLine(new String('-', deepth) + name);
            foreach (Company c in children)
            {
                c.Display(deepth + 2);
            }
        }

        public override void LineOfDuty()
        {
            foreach (Company c in children)
            {
                c.LineOfDuty();
            }
        }
    }

 

            ConcreteCompany cc = new ConcreteCompany("北京总公司");
            cc.Add(new FinancialDepartment("总公司财务部"));
            cc.Add(new HumanResourcesDepartment("总公司人力资源部"));

            ConcreteCompany cc1 = new ConcreteCompany("上海华东分公司");
            cc1.Add(new FinancialDepartment("华东分公司财务部"));
            cc1.Add(new HumanResourcesDepartment("华东分公司人力资源部"));
            cc.Add(cc1);

            ConcreteCompany cc2 = new ConcreteCompany("南方办事处");
            cc2.Add(new FinancialDepartment("南方办事处财务部"));
            cc2.Add(new HumanResourcesDepartment("南方办事处人力资源部"));
            cc.Add(cc2);

            ConcreteCompany cc3 = new ConcreteCompany("杭州办事处");
            cc3.Add(new FinancialDepartment("杭州办事处财务部"));
            cc3.Add(new HumanResourcesDepartment("杭州办事处人力资源部"));
            cc.Add(cc3);

            Console.WriteLine("\n结构图");
            cc.Display(1);

            Console.WriteLine("\n职责：");
            cc.LineOfDuty();

好处：基本对象可以被组合成更复杂的组合对象，而这个组合对象又可以被组合，这样不断地递归下去，客户代码中，任何用到基本对象的地方都可以使用组合对象了。

用户是不用关心到底是处理一个叶节点还是处理一个组合组件，也就是用不着为定义组合而写一些选择判断语句了。组合模式让客户可以一致的使用组合结构和单个对象。