设计模式之组合模式

        我们在设计过程中会碰到类树的问题，比如一个类是树根，好多类是其子树，又有好多类是子树的子树，它们的关系分布就如同一棵树的关系。这时我们声明对象都以树根类来声明，那么我们操作所有整棵树所有对象都不需要进行类型转换，可以一视同仁。组合模式允许你将对象组合成树形结构来表现"整体/部分"层次结构。组合能让客户以一致的方式处理个别对象以及对象组合。使用了组合模式，我们可以忽略对象组合和个别对象之间的差别。

1.适用性与优缺点：

1.适用性：

a.表示对象的部分--整体结构

b.希望用户忽略组合对象与单个对象的不同，用户统一地使用结构中的所有对象

2.优点：

a.可以清楚地定义分层次的复杂对象，表示对象的全部或部分层次，使得增加新构件更容易，因为都是由类中根类决定所有对象类型。

b.用户调用简单。

c.更容易在组合体内加入对象构件，客户端不必更改代码。

3.缺点：

a.使设计更加抽象，如果对象业务规则很复杂，实现组合模式比较困难。

c.如果形成的类树比较层次结构比较复杂，对于访问子叶等类的对象会比较困难，迭代层次太多。

2.示例讲解

        本文讲解的关于组合模式的示例，是关于一个公司常见的职位体系问题。一般一个大boss会带几个小boss，每个小boss会带几个小组长秘书之类的。一般公司职位体系一般都是有层次的，分布如同一棵树一般。因此，我们采用组合模式，将所有对象都声明为大boss类型的，那么访问所有对象都是无差别的。

首先，声明一个抽象类，叫做职员类，会实现一些公共方法，如果有差异的方法，则到具体职位中实现：

package composite;
import java.util.*;
public abstract class Employer {

	private String name;
    
    public void setName(String name) {
        this.name = name;
    }
    
    public String getName() {
        return this.name;
    }
    
    public abstract void add(Employer employer);
    
    public abstract void delete(Employer employer);
    
    public List<Employer> employers;
    
    public void printInfo() {
        System.out.println(name);
    }
    
    public List<Employer> getEmployers() {
        return this.employers;
    }
}

        上面抽象类声明了一个List<Employer>employers，这是用来放自己的属下的，每个职员都有这样一个成员变量，如果有属下，则把属下对象放进集合中，如果没属下则该集合为null。

        以下便是对各个职位的实现，首先来个大boss，项目经理：

package composite;
import java.util.*;
public class ProjectManager extends Employer {

	public ProjectManager(String name) {
		// TODO Auto-generated constructor stub
		setName(name);
        employers = new ArrayList();

	}

	@Override
	public void add(Employer employer) {
		// TODO Auto-generated method stub
		employers.add(employer);

	}

	@Override
	public void delete(Employer employer) {
		// TODO Auto-generated method stub
		employers.remove(employer);

	}

}

        项目经理类，初始化了自己职位名字，以及安放属下的集合。同时还实现了两个集合操作的方法，传入的函数都是Employer类型的(树的根部)。以下出现小boss，一个是项目助理，一个是程序员。

package composite;
import java.util.*;
public class ProjectAssistant extends Employer {

	public ProjectAssistant(String name) {
		// TODO Auto-generated constructor stub
		setName(name);
        employers = new ArrayList();

	}

	@Override
	public void add(Employer employer) {
		// TODO Auto-generated method stub
		employers.add(employer);
		

	}

	@Override
	public void delete(Employer employer) {
		// TODO Auto-generated method stub
		employers.remove(employers);

	}

}

package composite;
import java.util.*;
public class Programmer extends Employer {

	public Programmer(String name) {
		// TODO Auto-generated constructor stub
		setName(name);
        employers = new ArrayList();

	}

	@Override
	public void add(Employer employer) {
		// TODO Auto-generated method stub
		employers.add(employer);

	}

	@Override
	public void delete(Employer employer) {
		// TODO Auto-generated method stub
		employers.remove(employer);

	}

}

        上面两个类代表的职位是项目经理的直接属下，而这两个职位都还有自己的直接属下，所以他们的集合不为null。接下来介绍程序员的直接属下，程序员助理：

package composite;

public class ProgrammerAssistant extends Employer {

	public ProgrammerAssistant(String name) {
		// TODO Auto-generated constructor stub
		setName(name);
		employers=null;
	}

	@Override
	public void add(Employer employer) {
		// TODO Auto-generated method stub

	}

	@Override
	public void delete(Employer employer) {
		// TODO Auto-generated method stub

	}

}

项目助理直接属下，助理秘书：

package composite;

public class AssistantSecretary extends Employer {

	public AssistantSecretary(String name) {
		// TODO Auto-generated constructor stub
		setName(name);
		employers=null;
	}

	@Override
	public void add(Employer employer) {
		// TODO Auto-generated method stub

	}

	@Override
	public void delete(Employer employer) {
		// TODO Auto-generated method stub

	}

}

        程序员助理和助理秘书都没有直接属下了，所以集合都为null。接下来我们对所有类进行测试，构建职位体系：

package composite;
import java.util.*;
public class Test {

    public static void main(String[] args) {
        Employer pm = new ProjectManager("项目经理");
        Employer pa = new ProjectAssistant("项目助理");
        Employer programmer1 = new Programmer("程序员一");
        Employer programmer2 = new Programmer("程序员二");
        Employer pra = new Programmer("程序员助理");
        Employer as=new AssistantSecretary("助理秘书");
        
        pm.add(pa);//为项目经理添加项目助理
        pa.add(as);
        pm.add(programmer2);//为项目经理添加程序员
        programmer2.add(pra);
        
        List<Employer> ems = pm.getEmployers();
        System.out.println(pm.getName());
        for(Employer em:ems)
		{
        	List<Employer> em1 = em.getEmployers();
        	if(em1==null)
        	{
        		System.out.println(" -"+em.getName());
        	}
        	else
        	{
        		System.out.println(" -"+em.getName());
        		for(Employer ee:em1)
        		{
        			System.out.println("  "+"--"+ee.getName());
        		}
        	}
		}
    }
}

        运行代码，结果如下：

项目经理
 -项目助理
  --助理秘书
 -程序员二
  --程序员助理

        从上面结果可以看出几个职位的层次关系，正是利用了组合模式，使得操作过程中，无须进行类型转换，因为所有的职位的类都是继承抽象类Employer的，所以所有职位的对象都应一视同仁的。这也体现了组合模式的层次性以及一致性。