• 设计模式——中介者模式、迭代器模式、访问者模式（双分派）（行为型模式）

    1.中介者模式

    中介者模式包含以下主要角色：

    • 抽象中介者（Mediator）角色：它是中介者的接口，提供了同事对象注册与转发同事对象信息的抽象方法。

    • 具体中介者（ConcreteMediator）角色：实现中介者接口，定义一个 List 来管理同事对象，协调各个同事角色之间的交互关系，因此它依赖于同事角色。

    • 抽象同事类（Colleague）角色：定义同事类的接口，保存中介者对象，提供同事对象交互的抽象方法，实现所有相互影响的同事类的公共功能。

    • 具体同事类（Concrete Colleague）角色：是抽象同事类的实现者，当需要与其他同事对象交互时，由中介者对象负责后续的交互。

    抽象中介者：

    1. //抽象中介者类
    2. public abstract class Mediator {
    3.  
    4.     //沟通的方法
    5.     public abstract void constact(String message, Person person);
    6. }

    具体中介者：

    1. //具体的中介者角色类
    2. public class MediatorStructure extends Mediator {
    3.  
    4.     //聚合房主和租房者对象
    5.     private HouseOwner houseOwner;
    6.     private Tenant tenant;
    7.  
    8.     public HouseOwner getHouseOwner() {
    9.         return houseOwner;
    10.     }
    11.  
    12.     public void setHouseOwner(HouseOwner houseOwner) {
    13.         this.houseOwner = houseOwner;
    14.     }
    15.  
    16.     public Tenant getTenant() {
    17.         return tenant;
    18.     }
    19.  
    20.     public void setTenant(Tenant tenant) {
    21.         this.tenant = tenant;
    22.     }
    23.  
    24.     @Override
    25.     public void constact(String message, Person person) {
    26.         if(person == houseOwner) {
    27.             tenant.getMessage(message);
    28.         } else {
    29.             houseOwner.getMessage(message);
    30.         }
    31.     }
    32. }

    抽象同事类：

    1. //抽象同事类
    2. public abstract class Person {
    3.  
    4.     protected String name;
    5.     protected Mediator mediator;
    6.  
    7.     public Person(String name, Mediator mediator) {
    8.         this.name = name;
    9.         this.mediator = mediator;
    10.     }
    11.  
    12.     //和中介联系（沟通）
    13.     public void constact(String message) {
    14.         mediator.constact(message, this);
    15.     }
    16. }

    具体同事类：

    1. //租房者：具体的同事角色类
    2. public class Tenant extends Person {
    3.     public Tenant(String name, Mediator mediator) {
    4.         super(name, mediator);
    5.     }
    6.  
    7.     //获取信息
    8.     public void getMessage(String message) {
    9.         System.out.println("租房者" + name + "获取到的信息是：" + message);
    10.     }
    11. }
    12.  
    13.  
    14. //房主类： 具体的同事角色类
    15. public class HouseOwner extends Person {
    16.  
    17.     public HouseOwner(String name, Mediator mediator) {
    18.         super(name, mediator);
    19.     }
    20.  
    21.     //获取信息
    22.     public void getMessage(String message) {
    23.         System.out.println("房主" + name + "获取到的信息是：" + message);
    24.     }
    25. }

    测试类：

    1. public class Client {
    2.     public static void main(String[] args) {
    3.         //创建中介者对象
    4.         MediatorStructure mediator = new MediatorStructure();
    5.  
    6.         //创建租房者对象
    7.         Tenant tenant = new Tenant("李四", mediator);
    8.         //创建房主对象
    9.         HouseOwner houseOwner = new HouseOwner("张三", mediator);
    10.  
    11.         //中介者要知道具体的房主和租房者
    12.         mediator.setTenant(tenant);
    13.         mediator.setHouseOwner(houseOwner);
    14.  
    15.         tenant.constact("我要租三室的房子！！！");
    16.         houseOwner.constact("我这里有三室的房子，你要租吗？");
    17.         //房主张三获取到的信息是：我要租三室的房子！！！
    18.         //租房者李四获取到的信息是：我这里有三室的房子，你要租吗？
    19.     }
    20. }

    2.迭代器模式

    迭代器模式主要包含以下角色：

    • 抽象聚合（Aggregate）角色：定义存储、添加、删除聚合元素以及创建迭代器对象的接口。

    • 具体聚合（ConcreteAggregate）角色：实现抽象聚合类，返回一个具体迭代器的实例。

    • 抽象迭代器（Iterator）角色：定义访问和遍历聚合元素的接口，通常包含 hasNext()、next() 等方法。

    • 具体迭代器（Concretelterator）角色：实现抽象迭代器接口中所定义的方法，完成对聚合对象的遍历，记录遍历的当前位置。

    存储的实体类：

    1.  
    2. public class Student {
    3.     private String name;
    4.     private String number;
    5.  
    6.     public Student() {
    7.     }
    8.  
    9.     public Student(String name, String number) {
    10.         this.name = name;
    11.         this.number = number;
    12.     }
    13.  
    14.     public String getName() {
    15.         return name;
    16.     }
    17.  
    18.     public void setName(String name) {
    19.         this.name = name;
    20.     }
    21.  
    22.     public String getNumber() {
    23.         return number;
    24.     }
    25.  
    26.     public void setNumber(String number) {
    27.         this.number = number;
    28.     }
    29.  
    30.     @Override
    31.     public String toString() {
    32.         return "Student{" +
    33.                 "name='" + name + '\'' +
    34.                 ", number='" + number + '\'' +
    35.                 '}';
    36.     }
    37. }

    抽象聚合：

    1. //抽象聚合角色接口
    2. public interface StudentAggregate {
    3.  
    4.     //添加学生功能
    5.     void addStudent(Student stu);
    6.  
    7.     //删除学生功能
    8.     void removeStudent(Student stu);
    9.  
    10.     //获取迭代器对象功能
    11.     StudentIterator getStudentIterator();
    12. }

    具体聚合：

    1. import java.util.ArrayList;
    2. import java.util.List;
    3.  
    4. //具体聚合角色类
    5. public class StudentAggregateImpl implements StudentAggregate {
    6.  
    7.     private List list = new ArrayList<>();
    8.  
    9.     @Override
    10.     public void addStudent(Student stu) {
    11.         list.add(stu);
    12.     }
    13.  
    14.     @Override
    15.     public void removeStudent(Student stu) {
    16.         list.remove(stu);
    17.     }
    18.  
    19.     @Override
    20.     //获取迭代器对象
    21.     public StudentIterator getStudentIterator() {
    22.         return new StudentIteratorImpl(list);
    23.     }
    24. }

    抽象迭代器：

    1. //抽象迭代器角色接口
    2. public interface StudentIterator {
    3.  
    4.     //判断是否还有元素
    5.     boolean hasNext();
    6.  
    7.     //获取下一个元素
    8.     Student next();
    9. }

    具体迭代器：

    1. import java.util.List;
    2.  
    3. //具体迭代器角色类
    4. public class StudentIteratorImpl implements StudentIterator {
    5.  
    6.     private List list;
    7.     private int position = 0;//用来记录遍历时的位置
    8.  
    9.     public StudentIteratorImpl(List list) {
    10.         this.list = list;
    11.     }
    12.  
    13.     @Override
    14.     public boolean hasNext() {
    15.         return position < list.size();
    16.     }
    17.  
    18.     @Override
    19.     public Student next() {
    20.         //从集合中获取指定位置的元素
    21.         Student currentStudent = list.get(position);
    22.         position++;
    23.         return currentStudent;
    24.     }
    25. }

    Java源码中的集合迭代器

    1. public class IteratorDemo {
    2.     public static void main(String[] args) {
    3.         ArrayList arr = new ArrayList<>();
    4.         for (int i = 0; i < 20; i++) {
    5.             arr.add(i);
    6.         }
    7.         Iterator iterator = arr.iterator();
    8.         while (iterator.hasNext()) {
    9.             Integer next = iterator.next();
    10.             System.out.println(next);
    11.         }
    12.     }
    13. }
    1. public class ArrayList{
    2.  
    3.     public Iterator iterator() {
    4.         return new Itr();
    5.     }
    6.  
    7.  
    8.     private class Itr implements Iterator {
    9.         int cursor;       // index of next element to return
    10.         int lastRet = -1; // index of last element returned; -1 if no such
    11.         int expectedModCount = modCount;
    12.  
    13.         public boolean hasNext() {
    14.             return cursor != size;
    15.         }
    16.  
    17.         @SuppressWarnings("unchecked")
    18.         public E next() {
    19.             checkForComodification();
    20.             int i = cursor;
    21.             if (i >= size)
    22.                 throw new NoSuchElementException();
    23.             Object[] elementData = ArrayList.this.elementData;
    24.             if (i >= elementData.length)
    25.                 throw new ConcurrentModificationException();
    26.             cursor = i + 1;
    27.             return (E) elementData[lastRet = i];
    28.         }
    29.  
    30. }
    31.  
    32.  
    33. public interface Iterator {
    34.  
    35.     boolean hasNext();
    36.  
    37.     E next();
    38.  
    39.     default void remove() {
    40.         throw new UnsupportedOperationException("remove");
    41.     }
    42.  
    43.     default void forEachRemaining(Consumersuper E> action) {
    44.         Objects.requireNonNull(action);
    45.         while (hasNext())
    46.             action.accept(next());
    47.     }
    48. }

    3.访问者模式

    访问者模式包含以下主要角色:

    • 抽象访问者（Visitor）角色：定义了对每一个元素（Element）访问的行为，它的参数就是可以访问的元素，它的方法个数理论上来讲与元素类个数（Element的实现类个数）是一样的，从这点不难看出，访问者模式要求元素类的个数不能改变。

    • 具体访问者（ConcreteVisitor）角色：给出对每一个元素类访问时所产生的具体行为。

    • 抽象元素（Element）角色：定义了一个接受访问者的方法（accept），其意义是指，每一个元素都要可以被访问者访问。

    • 具体元素（ConcreteElement）角色： 提供接受访问方法的具体实现，而这个具体的实现，通常情况下是使用访问者提供的访问该元素类的方法。

    • 对象结构（Object Structure）角色：定义当中所提到的对象结构，对象结构是一个抽象表述，具体点可以理解为一个具有容器性质或者复合对象特性的类，它会含有一组元素（Element），并且可以迭代这些元素，供访问者访问。

    抽象访问者：

    1. //喂食的人：抽象访问者角色类
    2. public interface Person {
    3.  
    4.     //喂食宠物狗
    5.     void feed(Cat cat);
    6.     //喂食宠物猫
    7.     void feed(Dog dog);
    8. }

    具体访问者：

    1. //主人：体访问者角色类
    2. public class Owner implements Person {
    3.  
    4.     @Override
    5.     public void feed(Cat cat) {
    6.         System.out.println("主人喂食猫");
    7.     }
    8.  
    9.     @Override
    10.     public void feed(Dog dog) {
    11.         System.out.println("主人喂食狗");
    12.     }
    13. }
    14.  
    15.  
    16. //其他人:具体访问者角色类
    17. public class Someone implements Person {
    18.  
    19.     @Override
    20.     public void feed(Cat cat) {
    21.         System.out.println("其他人喂食猫");
    22.     }
    23.  
    24.     @Override
    25.     public void feed(Dog dog) {
    26.         System.out.println("其他人喂食狗");
    27.     }
    28. }

    抽象元素：

    1. //宠物：抽象元素角色类
    2. public interface Animal {
    3.  
    4.     //接受访问者访问的功能
    5.     void accept(Person person);
    6. }

    具体元素：

    1. //宠物猫：具体元素角色类
    2. public class Cat implements Animal {
    3.  
    4.     @Override
    5.     public void accept(Person person) {
    6.         person.feed(this); //访问者给宠物猫喂食
    7.         System.out.println("好好吃，喵喵喵。。。");
    8.     }
    9. }
    10.  
    11.  
    12. //宠物狗：具体元素角色类
    13. public class Dog implements Animal {
    14.  
    15.     @Override
    16.     public void accept(Person person) {
    17.         person.feed(this); //访问者给宠物猫喂食
    18.         System.out.println("好好吃，汪汪汪。。。");
    19.     }
    20. }

    对象结构：

    1. //对象结构类
    2. public class Home {
    3.  
    4.     //声明一个集合对象，用来存储元素对象
    5.     private List nodeList = new ArrayList<>();
    6.  
    7.     //添加元素功能
    8.     public void add(Animal animal) {
    9.         nodeList.add(animal);
    10.     }
    11.  
    12.     public void action(Person person) {
    13.         //遍历集合，获取每一个元素，让访问者访问每一个元素
    14.         for (Animal animal : nodeList) {
    15.             animal.accept(person);
    16.         }
    17.     }
    18. }

    测试类 ：

    1. public class Client {
    2.     public static void main(String[] args) {
    3.         //创建Home对象
    4.         Home home = new Home();
    5.  
    6.         //添加元素到Home对象中
    7.         home.add(new Dog());
    8.         home.add(new Cat());
    9.  
    10.         //创建主人对象
    11.         Owner owner = new Owner();
    12.         
    13.         //让主人喂食所有的宠物
    14.         home.action(owner);
    15.     }
    16. }

    优缺点

    1，优点：

    • 扩展性好

      在不修改对象结构中的元素的情况下，为对象结构中的元素添加新的功能。

    • 复用性好

      通过访问者来定义整个对象结构通用的功能，从而提高复用程度。

    • 分离无关行为

      通过访问者来分离无关的行为，把相关的行为封装在一起，构成一个访问者，这样每一个访问者的功能都比较单一。

    2，缺点：

    • 对象结构变化很困难

      在访问者模式中，每增加一个新的元素类，都要在每一个具体访问者类中增加相应的具体操作，这违背了“开闭原则”。

    • 违反了依赖倒置原则

      访问者模式依赖了具体类，而没有依赖抽象类。

    使用场景

    • 对象结构相对稳定，但其操作算法经常变化的程序。

    • 对象结构中的对象需要提供多种不同且不相关的操作，而且要避免让这些操作的变化影响对象的结构。

    双分派技术

    访问者模式用到了一种双分派的技术。

    分派

    变量被声明时的类型叫做变量的静态类型，有些人又把静态类型叫做明显类型；而变量所引用的对象的真实类型又叫做变量的实际类型。比如 Map map = new HashMap() ，map变量的静态类型是 Map ，实际类型是 HashMap 。根据对象的类型而对方法进行的选择，就是分派(Dispatch)，分派(Dispatch)又分为两种，即静态分派和动态分派。

    静态分派(Static Dispatch)

    发生在编译时期，分派根据静态类型信息发生。静态分派对于我们来说并不陌生，方法重载就是静态分派。

    ！！！重载方法的分派是根据静态类型进行的，这个分派过程在编译时期就完成了！！！

    1.  
    2. /**
    3.  * 静态分派
    4.  * 发生在编译时期，分派根据静态类型信息发生。
    5.  * 方法重载就是静态分派。
    6.  *
    7.  * ！！！重载方法的分派是根据静态类型进行的，这个分派过程在编译时期就完成了
    8.  */
    9. public class demo2 {
    10.     public static void main(String[] args) {
    11.         Animal a = new Animal();
    12.         Animal a1 = new Dog();
    13.         Animal a2 = new Cat();
    14.  
    15.         Execute exe = new Execute();
    16.         exe.execute(a);//Animal
    17.         exe.execute(a1);//Animal
    18.         exe.execute(a2);//Animal
    19.  
    20.     }
    21. }
    22.  
    23. class Animal {
    24. }
    25.  
    26. class Dog extends Animal {
    27. }
    28.  
    29. class Cat extends Animal {
    30. }
    31.  
    32. class Execute {
    33.     public void execute(Animal a) {
    34.         System.out.println("Animal");
    35.     }
    36.  
    37.     public void execute(Dog d) {
    38.         System.out.println("dog");
    39.     }
    40.  
    41.     public void execute(Cat c) {
    42.         System.out.println("cat");
    43.     }
    44. }

    动态分派(Dynamic Dispatch)

    发生在运行时期，动态分派动态地置换掉某个方法。Java通过方法的重写支持动态分派。

    1.  
    2. /**
    3.  * 动态分派
    4.  * 发生在运行时期，动态分派动态地置换掉某个方法
    5.  * Java通过方法的重写支持动态分派。
    6.  */
    7. public class demo1 {
    8.     public static void main(String[] args) {
    9.         Animal a = new Dog();
    10.         a.execute();//dog
    11.  
    12.         Animal a1 = new Cat();
    13.         a1.execute();//cat
    14.     }
    15. }
    16.  
    17. class Animal {
    18.     public void execute() {
    19.         System.out.println("Animal");
    20.     }
    21. }
    22.  
    23. class Dog extends Animal {
    24.     @Override
    25.     public void execute() {
    26.         System.out.println("dog");
    27.     }
    28. }
    29.  
    30. class Cat extends Animal {
    31.     @Override
    32.     public void execute() {
    33.         System.out.println("cat");
    34.     }
    35. }
    36.

    双分派

     * 第一次分派：将Execute对象做为参数传递给Animal类型的变量调用的方法。这里是方法重写，所以是动态分派
     * 第二次分派：将自己this（也就是实际类型）作为参数传递进去，这里的Execute类中有多个重载的方法，所以是静态分派

    1.  
    2. /**
    3.  * 双分派
    4.  * 第一次分派：将Execute对象做为参数传递给Animal类型的变量调用的方法。这里是方法重写，所以是动态分派
    5.  * 第二次分派：将自己this（也就是实际类型）作为参数传递进去，这里的Execute类中有多个重载的方法，所以是静态分派
    6.  */
    7. class demo3 {
    8.     public static void main(String[] args) {
    9.         Animal a = new Animal();
    10.         Animal d = new Dog();
    11.         Animal c = new Cat();
    12.  
    13.         Execute exe = new Execute();
    14.         a.accept(exe);//animal
    15.         d.accept(exe);//dog
    16.         c.accept(exe);//cat
    17.     }
    18. }
    19.  
    20. class Animal {
    21.     public void accept(Execute exe) {
    22.         exe.execute(this);
    23.     }
    24. }
    25.  
    26. class Dog extends Animal {
    27.     public void accept(Execute exe) {
    28.         exe.execute(this);
    29.     }
    30. }
    31.  
    32. class Cat extends Animal {
    33.     public void accept(Execute exe) {
    34.         exe.execute(this);
    35.     }
    36. }
    37.  
    38. class Execute {
    39.     public void execute(Animal a) {
    40.         System.out.println("animal");
    41.     }
    42.  
    43.     public void execute(Dog d) {
    44.         System.out.println("dog");
    45.     }
    46.  
    47.     public void execute(Cat c) {
    48.         System.out.println("cat");
    49.     }
    50. }

  • 相关阅读:
    无法信任 ASP.NET Core 中的本地 HTTPS 证书
    基于单片机设计的气压与海拔高度检测计(采用MPL3115A2芯片实现)
    springboot快速入门一篇文章全
    bugku-web-文件上传
    依赖配置与依赖传递
    标记二肽Dansyl-Ala-Arg、87687-46-5
    WebSocket 详细教程
    FreeRTOS自我救赎3之USB虚拟串口
    git：多分支管理
    【云原生之k8s】K8s 管理工具 kubectl 详解（二）
  • 原文地址：https://blog.csdn.net/m0_63544124/article/details/126047511