定义与特点

有时叫做整体-部分模式，将对象组合成树状的层次结构的设计模式，用来表示整体-部分的关系，使得用户对单个对象和组合对象有一致的访问性。

将对象组织到树形结构中，

优点

  • 组合模式使得客服端代码可以一致的处理单个对象和组合对象，无须关心自己处理的单个对象，可以直接进行操作，给客户带来了极大的便利
  • 更容易在组合体内加入新的对象，客户端不会因为加入新的对象而更改源代码，满足开闭原则

缺点

  • 设计比较复杂，客户端需要花更多的时间来理清类之间的层次关系
  • 不容易限制容器中的构件
  • 不容易继承的方法来增加构件的新功能

组合模式的应用场景

  • 需要表示一个对象整体与部分的层次结构的场合
  • 要求对用户隐藏组合对象与单个对象不同，用户可以用统一的接口使用组合结构中的所有对象的场合

代码结构

  1. 抽象构件（Component）：主要作用是为树叶构件和树枝构件声明公共接口，并实现他们的默认行为。
    • 在透明式的组合中：还声明访问和管理子类的接口
    • 在安全式组合中，不声明访问和管理子类接口，管理工作由树枝构件完成。
  2. 树叶构件（Leaf）：是组合中的叶子节点对象，没有子节点，用于继承或实现抽象构件
  3. 树枝构件（Composite）/中间构件: 组合中的分支系欸但对象，有子节点。用于继承和思实现抽下管理构件。主要作用是存储和管理子部件。通常包含了 Add(),Remove(),GetChild()等方法。

透明模式代码实现

抽象构件声明了所有的子类中所有的方法，所以客户端不需要区别对待树枝和树叶对象，对客户端来说是透明的。
但是，树叶构件本没有Add(),Remove()等方法，但是要去实现他们（为空或者抛异常），会带来一部分的安全问题

抽象构件

  1. public interface ComponentLucency {
  2.     public void add(ComponentLucency c);
  3.     public void remove(ComponentLucency c);
  4.     public ComponentLucency getChild(int t);
  5.     public void operation();
  6. }

树叶构件

  1. public class LeafLucency implements ComponentLucency{
  2.     private String name;
  3.     public LeafLucency(String name){
  4.         this.name = name;
  5.     }
  6.     @Override
  7.     public void add(ComponentLucency c) {
  8.     }
  9.     @Override
  10.     public void remove(ComponentLucency c) {
  11.     }
  12.     @Override
  13.     public ComponentLucency getChild(int t) {
  14.         return null;
  15.     }
  16.     @Override
  17.     public void operation() {
  18.         System.out.println("树叶"+name+":被访问！！！");
  19.     }
  20. }

树枝构件

  1. public class CompositeLucency implements ComponentLucency{
  2.     private ArrayList<ComponentLucency> children = new ArrayList<>();
  3.     @Override
  4.     public void add(ComponentLucency c) {
  5.         children.add(c);
  6.     }
  7.     @Override
  8.     public void remove(ComponentLucency c) {
  9.         children.remove(c);
  10.     }
  11.     @Override
  12.     public ComponentLucency getChild(int t) {
  13.         return children.get(t);
  14.     }
  15.     @Override
  16.     public void operation() {
  17.         for (Object obj:children) {
  18.             ((ComponentLucency)obj).operation();
  19.         }
  20.     }
  21. }

调用

  1. public class LucencyMain {
  2.     public static void main(String[] args) {
  3.         ComponentLucency c0 = new CompositeLucency();
  4.         ComponentLucency c1 = new CompositeLucency();
  5.         ComponentLucency l1 =new LeafLucency("1");
  6.         ComponentLucency l2 =new LeafLucency("2");
  7.         ComponentLucency l3 =new LeafLucency("3");
  9.         c0.add(l1);
  10.         c0.add(c1);
  11.         c1.add(l2);
  12.         c1.add(l3);
  13.         c0.operation();
  14.         System.out.println("-------------------------------");
  15.         c1.operation();
  16.     }
  17. }

安全模式代码实现

将管理子构件的方法移到树枝构件中，抽象构件和树叶构件没有对子类对象的管理方法，这样避免了上一种的安全性问题，但是由于叶子和分支有不同的接口，客户端在调用时需要知道树叶对象和树枝对象的存在，失去了透明性。

示例：

  1. * 组合模式的例子（安全模式下）
  2.  *
  3.  * 最后“大袋子”中的内容有：{
  4.  *          1 双李宁牌运动鞋（单价 198 元）、
  5.  *          白色小袋子{
  6.  *              2 包韶关香菇（单价 68 元）、
  7.  *              3 包韶关红茶（单价 180 元）}、
  8.  *          中袋子{
  9.  *              1 个景德镇瓷器（单价 380 元）、
  10.  *              红色小袋子{
  11.  *                  2 包婺源特产（单价 7.9 元）、
  12.  *                  1 张婺源地图（单价 9.9 元）}}}，
  13.  * 现在要求编程显示李先生放在大袋子中的所有商品信息并计算要支付的总价。

抽象构件

  1. public abstract class Atricles {
  2.     //计算价格方法
  3.     public abstract float calculation();
  4.     //显示商品信息方法
  5.     public abstract void show();
  6. }

树叶构件

  1. public class Goods extends Atricles {
  2.     private String name;
  3.     private int quantity;
  4.     private float unitPrie;
  5.     public Goods(String name,int quantity,float unitPrie){
  6.         this.name = name;
  7.         this.quantity = quantity;
  8.         this.unitPrie = unitPrie;
  9.     }
  10.     @Override
  11.     public float calculation() {
  12.         return quantity*unitPrie;
  13.     }
  14.     @Override
  15.     public void show() {
  16.         System.out.println("商品名："+name +" 单价：" + unitPrie + " 数量: " + quantity + " 总价： "+ calculation());
  17.     }
  18. }

树枝构件

  1. public class Bags extends Atricles{
  2.     private String name;
  3.     private ArrayList<Atricles> list = new ArrayList<>();
  5.     public Bags(String name){
  6.         this.name = name;
  7.     }
  8.     public void add(Atricles a){
  9.         list.add(a);
  10.     }
  11.     public void remove(Atricles a){
  12.         list.remove(a);
  13.     }
  14.     public Atricles getChild(int i){
  15.         return list.get(i);
  16.     }
  17.     @Override
  18.     public float calculation() {
  19.         float price = (float) 0;
  20.         for (Object obj:list) {
  21.             price = price + ((Atricles)obj).calculation();
  22.         }
  23.         return price;
  24.     }
  25.     @Override
  26.     public void show() {
  27.         System.out.println("----------");
  28.         System.out.println(name + "装着下面的这些物品：");
  29.         for (Object obj:list) {
  30.             ((Atricles)obj).show();
  31.         }
  32.     }
  33. }

调用

  1. public class CompositeSimpleMain {
  2.     public static void main(String[] args) {
  3.         Bags bags0 = new Bags("大袋子");
  4.         Bags bags1 = new Bags("白色小袋子");
  5.         Bags bags2 = new Bags("中袋子");
  6.         Bags bags3 = new Bags("红色小袋子");
  8.         Goods goods1 = new Goods("双李宁牌运动鞋",1,198);
  9.         Goods goods2 = new Goods("包韶关香菇",2,68);
  10.         Goods goods3 = new Goods("包韶关红茶",3,180);
  11.         Goods goods4 = new Goods("景德镇瓷器",1,380);
  12.         Goods goods5 = new Goods("婺源特产",2,7.9F);
  13.         Goods goods6 = new Goods("婺源地图",1,9.9F);
  15.         bags0.add(goods1);
  16.         bags0.add(bags1);
  17.         bags0.add(bags2);
  19.         bags1.add(goods2);
  20.         bags1.add(goods3);
  22.         bags2.add(goods4);
  23.         bags2.add(bags3);
  25.         bags3.add(goods5);
  26.         bags3.add(goods6);
  28.         bags0.show();
  29.         System.out.println("需要支付的价格：" +bags0.calculation());
  30.     }
  31. }

结果

  1. ----------
  2. 大袋子装着下面的这些物品：
  3. 商品名：双李宁牌运动鞋 单价：198.0 数量: 1 总价： 198.0
  4. ----------
  5. 白色小袋子装着下面的这些物品：
  6. 商品名：包韶关香菇 单价：68.0 数量: 2 总价： 136.0
  7. 商品名：包韶关红茶 单价：180.0 数量: 3 总价： 540.0
  8. ----------
  9. 中袋子装着下面的这些物品：
  10. 商品名：景德镇瓷器 单价：380.0 数量: 1 总价： 380.0
  11. ----------
  12. 红色小袋子装着下面的这些物品：
  13. 商品名：婺源特产 单价：7.9 数量: 2 总价： 15.8
  14. 商品名：婺源地图 单价：9.9 数量: 1 总价： 9.9
  15. 需要支付的价格：1279.7