一、介绍，定义
将对象组合呈树形结构以表示“部分-整体”的层次结构，使得用户对单个对象和组合对象的使用具有一致性。
比如，总公司下设总公司行政部、总公司研发部和子公司，而子公司又下设子公司行政部和子公司研发部。
二、使用场景
(1)表示对象的部分-整体层次结构时；
(2)从一个整体中能够独立出部分模块或功能的场景。
三、UML类图
25.png
角色说明：
Component（抽象组件角色）：定义参加组合对象的共有方法和属性，可以定义一些默认的函数或属性。
Leaf（叶子节点）：叶子没有子节点，因此是组合树的最小构建单元。
Composite（树枝节点）：定义所有枝干节点的行为，存储子节点，实现相关操作。
四、通用代码
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();
}
}
结果：
26.png
这里有一个很大的弊端，我们在客户类中直接使用了Component的实现类，这与依赖倒置原则（高层次的模块不依赖于低层次的模块的实现细节的目的）相违背。
我们将位于Composite的一些方法定义到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)组合模式为树形结构的面向对象实现提供了一种灵活的解决方案，通过叶子对象和枝干对象的递归组合，可以形成复杂的树形结构，但对树形结构的控制却非常简单。
缺点：
在新增构件时不好对枝干中的构件类型进行限制，不能依赖类型系统来施加这些约束，因为在大多数情况下，它们都来自于相同的抽象层，此时，必须及时进行类型检查来实现，这个实现过程较为复杂。
网友评论