visitor模式

场景

（1）组合模式，我们现在想象一下，我们之前做的是说递归删除部门自己本身 （2）但是我们现在要对他改造一下，将组合模式和访问者模式结合起来，就是说，我们可以让那颗树执行我们想要他做的任何事情

1.访问者模式

  1. package com.example.demo.pattern.visitor;
  3. import java.util.ArrayList;
  4. import java.util.List;
  5. /**
  6.  * @author chenchao
  7.  * @date 2021/11/9
  8.  */
  9. public class VisitorPatternDemo {
  11.     public static void main(String[] args) {
  12.         Department leafDept1 = new Department("叶子部门1"); 
  13.         Department leafDept2 = new Department("叶子部门2");
  14.         Department leafDept3 = new Department("叶子部门3"); 
  16.         Department subDept1 = new Department("子部门1");
  17.         subDept1.getChildren().add(leafDept1);
  18.         subDept1.getChildren().add(leafDept2);
  20.         Department subDept2 = new Department("子部门2"); 
  21.         subDept2.getChildren().add(leafDept3);
  23.         Department parentDept = new Department("父部门");
  24.         parentDept.getChildren().add(subDept1);
  25.         parentDept.getChildren().add(subDept2);
  27.         Visitor removeVisitor = new RemoveVisitor();
  28.         parentDept.accept(removeVisitor);
  30.         Visitor updateStatusVisitor = new UpdateStatusVisitor("禁用");  
  31.         parentDept.accept(updateStatusVisitor);
  33.         // 访问者模式，一般来说，就是跟组合模式结合起来使用的
  34.         // 组合模式代表了一种复杂的对象的类型
  35.         // 如果你后面要给树形的数据结构增加个什么功能，修改代码可能会比较麻烦
  36.         // 但是如果采用访问者模式来做，你可以在任何时候给树形的数据结构增加任何的功能
  37.     }
  39.     public static class Department {
  41.         private String name;
  42.         private List<Department> children = new ArrayList<Department>();
  44.         public Department(String name) {
  45.             super();
  46.             this.name = name;
  47.         }
  49.         public String getName() {
  50.             return name;
  51.         }
  52.         public void setName(String name) {
  53.             this.name = name;
  54.         }
  55.         public List<Department> getChildren() {
  56.             return children;
  57.         }
  58.         public void setChildren(List<Department> children) {
  59.             this.children = children;
  60.         }
  62.         public void accept(Visitor visitor) {
  63.             visitor.visit(this);
  64.         }
  66.     }
  68.     public interface Visitor {
  70.         void visit(Department dept);
  72.     }
  74.     public static class RemoveVisitor implements Visitor {
  75.         @Override
  76.         public void visit(Department dept) {
  77.             if(dept.getChildren().size() > 0) {
  78.                 for(Department child : dept.getChildren()) {  
  79.                     child.accept(this);  
  80.                 }
  81.             }
  82.             System.out.println("删除部门【" + dept.getName() + "】");  
  83.         }
  85.     }    
  87.     public static class UpdateStatusVisitor implements Visitor {
  89.         private String status;
  90.         @Override
  91.         public void visit(Department dept) {
  92.             if(dept.getChildren().size() > 0) {
  93.                 for(Department child : dept.getChildren()) {  
  94.                     child.accept(this);  
  95.                 }
  96.             }
  97.             System.out.println("将部门【" + dept.getName() + "】的状态修改为：" + status);  
  98.         }
  100.         public UpdateStatusVisitor(String status) {
  101.             this.status = status;
  102.         }
  104.     }
  106. }

2.说明

访问者模式，是对目标对象，动态的执行某个功能，而不对目标对象有任何的改动