Composite（组合模式）

Composite模式，有时候又叫做部分-整体模式，是将对象组合成树形结构以表示“部分-整体”的层次结构，使得用户对单个对象和组合对象的使用具有一致性。

应用场景

组合模式让你可以优化处理递归或分级数据结构。有许多关于分级数据结构的例子，使得组合模式非常有用武之地。关于分级数据结构的一个普遍性的例子是你每次使用电脑时所遇到的文件系统。文件系统由目录和文件组成。每个目录都可以装内容。目录的内容可以是文件，也可以是目录。按照这种方式，计算机的文件系统就是以递归结构来组织的。如果你想要描述这样的数据结构，那么你可以使用组合模式Composite。

模式结构

组合模式的分类

组合模式的实现根据所实现接口的区别分为两种形式，分别称为安全模式和透明模式。组合模式可以不提供父对象的管理方法，但组合模式必须在合适的地方提供子对象的管理方法（诸如：add、remove、getChild等）。

1)   透明方式：将管理子元素的方法定义在Component接口中，这样Leaf类就需要对这些方法空实现。

·        抽象构件（Component）角色：这是一个抽象角色，它给参加组合的对象规定一个接口，规范共有的接口及默认行为。

·        树叶构件（Leaf）角色：代表参加组合的树叶对象，定义出参加组合的原始对象的行为。树叶类会给出add（）、remove（）以及getChild（）之类的用来管理子类对对象的方法的平庸实现。

·        树枝构件（Composite）角色：代表参加组合的有子对象的对象，定义出这样的对象的行为。

作为第一种选择，在Component里面声明所有的用来管理子类对象的方法，包括add（）、remove（），以及getChild（）方法。这样做的好处是所有的构件类都有相同的接口。在客户端看来，树叶类对象与合成类对象的区别起码在接口层次上消失了，客户端可以同等的对待所有的对象。这就是透明形式的合成模式。

这个选择的缺点是不够安全，因为树叶类对象和合成类对象在本质上是有区别的。树叶类对象不可能有下一个层次的对象，因此add（）、remove（）以及getChild（）方法没有意义，是在编译时期不会出错，而只会在运行时期才会出错。

2)   安全方式：将管理子元素的方法定义在composite类中

这种形式涉及到三个角色：

·        抽象构件(Component)角色：这是一个抽象角色，它给参加组合的对象定义出公共的接口及其默认行为，可以用来管理所有的子对象。在安全式的合成模式里，构件角色并不是定义出管理子对象的方法，这一定义由树枝构件对象给出。

·        树叶构件（Leaf）角色：树叶对象是没有下级子对象的对象，定义出参加组合的原始对象的行为。

·        树枝构件（Composite）角色：代表参加组合的有下级子对象的对象。树枝对象给出所有的管理子对象的方法，如add（）、remove（）、getChild（）等。

第二种选择是在Composite类里面声明所有的用来管理子类对象的方法。这样的做法是安全的做法，因为树叶类型的对象根本就没有管理子类对象的方法，因此，如果客户端对树叶类对象使用这些方法时，程序会在编译时期出错。

这个选择的缺点是不够透明，因为树叶类和合成类将具有不同的接口。

这两个形式各有优缺点，需要根据软件的具体情况做出取舍决定。

代码实现

1.      透明式

 

// Composite pattern -- Author:rocket5725@163.com
using System;
using System.Text;
using System.Collections;

// "Component"
abstract class Component
{
    // Fields
    protected string name;

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

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

// "Composite"
class Composite : Component
{
    // Fields
    private ArrayList children = new ArrayList();

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

    // Methods
    public override void Add(Component component)
    { children.Add(component); }

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

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

        // Display each of the node's children
        foreach (Component component in children)
            component.Display(depth + 2);
    }
}

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

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

/**/
/// <summary>
/// Client test
/// </summary>
public class Client
{
    public static void Main(string[] args)
    {
        // Create a tree structure
        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);

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

        // Add and remove a leaf
        Leaf l = new Leaf("Leaf D");
        root.Add(l);
        root.Remove(l);

        // Recursively display nodes
        root.Display(1);
        Console.Read();
    }
}

2、安全式

 

// Composite pattern -- author:rocket5725@163.com
using System;
using System.Text;
using System.Collections;

// "Component"
abstract class Component
{
    // Fields
    protected string name;

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

    // Operation
    public abstract void Display(int depth);
}

// "Composite"
class Composite : Component
{
    // Fields
    private ArrayList children = new ArrayList();

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

    // Methods
    public void Add(Component component)
    {
        children.Add(component);
    }
    public void Remove(Component component)
    {
        children.Remove(component);
    }
    public override void Display(int depth)
    {
        Console.WriteLine(new String('-', depth) + name);

        // Display each of the node's children
        foreach (Component component in children)
            component.Display(depth + 2);
    }
}

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

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

/**/
/// <summary>
/// Client test
/// </summary>
public class Client
{
    public static void Main(string[] args)
    {
        // Create a tree structure
        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);

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

        // Add and remove a leaf
        Leaf l = new Leaf("Leaf D");
        root.Add(l);
        root.Remove(l);

        // Recursively display nodes
        root.Display(1);
        Console.Read();
    }
}

 

3 应用实例

package design.composite;
/**
 * 文件名称：design.composite.Company.java
 *  创建人：Fei Wong 
 *  创建时间： 2012-06-26
 * 电子邮箱：feiwong8@126.com 
 * 
 */
public abstract class Company {
	private String name;

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

	public Company() {
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	protected abstract void add(Company company);

	protected abstract void romove(Company company);

	protected abstract void display(int depth);
}




package design.composite;

import java.util.ArrayList;
import java.util.List;
/**
 * 文件名称：design.singleton.CommandInvoker.java
 *  创建人：Fei Wong 
 *  创建时间： 2012-06-26
 * 电子邮箱：feiwong8@126.com 
 * 
 */
public class ConcreteCompany extends Company {
	private List<Company> cList;

	public ConcreteCompany() {
		cList = new ArrayList<Company>();
	}

	public ConcreteCompany(String name) {
		super(name); 
		cList = new ArrayList<Company>() ; 
	}

	@Override
	protected void add(Company company) {
		cList.add(company);
	}

	@Override
	protected void display(int depth) {
		// TODO Auto-generated method stub
		StringBuilder sb = new StringBuilder("");
		for (int i = 0; i < depth; i++) {
			sb.append("-"); 
		}
		System.out.println(new String(sb) + this.getName());
		for (Company c : cList) {
			c.display(depth + 2);
		}
	}

	@Override
	protected void romove(Company company) {
		cList.remove(company);
	}
}



package design.composite;
/**
 * 文件名称：design.composite.FinanceDepartment.java
 *  创建人：Fei Wong 
 *  创建时间： 2012-06-26
 * 电子邮箱：feiwong8@126.com
 */
public class FinanceDepartment extends Company {
	
	
	public FinanceDepartment(){
		
	}
	
	public FinanceDepartment(String name){
		super(name);
	}
	
	@Override
	protected void add(Company company) {

	}

	@Override
	protected void display(int depth) {
		StringBuilder sb = new StringBuilder("");
		for (int i = 0; i < depth; i++) {
			sb.append("-");
		}
		System.out.println(new String(sb) + this.getName() ) ; 
	}

	@Override
	protected void romove(Company company) {
		
	}
	
}




package design.composite;
/**
 * 文件名称：design.composite.HRDepartment.java
 *  创建人：Fei Wong 
 *  创建时间： 2012-06-26
 * 电子邮箱：feiwong8@126.com
 */
public class HRDepartment extends Company {
	
	
	public HRDepartment(){
		
	}
	
	public HRDepartment(String name){
		super(name);
	}
	
	@Override
	protected void add(Company company) {

	}

	@Override
	protected void display(int depth) {
		StringBuilder sb = new StringBuilder("");
		for (int i = 0; i < depth; i++) {
			sb.append("-"); 
		}
		System.out.println(new String(sb) + this.getName() ) ; 
	}

	@Override
	protected void romove(Company company) {
		
	}
	
}




package design.composite;

public class Client {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Company root = new ConcreteCompany();
		root.setName("北京总公司");
		root.add(new HRDepartment("总公司人力资源部"));
		root.add(new FinanceDepartment("总公司财务部"));
		Company shandongCom = new ConcreteCompany("山东分公司");
		shandongCom.add(new HRDepartment("山东分公司人力资源部"));
		shandongCom.add(new FinanceDepartment("山东分公司账务部"));
		Company zaozhuangCom = new ConcreteCompany("枣庄办事处");
		zaozhuangCom.add(new FinanceDepartment("枣庄办事处财务部"));
		zaozhuangCom.add(new HRDepartment("枣庄办事处人力资源部"));
		Company jinanCom = new ConcreteCompany("济南办事处");
		jinanCom.add(new FinanceDepartment("济南办事处财务部"));
		jinanCom.add(new HRDepartment("济南办事处人力资源部")); 
		shandongCom.add(jinanCom);
		shandongCom.add(zaozhuangCom);
		Company huadongCom = new ConcreteCompany("上海华东分公司");
		huadongCom.add(new HRDepartment("上海华东分公司人力资源部"));
		huadongCom.add(new FinanceDepartment("上海华东分公司账务部"));
		Company hangzhouCom = new ConcreteCompany("杭州办事处");
		hangzhouCom.add(new FinanceDepartment("杭州办事处财务部"));
		hangzhouCom.add(new HRDepartment("杭州办事处人力资源部"));
		Company nanjingCom = new ConcreteCompany("南京办事处");
		nanjingCom.add(new FinanceDepartment("南京办事处财务部"));
		nanjingCom.add(new HRDepartment("南京办事处人力资源部"));
		huadongCom.add(hangzhouCom);
		huadongCom.add(nanjingCom); 
		root.add(shandongCom);
		root.add(huadongCom);
		root.display(0);
	}

}