(《设计模式解析与实战——何红辉,关爱民》读书笔记)
一、定义
将对象组合呈树形结构以表示“部分-整体”的层次结构,使得用户对单个对象和组合对象的使用具有一致性。
比如,总公司下设总公司行政部、总公司研发部和子公司,而子公司又下设子公司行政部和子公司研发部。
二、使用场景
(1)表示对象的部分-整体层次结构时;
(2)从一个整体中能够独立出部分模块或功能的场景。
三、组合模式的通用模式代码
1、安全的组合模式
/**
* 抽象根节点:为组合中的对象声明接口
*/
public abstract class Component {
// 节点名
protected String name;
public Component(String name) {
this.name = name;
}
/**
* 具体的逻辑方法由子类实现
*/
public abstract void doSomething();
}
/**
* 具体枝干节点:定义有子节点的那些枝干节点的行为,存储子节点
*/
public class Composite extends Component {
/*
* 存储节点的容器
*/
private List<Component> components = new ArrayList<>();
public Composite(String name) {
super(name);
}
@Override
public void doSomething() {
System.out.println(name);
if (components != null) {
for (Component component : components) {
component.doSomething();
}
}
}
/**
* 添加子节点
*
* @param child
* 子节点
*/
public void addChild(Component child) {
components.add(child);
}
/**
* 移除子节点
*
* @param child
* 子节点
*/
public void removeChild(Component child) {
components.remove(child);
}
/**
* 获取子节点
*
* @param index
* 子节点对应下标
* @return 子节点
*/
public Component getChildren(int index) {
return components.get(index);
}
}
/**
* 具体叶子节点:叶子节点没有子节点,在组合中定义节点对象的行为
*/
public class Leaf extends Component{
public Leaf(String name) {
super(name);
}
@Override
public void doSomething() {
System.out.println(name);
}
}
/**
* 客户类:通过Component接口操纵组合节点的对象
*/
public class Client {
public static void main(String[] args) {
// 构造一个根节点
Composite root = new Composite("Root");
// 构造两个枝干节点
Composite branch1 = new Composite("Branch1");
Composite branch2 = new Composite("Branch2");
// 构造两个叶子节点
Leaf leaf1 = new Leaf("Leaf1");
Leaf leaf2 = new Leaf("Leaf2");
// 将叶子节点添加至枝干节点中
branch1.addChild(leaf1);
branch2.addChild(leaf2);
// 将枝干节点添加至根节点中
root.addChild(branch1);
root.addChild(branch2);
// 执行方法
root.doSomething();
}
}
运行结果:
这里有一个很大的弊端,我们在客户类中直接使用了Component的实现类,这与依赖倒置原则(高层次的模块不依赖于低层次的模块的实现细节的目的)相违背。
2、透明的组合模式
/**
* 透明的组合模式抽象根节点:为组合中的对象声明接口
*/
public abstract class Component {
// 节点名
protected String name;
public Component(String name) {
this.name = name;
}
/**
* 具体的逻辑方法由子类实现
*/
public abstract void doSomething();
/**
* 添加子节点
*
* @param child
* 子节点
*/
public abstract void addChild(Component child);
/**
* 移除子节点
*
* @param child
* 子节点
*/
public abstract void removeChild(Component child);
/**
* 获取子节点
*
* @param index
* 子节点对应下标
* @return 子节点
*/
public abstract Component getChildren(int index);
}
/**
* 透明的组合模式具体枝干节点:定义有子节点的那些枝干节点的行为,存储子节点
*/
public class Composite extends Component {
/*
* 存储节点的容器
*/
private List<Component> components = new ArrayList<>();
public Composite(String name) {
super(name);
}
@Override
public void doSomething() {
System.out.println(name);
if (components != null) {
for (Component component : components) {
component.doSomething();
}
}
}
@Override
public void addChild(Component child) {
components.add(child);
}
@Override
public void removeChild(Component child) {
components.remove(child);
}
@Override
public Component getChildren(int index) {
return components.get(index);
}
}
/**
* 透明的组合模式具体叶子节点:叶子节点没有子节点,在组合中定义节点对象的行为
*/
public class Leaf extends Component {
public Leaf(String name) {
super(name);
}
@Override
public void doSomething() {
System.out.println(name);
}
@Override
public void addChild(Component child) {
throw new UnsupportedOperationException("叶子节点没有子节点");
}
@Override
public void removeChild(Component child) {
throw new UnsupportedOperationException("叶子节点没有子节点");
}
@Override
public Component getChildren(int index) {
throw new UnsupportedOperationException("叶子节点没有子节点");
}
}
/**
* 透明的组合模式客户类:通过Component接口操纵组合节点的对象
*/
public class Client {
public static void main(String[] args) {
// 构造一个根节点
Component root = new Composite("Root");
// 构造两个枝干节点
Component branch1 = new Composite("Branch1");
Component branch2 = new Composite("Branch2");
// 构造两个叶子节点
Component leaf1 = new Leaf("Leaf1");
Component leaf2 = new Leaf("Leaf2");
// 将叶子节点添加至枝干节点中
branch1.addChild(leaf1);
branch2.addChild(leaf2);
// 将枝干节点添加至根节点中
root.addChild(branch1);
root.addChild(branch2);
// 执行方法
root.doSomething();
}
}
四、总结
组合模式在Android中最经典的实现就是View和ViewGrounp的嵌套组合。当然这种模式真正需要开发者去实现的并不多。
优点:
(1)可以清楚的定义分层次的复杂对象,表示对象的全部或部分层次,它让高层模块忽略了层次的差异,方便对整个层次结构进行控制;
(2)高层模块可以一致的使用一个组合结构或其中单个对象,不必关心处理的是单个对象还是整个组合结构,简化了高层模块的代码;
(3)在组合模式中增加新的枝干构件和叶子构件都很方便,无须对现有类库进行任何修改,符合“开闭原则”;
(4)组合模式为树形结构的面向对象实现提供了一种灵活的解决方案,通过叶子对象和枝干对象的递归组合,可以形成复杂的树形结构,但对树形结构的控制却非常简单。
缺点:
在新增构件时不好对枝干中的构件类型进行限制,不能依赖类型系统来施加这些约束,因为在大多数情况下,它们都来自于相同的抽象层,此时,必须及时进行类型检查来实现,这个实现过程较为复杂。