设计模式之组合模式(15):对组合成的层级数据递归调用执行操作
文章目录
场景
场景:
(1)父部门->子部门->子部门
(2)我们要对部门树,删除一个父部门以及其下所有的子部门
内容
组合模式首先需要组合成一颗递归调用树
1.不使用设计模式
部门树形结构,我们可以用一个对象来表示,里面报表集合属性。
1.1 类图

- 组装部门树时候,只需要一级一级的组装
- 删除时候根据遍历删除
1.2 代码
public class NonPattern2 {
public static void main(String[] args) {
//1.根节点
Department rootDepartment = new Department("根部门");
//2.子节点
Department subDepartment1 = new Department("子部门1");
Department subDepartment2 = new Department("子部门2");
//3.孙子节点
Department leafDepartment1 = new Department("叶子部门1");
Department leafDepartment2 = new Department("叶子部门2");
Department leafDepartment3 = new Department("叶子部门3");
//4.组装数据
rootDepartment.getChidlren().add(subDepartment1);
rootDepartment.getChidlren().add(subDepartment2);
subDepartment1.getChidlren().add(leafDepartment1);
subDepartment1.getChidlren().add(leafDepartment2);
subDepartment2.getChidlren().add(leafDepartment3);
//5.删除数据
for (Department subDept:rootDepartment.getChidlren()){
if(subDept.getChidlren().size()>0){
for (Department leafDept:subDept.getChidlren()){
leafDept.remove();
}
}
subDept.remove();
}
rootDepartment.remove();
/**
* 输出:
* 删除部门【叶子部门1】
* 删除部门【叶子部门2】
* 删除部门【子部门1】
* 删除部门【叶子部门3】
* 删除部门【子部门2】
* 删除部门【根部门】
*/
}
public static class Department{
private String name;
private List<Department> chidlren = new ArrayList();
public Department(String name){
this.name = name;
}
public void remove(){
System.out.println("删除部门【" + name + "】");
}
public void setChidlren(List<Department> chidlren) {
this.chidlren = chidlren;
}
public List<Department> getChidlren() {
return chidlren;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
}
2.使用组合模式
2.1 类图

- 组合设计模式和不使用设计模式的类图类似,最主要区别是remove方法执行逻辑。
- remove方法实现递归删除。
2.2 代码
public class CompositePattern2 {
public static void main(String[] args) {
//1.父部门
Department parentDept = new Department("父部门");
//2.子部门
Department subDept1 = new Department("子部门1");
Department subDept2 = new Department("子部门2");
//3.叶子部门
Department leafDept1 = new Department("叶子部门1");
Department leafDept2 = new Department("叶子部门2");
Department leafDept3 = new Department("叶子部门3");
//4.组装数据
subDept1.getChildren().add(leafDept1);
subDept1.getChildren().add(leafDept2);
subDept2.getChildren().add(leafDept3);
parentDept.getChildren().add(subDept1);
parentDept.getChildren().add(subDept2);
//5.删除
parentDept.remove();
}
public static class Department{
private String name;
private List<Department> children = new ArrayList<Department>();
public Department(String name){
super();
this.name = name;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public List<Department> getChildren() {
return children;
}
public void setChildren(List<Department> children) {
this.children = children;
}
//===================关键点=================
public void remove(){
//递归删除:递归找准结束边界:对象的属性集合不大于0就结束
if(children.size()>0){
for (Department child:children){
child.remove();//递归调用
}
}
System.out.println("删除部门【" + name + "】");
}
}
}
3.总结
3.1 不使用设计模式
- 调用方需要知道被调用方逻辑,并且需要使用大量if---for,如果被调用方更改了里面逻辑代码,那么调用方也得更改里面代码。
3.2 使用设计模式
- 组合模式的第一要义,就是将树形结构的数据,用一个类,或者少数一两个类,就可以拼装成一棵树的形状。
- 组合模式的第二要义,就是直接对一个父级的数据执行某个操作,这个操作会直接递归调用所有下层的子数据的相关操作;通过这个树形结构自己递归自己的方式,就将对一棵树的操作,完美的执行了
- 好处,就是对树形数据的操作,不需要调用方组织复杂的屎一样的if for的代码,去执行。
- 外部要操作一颗树,直接对树的父级节点,调用一个操作,这颗树自己就递归着把事儿给干完了。
- 设计模式,重点,是思想,理解了思想,随便招式你怎么出,只要能将思想运用到实际业务场景中;避免写出垃圾代码,你就成功了;如果你照搬设计模式去写,反而增加代码的复杂度。
评论
登录后参与技术讨论,分享你的经验与见解。
登录 / 注册暂无评论