组合模式

在之前有接触过组合模式，那是第一次接触设计模式，觉得什么是组合模式啊？什么部分与整体。现在再来看组合模式，觉得实际上并没有那么神秘。

组合模式：将对象组合成树形结构以表示“部分-整体”的层次结构。组合模式使得用户对单个对象和组合对象的使用具有一致性。这句话什么意思呢？凡是能类似树形结构的场景，均可使用组合模式来实现。对组合对象和单个对象抽象为一个公共类，这样就使得对它们的使用一致了。

组合模式的UML类图结构：

任何复杂的代码其基本结构都是简单的，把简单的灵活应用组合起来就变得不简单。

公共抽象类Component：

 1 package day_8_composite;
 2 
 3 /**
 4  * 所有类共用接口的默认方法
 5  * @author turbo
 6  *
 7  * 2016年9月11日
 8  */
 9 public abstract class Component {
10     private String name;
11     
12     public Component(String name){
13         this.name = name;
14     }
15     
16     public String getName() {
17         return name;
18     }
19     public void setName(String name) {
20         this.name = name;
21     }
22     
23     public abstract void add(Component c);
24     public abstract void remove(Component c);
25     
26     /**
27      * 这里用来显示结构关系，可再抽象一个方法，每个实现子类具体实现
28      * @param c
29      */
30     public abstract void display();
31 }

组件类：

 1 package day_8_composite;
 2 
 3 /**
 4  * 组件类。即叶节点，不具体实现add和remove方法。
 5  * @author turbo
 6  *
 7  * 2016年9月11日
 8  */
 9 public class Leaf extends Component {
10 
11     /**
12      * @param name
13      */
14     public Leaf(String name) {
15         super(name);
16     }
17 
18     /* (non-Javadoc)
19      * @see day_8_composite.Component#add(day_8_composite.Component)
20      */
21     @Override
22     public void add(Component c) {
23         // TODO Auto-generated method stub
24 
25     }
26 
27     /* (non-Javadoc)
28      * @see day_8_composite.Component#remove(day_8_composite.Component)
29      */
30     @Override
31     public void remove(Component c) {
32         // TODO Auto-generated method stub
33 
34     }
35 
36     /* (non-Javadoc)
37      * @see day_8_composite.Component#display(day_8_composite.Component)
38      */
39     @Override
40     public void display() {
41         System.out.println(super.getName());
42     }
43 
44 }

组合类，注意其中有一个list，为什么有list，仔细思考。

 1 package day_8_composite;
 2 
 3 import java.util.ArrayList;
 4 import java.util.List;
 5 
 6 /**
 7  * 组合类
 8  * @author turbo
 9  *
10  * 2016年9月11日
11  */
12 public class Composite extends Component {
13     
14     /**
15      * @param name
16      */
17     public Composite(String name) {
18         super(name);
19     }
20 
21     private List<Component> list = new ArrayList<Component>();
22     
23     /* (non-Javadoc)
24      * @see day_8_composite.Component#add(day_8_composite.Component)
25      */
26     @Override
27     public void add(Component c) {
28         list.add(c);
29     }
30 
31     /* (non-Javadoc)
32      * @see day_8_composite.Component#remove(day_8_composite.Component)
33      */
34     @Override
35     public void remove(Component c) {
36         list.remove(c);
37     }
38 
39     /* (non-Javadoc)
40      * @see day_8_composite.Component#display(int)
41      */
42     @Override
43     public void display() {
44         System.out.println(super.getName());
45         for (Component c : list){
46             c.display();
47         }
48     }
49 
50 }

客户端测试代码：

 1 package day_8_composite;
 2 
 3 /**
 4  * 客户端测试代码
 5  * @author turbo
 6  *
 7  * 2016年9月11日
 8  */
 9 public class Main {
10 
11     /**
12      * @param args
13      */
14     public static void main(String[] args) {
15         Composite root = new Composite("根节点");
16         /*构造左节点，右分支*/
17         Leaf leftLeaf = new Leaf("左节点");
18         Composite rightBranch = new Composite("右分支");
19         /*将左右节点分支挂到根节点*/
20         root.add(leftLeaf);
21         root.add(rightBranch);
22         /*为右分支添加节点*/
23         Leaf leaf1 = new Leaf("右-子节点1");
24         Leaf leaf2 = new Leaf("右-子节点2");
25         /*将节点挂到右分支上*/
26         rightBranch.add(leaf1);
27         rightBranch.add(leaf2);
28         
29         root.display();
30     }
31 
32 }

现在我们就实现了一个最基本的组合模式，上面说过，复杂的代码其实质就是灵活应用最简单的代码。虽然这里我们实现了组合模式，也看懂了组合模式，但离真正应用还有一段路要走，我之所以想要学这些设计模式并且写出来，实际上是在为阅读开源代码做准备，阅读开源框架的代码是很好的学习方式。无奈每次打开源代码都被各种各样“复杂”的接口、抽象类、实现类给绕晕，只好草草收场。与其说写的“复杂”，我想用写的好来形容更恰当，之所以看不懂是因为基础太弱。有了扎实的基础，才能走得更远。