【Java】23种设计模式——16.迭代器模式21访问者模式

迭代器模式与访问者模式，都用于遍历集合；迭代器模式关注遍历；访问者模式关注操作。

迭代器模式

定义

迭代器模式(Iterator Pattern)是一种行为型设计模式，它提供一种方法顺序访问一个聚合对象中的各个元素，而又不暴露该对象的内部表示。

核心角色

1. 迭代器(Iterator)：定义访问和遍历元素的接口
2. 具体迭代器(ConcreteIterator)：实现迭代器接口，跟踪当前遍历位置
3. 聚合(Aggregate)：定义创建迭代器对象的接口
4. 具体聚合(ConcreteAggregate)：实现创建迭代器的接口

应用场景

• 需要统一遍历不同集合结构的对象时
• 需要为聚合对象提供多种遍历方式的时候
• 需要隐藏聚合对下那个的内部结构时
• 需要支持对聚合对象的并行遍历时

使用

迭代器模式的典型实现：

• 抽象迭代器

  /**
   * 迭代器模式：迭代器接口
   * @Author：lyj
   * @Date：2025/5/20 11:47
   */
  public interface Iterator<T> {
      /**
       * 判断是否还有下一个元素
       * @return
       */
      public boolean hasNext();
      /**
       * 获取下一个元素
       * @return
       */
      public T next();
  }
  

• 抽象聚合

  /**
   * 迭代器模式：聚合接口
   * @Author：lyj
   * @Date：2025/5/20 11:49
   */
  public interface Container<T> {
      /**
       * 获取迭代器
       * @return
       */
      Iterator<T> getIterator();
  }
  

• 具体聚合+具体迭代器

  /*
  * 迭代器模式：具体聚合
   * @Date：2025/5/20 11:50
   */
  public class NameRepository implements Container<String> {
      public List<String> names = new ArrayList<>();
  
      public NameRepository(String[] names) {
         for (String name : names){
             this.names.add(name);
         }
      }
      /**
       * 获取迭代器
       * @return
       */
      @Override
      public Iterator<String> getIterator() {
          return new NameIterator();
      }
  
  
      /**
       *  迭代器模式：具体迭代器
       * @Author：lyj
       * @Date：2025/5/20 11:54
       */
      public class NameIterator implements Iterator<String> {
          private int index = 0;
  
          /**
           * 判断是否还有下一个元素
           * @return
           */
          @Override
          public boolean hasNext() {
              return index < names.size();
          }
  
          /**
           * 获取下一个元素
           * @return
           */
          @Override
          public String next() {
              if (this.hasNext() ) {
                  return names.get(index++);
              }
              return "";
          }
      }
  }
  

运行客户端

String[] names = {"张三","李四","王五","赵六"};
NameRepository nameRepository = new NameRepository(names);
// 迭代
Iterator<String> iterator = nameRepository.getIterator();
while (iterator.hasNext()){
	System.out.println("Name:" +iterator.next());
}

运行结果：

访问者模式

定义

访问者模式(Visitor Pattern)允许在不修改已有类结构的情况下定义新的操作，将数据结构和数据操作分离。

核心角色

1. Visitor（访问者接口）：声明访问具体元素的visit方法
2. ConcreteVisitor（具体访问者）：实现访问者接口的具体操作
3. Element（元素接口）：定义accept方法接受访问者
4. ConcreteElement（具体元素）：实现元素接口的具体类
5. ObjectStructure（对象结构）：包含元素的集合，提供访问入口

应用场景

• 需要对复杂对象结构（如组合结构）执行多种不相关的操作
• 需要在不改变元素类的前提下增加新的操作
• 需要对对象结构中的元素执行多种不同且不相关的操作

使用

电脑配件的显示

• 访问者接口 (电脑访问者（键盘、显示屏）)

  /**
   * 访问者模式-访问者接口：电脑
   * @Author：lyj
   * @Date：2025/5/22 10:59
   */
  public interface ComputerPartVisitor {
      /**
       * 访问者访问电脑
       * @param keyyboard
       */
      public void visit(Keyyboard keyyboard);
      /**
       * 访问者访问显示器
       * @param monitor
       */
      public void visit(Monitor monitor);
  }
  

• 具体访问者 (显示电脑部件信息)

  /**
   * 访问者模式-具体访问者：显示部件信息
   * @Date：2025/5/22 11:22
   */
  public class ComputerPartDisplayVistor implements ComputerPartVisitor {
      @Override
      public void visit(Keyyboard keyyboard) {
          System.out.println("显示键盘信息");
      }
  
      @Override
      public void visit(Monitor monitor) {
          System.out.println("显示显示器信息");
      }
  }
  

• 元素接口 (电脑接口)

  /**
   * 访问者模式-元素接口 ：电脑
   * @Author：lyj
   * @Date：2025/5/22 10:54
   */
  public interface ComputerPart {
      /**
       * 接受访问者
       * @param visitor
       */
      public void accept(ComputerPartVisitor visitor);
  }
  

• 具体元素 （键盘、显示屏）

  /**
   * 访问者模式-具体元素：键盘
   * @Date：2025/5/22 11:01
   */
  public class Keyyboard implements ComputerPart {
      @Override
      public void accept(ComputerPartVisitor visitor) {
          visitor.visit(this);
      }
  }
  

  /**
   * 访问者模式-具体元素：显示器
   * @Author：lyj
   * @Date：2025/5/22 11:02
   */
  public class Monitor implements ComputerPart{
      @Override
      public void accept(ComputerPartVisitor visitor) {
          visitor.visit(this);
      }
  }
  

• 对象结构

/**
 * 访问者模式-对象结构：电脑
 * @Author：lyj
 * @Date：2025/5/22 11:20
 */
public class Computer implements ComputerPart {
    ComputerPart[] parts;
    public Computer(){
        parts = new ComputerPart[]{
                new Keyyboard(),
                new Monitor()
        };
    }
    @Override
    public void accept(ComputerPartVisitor visitor) {
       for (ComputerPart part:parts){
           part.accept(visitor);
       }
    }
}

运行客户端：

Computer computer = new Computer();
computer.accept(new ComputerPartDisplayVistor());

运行结果：