大话设计模式－第19章 分公司=一部分--组合模式

第19章
分公司=一部分--组合模式

19.1 分公司不就是以部门吗？

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

19.2 组合模式

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

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

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

}

Leaf在组合中表示叶节点对象，叶结点没有子节点。

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(Component c)

    {

        Console.WriteLine(new String(‘-‘.depth) + name);

    }

}

Composite 定义有枝节点行为，用来存储子部件，在Component接口中实现与子部件有关的操作，比如增加Add和删除Remove。

class Composite : Component

{

    //一个子对象集合用来存储其下属的枝节点和叶节点

    private List<Component> children = new List<Component>();

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

        }

    }

}

客户端代码，能通过Component接口操作组合部件的对象。

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

    com.Add(comp2);

    root.Add(new Leaf(“Leaf C”));

    Leaf leaf = new Leaf(“Leaf D”);

    root.Add(leaf);

    root.Romove(leaf);

    root.Display(1);

    Console.Read();

}

19.3 透明方式与安全方式

    “�可能有无数的分枝，但只需要反复用Composite就可以实现树状结构了。小菜感觉如何？”

    “有点懂，但还是有点疑问，为什么Leaf类当中也有Add和Remove，树叶不是不可以再长出分枝吗？”

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

    “哦，那么如果我不希望做这样的无用功呢？也就是Leaf类当中不用Add和Remove方法，可以吗？”

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

19.4 何时使用组合模式

    “什么地方用组合模式比较好呢？”

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

19.5 公司管理系统

公司类 抽象类或接口

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

    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.LineDuty();

    Console.Read();

}

19.6 组合模式好处

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

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