组合模式(Composite)

简介

组合模式：将对象组合成树形结构以表示‘部分-整体’的层次结构。组合模式使得用户对单个对象和组合对象的使用具有一致性。组合模式可以让客户端像修改配置文件一样简单的完成本来需要流程控制语句来完成的功能。

书中实例

今天小菜在开发中可遇到大难题了。用户需求是这样：开发一套办公管理系统。公司有总部和分部，总部下属的各个部门，分部同样也具有。如果在设计系统组织结构时，采取平行管理会非常麻烦，因为实际开发中需要一个个的判断它是总部还是分部的哪个部门，然后再执行其相应的方法。这时大鸟又乱入了。小伙子！有这类问题的话就跟我学组合模式吧~

组合模式实现程序

    //公司类 抽象类或接口
    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);
        }
    }

    //客户端
    class Program
    {
        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);

            ConcreteCompany comp1 = new ConcreteCompany("南京办事处");
            comp1.Add(new HRDepartment("南京办事处人力资源部"));
            comp1.Add(new FinanceDepartment("南京办事处财务部"));
            comp.Add(comp1);

            ConcreteCompany comp2 = new ConcreteCompany("杭州办事处");
            comp2.Add(new HRDepartment("杭州办事处人力资源部"));
            comp2.Add(new FinanceDepartment("杭州办事处财务部"));
            comp.Add(comp2);

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

            Console.WriteLine("\n职责: ");
            root.LineOfDuty();

            Console.Read();

        }
    }

组成类图

关系介绍

组成类(Component)是枝节点类(Composite)和叶节点类(Leaf)的父类。组成类又和枝节点类是聚合关系，组成类拥有枝节点类。客户端与组成类之间是关联关系。

组合模式的构成

Component(组成类):为组合中的对象声明接口，在适当的情况下，实现所有类共有接口的默认行为。声明一个接口用以访问组成类的子部件。

Leaf(叶节点类):组成类的分支，叶节点没有子节点

Composite(枝节点类):组成类的分支，用来存储子部件，在组成类接口中实现与子部件有关的操作。

组合模式的优点

1.组合模式定义了基本对象和组合对象的类层次结构。基本对象可以被组合成更复杂的组合对象，而这个组合对象又可以不断被组合，递归下去，在客户代码中，任何用到基本对象的地方都可以使用组合对象了。

2.组合模式让客户可以一致地使用组合结构和单个对象。

使用场景

1.当需求中是体现部分与整体层次的结构时

2.当你希望用户可以忽略组合对象与单个对象的不同，统一地使用组合结构中的所有对象时