目录
- 示例
- 组合模式
- 安全式的合成模式的结构
- 透明式的合成模式的结构
- 定义
- 意图
- 主要解决问题
- 优缺点
- 安全式和透明式的组合模式
- 老和尚和小和尚的故事
有一个绘图系统,可以描绘各种图形,假设现在可以描绘线、长方形、圆形
定义一个抽象类,所有的图形继承此类,完成绘图:
public abstract class Graphics { /** 绘图 */ public abstract void draw(); }
线、长方形、圆形分别实现上述抽象类:
public class Line extends Graphics { @Override public void draw() { System.out.println("画一条线"); } }
public class Rect extends Graphics { @Override public void draw() { System.out.println("画一个矩形"); } }
public class Circle extends Graphics { @Override public void draw() { System.out.println("画一个圆形"); } }
现在还需要把上面的各种图形添加到画板里面,然后绘图:
public class Picture extends Graphics { private List<Graphics> list = new ArrayList<>(); @Override public void draw() { for (Graphics g : list) { g.draw(); } } /** 添加一个图形 */ public void add(Graphics graphics) { list.add(graphics); } /** 移除一个图形 */ public void remove(Graphics graphics) { list.remove(graphics); } /** 获取一个图形 */ public Graphics getChild(int i) { return list.get(i); } }
测试类:
public class Test { public static void main(String[] args) { Picture picture = new Picture(); picture.add(new Line()); picture.add(new Rect()); picture.add(new Circle()); picture.draw(); } }组合模式
定义
组合模式又叫做部分-整体模式,合成模式将对象组织到树结构中,可以用来描述整体与部分的关系,合成模式可以使客户端将单纯元素和复合元素同等看待
意图
将对象组合成树形结构以表示"部分-整体"的层次结构,组合模式使得用户对单个对象和组合对象的使用具有一致性
主要解决问题
客户程序可以像处理简单元素一样来处理复杂元素,从而使得客户程序与复杂元素的内部结构解耦
优缺点
优点:
- 高层模块调用简单
- 节点可以自由增加
缺点:
在使用组合模式时,其叶子和树枝的声明都是实现类,而不是接口,违反了依赖倒置原则
安全式和透明式的组合模式
下图省略了各个角色的细节,没有给出它们的各个方法
涉及的角色:
- 抽象构建(Component)角色:它给参加组合的对象规定了一个接口,这个角色给出共有的接口及默认行为
- 树叶构建(Leaf)角色:代表参加组合的树叶对象,一个树叶没有下级的子对象,定义出参加组合的原始对象的行为
- 树枝构建(Composite)角色:代表参加组合的有子对象的对象,并给出树枝对象构建的行为
Composite对象可以含有其他的Component类型的对象,也就是说,可以含有其他的树枝对象和树叶对象
安全式的合成模式的结构
要求管理聚集的方法只出现在树枝构建类中,而不出现在树叶构建类中,即在Composite类中声明管理子类对象的方法
涉及的角色:
- 抽象构建(Component)角色:它给参加组合的对象规定了一个接口,这个角色给出共有的接口及默认行为,可以用来管理所有的子对象,在安全式的组合模式中,构建角色并不定义出管理子对象的方法,这一定义由树枝构建给出
- 树叶构建(Leaf)角色:代表参加组合的树叶对象,一个树叶没有下级的子对象,定义出参加组合的原始对象的行为
- 树枝构建(Composite)角色:代表参加组合的有子对象的对象,并给出树枝对象构建的行为,它会给出所有的管理子对象的方法,比如add、remove等
对应的源码如下:
public interface Component { /** 返还自己的实例 */ Composite getComposite(); /** 某个商业方法 */ void sampleOperation(); }
public class Composite implements Component { private List<Component> compositeList = new ArrayList<>(); @Override public Composite getComposite() { return this; } @Override public void sampleOperation() { compositeList.forEach(v -> { v.sampleOperation(); }); } public void add(Component component) { compositeList.add(component); } public void remove(Component component) { compositeList.remove(component); } public List<Component> components() { return compositeList; } }
public class Leaf implements Component { @Override public Composite getComposite() { return null; } @Override public void sampleOperation() { } }
透明式的合成模式的结构
透明式的合成模式要求所有的具体构建类,不论是树枝还是树叶,都要实现一个固定的接口
涉及的角色:
- 抽象构建(Component)角色:它给参加组合的对象规定了一个接口,这个角色给出共有的接口及默认行为,可以用来管理所有的子对象,它会给出所有的管理子对象的方法,比如add、remove等
- 树叶构建(Leaf)角色:代表参加组合的树叶对象,一个树叶没有下级的子对象,定义出参加组合的原始对象的行为
- 树枝构建(Composite)角色:代表参加组合的有子对象的对象,并给出树枝对象构建的行为
对应的源码如下:
public interface Component { /** 返还自己的实例 */ Composite getComposite(); /** 某个商业方法 */ void sampleOperation(); /** 增加一个子构建对象 */ void add(Component component); /** 删除一个子构建对象 */ void remove(Component component); /** 返回所有的构建对象 */ List<Component> components(); }
public class Composite implements Component { private List<Component> compositeList = new ArrayList<>(); @Override public Composite getComposite() { return this; } @Override public void sampleOperation() { compositeList.forEach(v -> { v.sampleOperation(); }); } @Override public void add(Component component) { compositeList.add(component); } @Override public void remove(Component component) { compositeList.remove(component); } @Override public List<Component> components() { return compositeList; } }
public class Leaf implements Component { @Override public Composite getComposite() { return null; } @Override public void sampleOperation() { } @Override public void add(Component component) { } @Override public void remove(Component component) { } @Override public List<Component> components() { return null; } }老和尚和小和尚的故事
从前有座山,山里有座庙,庙里有个老和尚正给小和尚讲故事,故事讲的是,从前有座山,山里有座庙,庙里有个老和尚正给小和尚讲故事......
在这里故事就是上述的树枝构建,它包含了山、庙、和尚,而山、庙、和尚则是树叶构建,没有内部的角色
可以看到,故事对象里面有山对象、庙对象、和尚对象、故事对象,如此循环下去
对应的示例代码如下:
讲故事的接口,即故事是抽象构建角色:
public interface StoryComponent { /** 讲故事 */ void tellStory(); }
下面是树叶构建角色,即故事:
public class StoryComposite implements StoryComponent { private List<StoryComponent> componentList = new ArrayList<>(); @Override public void tellStory() { for (StoryComponent s : componentList) { s.tellStory(); if (s.getClass().getName().contains("MonkLeaf")) { tellStory(); } } } public void add(StoryComponent component) { componentList.add(component); } public void remove(StoryComponent component) { componentList.remove(component); } public List<StoryComponent> getChild() { return componentList; } }
下面是山、庙、和尚,没有子对象:
public class MountainLeaf implements StoryComponent { @Override public void tellStory() { System.out.println("从前有座山"); } }
public class TempleLeaf implements StoryComponent { @Override public void tellStory() { System.out.println("山里有个庙"); } }
public class MonkLeaf implements StoryComponent { @Override public void tellStory() { System.out.println("庙里有个老和尚,老和尚再给小和尚讲故事,讲的什么故事呢?"); System.out.println("讲的是:"); System.out.println("----------------------------------------------------------------------"); } }
开始讲故事了:
public class StoryTest { public static void main(String[] args) { //故事 StoryComposite story = new StoryComposite(); //叶子:山、庙、道士 StoryComponent mountain = new MountainLeaf(); StoryComponent temple = new TempleLeaf(); StoryComponent monk = new MonkLeaf(); //添加子构建对象 story.add(mountain); story.add(temple); story.add(monk); //开始讲故事 story.tellStory(); } }
然后运行会发现啊,老和尚累死了,哈哈。。。
类图: