本文共 2643 字，大约阅读时间需要 8 分钟。

组合模式，顾名思义，采用了组合的方式，使得简单的对象可以组合成复杂的对象，同时保证了简单对象和复杂对象使用上的一致性。这是一种典型的has- a 关系。用过组合 使得简单对象成为了复杂对象的一部分，而在使用上，简单对象和复杂对象又是一致的。 组合模式类图： [img]http://dl.iteye.com/upload/attachment/364541/b7cdc2de-4278-36e1-9acf-030e2091033d.jpg[/img] 具体实例demo: 抽象对象：

package compositePattern; import java.util.ArrayList; import java.util.List; public abstract class Person {
  	protected List
   
     personList; 	protected String name; 	public abstract void work(); 	public  Person(List
    
      personList,String name){
  		this.personList = personList; 		this.name = name; 	} 	public abstract void add(Person person); 	public abstract void remove(Person person); 	public abstract List
     
       getShouXia(); 	public void setName(String name) {
  		this.name = name; 	} 	public String getName() {
  		return name; 	} }
     
    
   

具体对象类：

package compositePattern; import java.util.List; public class Coder extends Person{
  	public Coder(List
   
     personList,String name) {
  		super(personList, name); 		// TODO Auto-generated constructor stub 	} 	@Override 	public void work() {
  		System.out.println("miserable coder"); 	} 	public void add(Person person){
  	} 	public void remove(Person person){
  	} 	public List
    
      getShouXia(){
  		return null; 	} }
    
   

具体对象类2：

package compositePattern; import java.util.List; public class LaoDa extends Person{
  	public LaoDa(List
   
     personList,String name) {
  		super(personList, name); 		// TODO Auto-generated constructor stub 	} 	@Override 	public void work() {
  		// TODO Auto-generated method stub 	} 	public void add(Person person){
  		personList.add(person);	 	} 	public void remove(Person person){
  		personList.remove(person);	 	} 	public List
    
      getShouXia(){
  		return personList; 	} }
    
   

测试类：

package compositePattern; import java.util.ArrayList; public class CompositePatternTest {
  	public static void main(String[]args){
  		int  deep = 0; 		LaoDa[] laodas =new LaoDa[2]; 		for(int i=0;i<2;i++){
  			 laodas[i] = new LaoDa(new ArrayList
   
    (),i+"号老大"); 		} 		Coder[] coders =new Coder[6]; 		for(int j=0;j<6;j++){
  			coders[j] = new Coder(null,j+"号码农"); 		} 		for(int i =0;i<2;i++){
  			laodas[i].add(coders[i]); 			laodas[i].add(coders[i+2]); 			laodas[i].add(coders[i+4]); 		} 		laodas[0].add(laodas[1]); 		show(laodas[0],0); 	} 	public static void show(Person p ,int deep){
  		for(int i=0;i<=deep-1;i++) 			System.out.print("---"); 		System.out.println(p.getName()); 		if(p.personList!=null &&p.personList.size()>0) 			for(Person person : p.personList) 				show( person ,deep+1); 	} }
   

说明;简单对象类对一些非自己的功能可以将抽象对象功能空实现，这样既保证了简单对性爱那个和复杂对象类的一致性，又保证了各自功能的相对区别。

转载地址：https://blog.csdn.net/iteye_2655/article/details/81970374 如侵犯您的版权，请留言回复原文章的地址，我们会给您删除此文章，给您带来不便请您谅解！