【设计模式】8、组合模式

 

 

 1 package com.shejimoshi.structural.Composite.type1;
 2 
 3 
 4 /**
 5  * 功能：将对象组合成树形结构以表示“部分-整体”的层次结构。composite使得用户对单个对象和组合对象的使用具有一致性
 6  * 适用：想表示对象的部分-整体层次结构
 7  *         希望用户忽略组合对象与单个对象的不同，用户将统一地使用组合结构中的所有对象
 8  * 时间：2016年2月20日下午8:57:12
 9  * 作者：cutter_point
10  */
11 public abstract class Componment
12 {
13     protected String name;    //名字
14     
15     public Componment(String name)
16     {
17         this.name = name;
18     }
19     
20     //几个基本的方法，叶子节点和枝节点都需要的，叶子节点没有子节点
21     public abstract void add(Componment c);
22     public abstract void remove(Componment c);
23     public abstract void display(int depth);    //当前的深度
24 }

这里再display的时候，有部分代码很重复，我觉得麻烦，我就在封装了一个方法

 1 package com.shejimoshi.structural.Composite.type1;
 2 
 3 
 4 /**
 5  * 功能：工具类
 6  * 时间：2016年2月20日下午9:12:54
 7  * 作者：cutter_point
 8  */
 9 public class myutil
10 {
11     public static StringBuffer show(int depth)
12     {
13         //显示名称和深度就可以了
14         StringBuffer sb = new StringBuffer();
15         for(int i = 0; i < depth; ++i)
16             sb.append("-");
17         
18         return sb;
19     }
20 }

 

叶子

 1 package com.shejimoshi.structural.Composite.type1;
 2 
 3 
 4 /**
 5  * 功能：将对象组合成树形结构以表示“部分-整体”的层次结构。composite使得用户对单个对象和组合对象的使用具有一致性
 6  * 适用：想表示对象的部分-整体层次结构
 7  *         希望用户忽略组合对象与单个对象的不同，用户将统一地使用组合结构中的所有对象
 8  * 时间：2016年2月20日下午9:02:24
 9  * 作者：cutter_point
10  */
11 public class Leaf extends Componment
12 {
13 
14     public Leaf(String name)
15     {
16         super(name);
17     }
18 
19     @Override
20     public void add(Componment c)
21     {
22         //叶子是没有子类的，他是叶子，所以添加和移除没有意义
23         System.out.println("添加错误，叶子节点");
24     }
25 
26     @Override
27     public void remove(Componment c)
28     {
29         //叶子是没有子类的，他是叶子，所以添加和移除没有意义
30         System.out.println("删除错误，叶子节点");
31     }
32 
33     @Override
34     public void display(int depth)
35     {
36         //显示名称和深度就可以了
37         StringBuffer sb = myutil.show(depth);
38         sb.append(this.name);
39         System.out.println(sb.toString());
40     }
41 
42 }

 

分支节点

 1 package com.shejimoshi.structural.Composite.type1;
 2 
 3 import java.util.ArrayList;
 4 import java.util.List;
 5 
 6 
 7 /**
 8  * 功能：将对象组合成树形结构以表示“部分-整体”的层次结构。composite使得用户对单个对象和组合对象的使用具有一致性
 9  * 适用：想表示对象的部分-整体层次结构
10  *         希望用户忽略组合对象与单个对象的不同，用户将统一地使用组合结构中的所有对象
11  * 时间：2016年2月20日下午9:09:45
12  * 作者：cutter_point
13  */
14 public class Composite extends Componment
15 {
16     //这个是单个节点，树枝节点，可以有子节点，我们用一个list存放我们的孩子节点
17     private List<Componment> children = new ArrayList<Componment>();
18     
19     public Composite(String name)
20     {
21         super(name);
22     }
23 
24     @Override
25     public void add(Componment c)
26     {
27         //添加一个孩子节点
28         children.add(c);
29     }
30 
31     @Override
32     public void remove(Componment c)
33     {
34         //删除对应的节点
35         children.remove(c);
36     }
37 
38     @Override
39     public void display(int depth)
40     {
41         //首先显示当前节点信息
42         StringBuffer sb = myutil.show(depth);
43         sb.append(this.name);
44         System.out.println(sb.toString());
45         
46         //显示相应的叶子的属性
47         for(Componment c : children)
48         {
49             //吧深度添加一个标准
50             c.display(depth + 2);
51         }//for
52     }
53 
54 }

 

测试代码：

 1 package com.shejimoshi.structural.Composite.type1;
 2 
 3 
 4 /**
 5  * 功能：测试组合模式
 6  * 时间：2016年2月20日下午9:15:49
 7  * 作者：cutter_point
 8  */
 9 public class Test
10 {
11     public static void main(String[] args)
12     {
13         Composite root = new Composite("根");
14         root.add(new Leaf("叶子A1"));
15         root.add(new Leaf("叶子A2"));
16         root.add(new Leaf("叶子A3"));
17         
18         //第一个分支
19         Composite child1 = new Composite("分支A1");
20         child1.add(new Leaf("叶子B1"));
21         child1.add(new Leaf("叶子B2"));
22         
23         root.add(child1); //吧分支加进去
24         
25         //分支可以再有分支,分支2
26         Composite child2 = new Composite("分支B1");
27         child2.add(new Leaf("叶子C1"));
28         child2.add(new Leaf("叶子C2"));
29         
30         child1.add(child2);
31         
32         //根部在张叶子
33         root.add(new Leaf("叶子A4"));
34         Leaf leaf = new Leaf("叶子A5");
35         root.add(leaf);
36         root.remove(leaf);
37         
38         //显示大树，首先大树根，那么深度就是0
39         root.display(0);
40     }
41 }

 

结果：

根
--叶子A1
--叶子A2
--叶子A3
--分支A1
----叶子B1
----叶子B2
----分支B1
------叶子C1
------叶子C2
--叶子A4