JAVA设计模式初探之组合模式

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

就拿剪发办卡的事情来分析一下吧。

首先，一张卡可以在总部，分店，加盟店使用，那么总部可以刷卡，分店也可以刷卡，加盟店也可以刷卡，这个属性结构的店面层级关系就明确啦。

那么，总店刷卡消费与分店刷卡消费是一样的道理，那么总店与分店对会员卡的使用也具有一致性。

1.组合模式的例子

那么组合模式的实例如下：

1. import java.util.ArrayList;
2. import java.util.List;
3. public class ComponentDemo {
4. public abstract class Component {
5. String name;
6. public abstract void add(Component c);
7. public abstract void remove(Component c);
8. public abstract void eachChild();
9. }
10. // 组合部件类
11. public class Leaf extends Component {
12. // 叶子节点不具备添加的能力，所以不实现
13. @Override
14. public void add(Component c) {
15. // TODO Auto-generated method stub
16. System.out.println("");
17. }
18. // 叶子节点不具备添加的能力必然也不能删除
19. @Override
20. public void remove(Component c) {
21. // TODO Auto-generated method stub
22. System.out.println("");
23. }
24. // 叶子节点没有子节点所以显示自己的执行结果
25. @Override
26. public void eachChild() {
27. // TODO Auto-generated method stub
28. System.out.println(name + "执行了");
29. }
30. }
31. // 组合类
32. public class Composite extends Component {
33. // 用来保存节点的子节点
34. List<Component> list = new ArrayList<Component>();
35. // 添加节点 添加部件
36. @Override
37. public void add(Component c) {
38. // TODO Auto-generated method stub
39. list.add(c);
40. }
41. // 删除节点 删除部件
42. @Override
43. public void remove(Component c) {
44. // TODO Auto-generated method stub
45. list.remove(c);
46. }
47. // 遍历子节点
48. @Override
49. public void eachChild() {
50. // TODO Auto-generated method stub
51. System.out.println(name + "执行了");
52. for (Component c : list) {
53. c.eachChild();
54. }
55. }
56. }
57. public static void main(String[] args) {
58. ComponentDemo demo = new ComponentDemo();
59. // 构造根节点
60. Composite rootComposite = demo.new Composite();
61. rootComposite.name = "根节点";
62. // 左节点
63. Composite compositeLeft = demo.new Composite();
64. compositeLeft.name = "左节点";
65. // 构建右节点，添加两个叶子几点，也就是子部件
66. Composite compositeRight = demo.new Composite();
67. compositeRight.name = "右节点";
68. Leaf leaf1 = demo.new Leaf();
69. leaf1.name = "右-子节点1";
70. Leaf leaf2 = demo.new Leaf();
71. leaf2.name = "右-子节点2";
72. compositeRight.add(leaf1);
73. compositeRight.add(leaf2);
74. // 左右节点加入 根节点
75. rootComposite.add(compositeRight);
76. rootComposite.add(compositeLeft);
77. // 遍历组合部件
78. rootComposite.eachChild();
79. }
80. }

执行结果如下：

2.应用组合模式的会员卡消费

那么我们就根据我们会员卡的消费，来模拟一下组合模式的实现吧！let's Go！

首先：

1.我们的部件有，总店，分店，加盟店！

2.我们的部件共有的行为是：刷会员卡

3.部件之间的层次关系，也就是店面的层次关系是，总店下有分店、分店下可以拥有加盟店。

有了我们这几个必要条件后，我的要求就是目前店面搞活动当我在总店刷卡后，就可以累积相当于在所有下级店面刷卡的积分总额，设计的代码如下：

1. import java.util.ArrayList;
2. import java.util.List;
3. public class PayDemo {
4. public abstract class Market {
5. String name;
6. public abstract void add(Market m);
7. public abstract void remove(Market m);
8. public abstract void PayByCard();
9. }
10. // 分店 下面可以有加盟店
11. public class MarketBranch extends Market {
12. // 加盟店列表
13. List<Market> list = new ArrayList<PayDemo.Market>();
14. public MarketBranch(String s) {
15. this.name = s;
16. }
17. @Override
18. public void add(Market m) {
19. // TODO Auto-generated method stub
20. list.add(m);
21. }
22. @Override
23. public void remove(Market m) {
24. // TODO Auto-generated method stub
25. list.remove(m);
26. }
27. // 消费之后，该分店下的加盟店自动累加积分
28. @Override
29. public void PayByCard() {
30. // TODO Auto-generated method stub
31. System.out.println(name + "消费,积分已累加入该会员卡");
32. for (Market m : list) {
33. m.PayByCard();
34. }
35. }
36. }
37. // 加盟店 下面不在有分店和加盟店，最底层
38. public class MarketJoin extends Market {
39. public MarketJoin(String s) {
40. this.name = s;
41. }
42. @Override
43. public void add(Market m) {
44. // TODO Auto-generated method stub
45. }
46. @Override
47. public void remove(Market m) {
48. // TODO Auto-generated method stub
49. }
50. @Override
51. public void PayByCard() {
52. // TODO Auto-generated method stub
53. System.out.println(name + "消费,积分已累加入该会员卡");
54. }
55. }
56. public static void main(String[] args) {
57. PayDemo demo = new PayDemo();
58. MarketBranch rootBranch = demo.new MarketBranch("总店");
59. MarketBranch qhdBranch = demo.new MarketBranch("秦皇岛分店");
60. MarketJoin hgqJoin = demo.new MarketJoin("秦皇岛分店一海港区加盟店");
61. MarketJoin btlJoin = demo.new MarketJoin("秦皇岛分店二白塔岭加盟店");
62. qhdBranch.add(hgqJoin);
63. qhdBranch.add(btlJoin);
64. rootBranch.add(qhdBranch);
65. rootBranch.PayByCard();
66. }
67. }

运行结果如下：

这样在累积所有子店面积分的时候，就不需要去关心子店面的个数了，也不用关系是否是叶子节点还是组合节点了，也就是说不管是总店刷卡，还是加盟店刷卡，都可以正确有效的计算出活动积分。

3.什么情况下使用组合模式

引用大话设计模式的片段：“当发现需求中是体现部分与整体层次结构时，以及你希望用户可以忽略组合对象与单个对象的不同，统一地使用组合结构中的所有对象时，就应该考虑组合模式了。”

作者：jason0539

微博：http://weibo.com/2553717707

博客：http://blog.csdn.net/jason0539（转载请说明出处）