组合模式

一、组合模式简介（Brief Introduction）

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

 

二、解决的问题（What To Solve）

解决整合与部分可以被一致对待问题。

三、组合模式分析（Analysis）

1、组合模式结构

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

Leaf类：叶节点对象，叶节点没有子节点。由于叶节点不能增加分支和树叶，所以叶节点的Add和Remove没有实际意义。

有叶节点行为，用来存储叶节点集合

Composite类：实现Componet的相关操作，比如Add和Remove操作。

children:用来存储叶节点集合

 

//Component.java

package Composit;

public abstract class Component
{
 protected String name;

 Component(String name){
  this.name=name;
 }
 public void add(Component component)
 {
  throw new UnsupportedOperationException();
 }

 public void remove(Component component)
 {
  throw new UnsupportedOperationException();
 }

 public Component getChild(int i)
 {
  throw new UnsupportedOperationException();
 }

 public void operation()
 {
  throw new UnsupportedOperationException();
 }
 public void display(int depth)
 {
  throw new UnsupportedOperationException();
 }
}

 

//Composit.java

package Composit;

import java.util.ArrayList;

public class Composite extends Component
{
 Composite(String name) {
  super(name);
  // TODO Auto-generated constructor stub
 }

 ArrayList<Component> components = new ArrayList<Component>();
 
 @Override
 public void add(Component component)
 {
  components.add(component);
 }
 
 @Override
 public void remove(Component component)
 {
  components.remove(component);
 }
 
 @Override
 public Component getChild(int i)
 {
  return components.get(i);
 }
 
 @Override
 public void operation()
 {
  for (Component component : components)
  {
   component.operation();
  }
 }
 @Override
    public void display(int depth)
    {
        System.out.println(depth+'-'+name);

    }
}

 

//Leaf.java

package Composit;

public class Leaf extends Component
{
  String name;
  public Leaf(String name){
    super(name);
    this.name=name;
    System.out.println("新树叶");
  }
 
 @Override
 public void operation()
 {
  //your code
  System.out.println(name);
 }
 
 @Override
 public void add(Component c)
    {
  System.out.println("不能向叶子节点添加子节点");

    }

 @Override
    public void remove(Component c)
    {
        System.out.println("叶子节点没有子节点");

    }
 
 @Override
    public void display(int depth)
    {
        System.out.println(depth+'-'+name);

    }

}

 

 

//CompositTest.java

package Composit;

public class CompositTest {

 /**
  * @param args
  */
 public static void main(String[] args) {
  Composite root = new Composite("根节点root");
     root.add(new Leaf("根上生出的叶子A"));
     System.out.println("根上生出的叶子A");
     root.add(new Leaf("根上生出的叶子B"));

 

     Composite comp = new Composite("根上生出的分支CompositeX");
     comp.add(new Leaf("分支CompositeX生出的叶子LeafXA"));
     comp.add(new Leaf("分支CompositeX生出的叶子LeafXB"));
     root.add(comp);

 

     Composite comp2 = new Composite("分支CompositeX生出的分支CompositeXY");
     comp2.add(new Leaf("分支CompositeXY生出叶子LeafXYA"));
     comp2.add(new Leaf("分支CompositeXY生出叶子LeafXYB"));

     comp.add(comp2);
     root.add(new Leaf("根节点生成的叶子LeafC"));
     Leaf leafD = new Leaf("leaf D");
     root.add(leafD);
     root.remove(leafD);
     root.display(1);
    
     root.operation();
 }

}

 

适用性：

以下情况使用Composite模式:

1. 你想表示对象的部分-整体层次结构。

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

 

优点：

1. 组合模式可以很容易的增加新的构件。

2. 使用组合模式可以使客户端变的很容易设计，因为客户端可以对组合和叶节点一视同仁。

缺点：

1. 使用组合模式后，控制树枝构件的类型不太容易。

2. 用继承的方法来增加新的行为很困难。