• 设计模式：访问者模式（C#、JAVA、JavaScript、C++、Python、Go、PHP）

    上一篇《状态模式》                                                                     下一篇《原型模式》

    简介：

    访问者模式，它是一种将数据操作与数据结构分离的设计模式，它属于行为型模式。访问者模式的基本思想是，针对系统中拥有固定类型数的对象结构（元素），在其内提供一个accept()方法用来接受访问者对象的访问。不同的访问者对同一元素的访问内容不同，使得相同的元素集合可以产生不同的数据结果。accept()方法可以接收不同的访问者对象，然后在内部将自己（元素）转发到接收到的访问者对象的visit()方法内。访问者内部对应类型的visit()方法就会得到回调执行，对元素进行操作。

    访问者模式的使用场景：
    1、操作复杂且频繁的数据结构：当需要对一个复杂且频繁变化的数据结构进行操作时，如遍历、查找、统计等，使用访问者模式可以提高代码的可维护性和可复用性。
    2、数据结构需要频繁修改：如果数据结构需要频繁修改，而操作又需要与数据结构保持相对独立，这时可以使用访问者模式。通过将操作封装在访问者类中，可以在不修改元素类的情况下增加新的操作，降低了元素类和操作之间的耦合度。
    3、需要对数据结构进行复杂的操作：当需要对数据结构进行复杂的操作时，如需要对元素进行自定义的访问、更新、删除等操作，使用访问者模式可以将这些操作封装在访问者类中，使代码更加清晰和易于维护。
    4、需要对数据结构进行自定义的查询：当需要对数据结构进行自定义的查询时，如需要根据特定条件对元素进行筛选、排序等操作，使用访问者模式可以将查询逻辑封装在访问者类中，使代码更加灵活和可扩展。

    访问者模式的创建步骤：
    1、定义元素类：首先需要定义元素类，这些元素类构成了数据结构的基本单元。元素类通常具有一些公共的方法，如accept()，用于接受访问者的访问。
    2、定义访问者接口：然后需要定义访问者接口，这个接口为元素类定义了访问的方法。访问者接口通常具有一个visit()方法，用于访问元素对象。
    3、实现访问者类：接着需要实现访问者接口，创建访问者类。访问者类通常具有visit()方法的具体实现，用于对元素对象进行操作。
    实现元素类的accept()方法：在元素类中实现accept()方法，这个方法接受一个访问者对象作为参数，并在内部将自己转发到接收到的访问者对象的visit()方法内。
    4、使用访问者模式：最后，可以通过创建元素对象和访问者对象，并调用元素对象的accept()方法来使用访问者模式。accept()方法会将自己转发到访问者对象的visit()方法内，从而实现对元素对象的操作。

    访问者模式的优点，主要包括：
    1、扩展性好：访问者模式使得增加新的操作变得很容易，只需要添加一个新的访问者类即可。这提高了系统的可扩展性和可维护性。
    2、复用性好：访问者模式可以将有关的行为集中到一个访问者对象中，而不是分散到一个个的节点类中。这提高了系统的复用程度，并且可以避免在每个元素类中都重复实现相同的行为。
    3、灵活性好：访问者模式将数据结构与作用于结构上的操作解耦，使得操作集合可相对自由地演化而不影响系统的数据结构。这使得系统更加灵活，能够适应不同的需求和变化。
    4、符合单一职责原则：访问者模式把相关的行为封装在一起，构成一个访问者，使每一个访问者的功能都比较单一。这符合单一职责原则，使得代码更加清晰和易于维护。
    5、便于积累状态：每一个单独的访问者对象都集中了相关的行为，从而也就可以在访问的过程中将执行操作的状态积累在自己内部，而不是分散到很多的节点对象中。这有利于系统状态的积累和管理。

    访问者模式的缺点，主要包括：
    1、破坏封装：访问者模式要求访问者对象访问并调用每一个节点对象的操作，这隐含了一个对所有节点对象的要求：它们必须暴露一些自己的操作和内部状态。这破坏了对象的封装性。
    2、违反了依赖倒置原则：访问者模式依赖了具体类，而没有依赖抽象类。这违反了依赖倒置原则，使得代码的维护和扩展性降低。
    3、增加新的节点类变得困难：每增加一个新的节点都意味着要在抽象访问者角色中增加一个新的抽象操作，并在每一个具体访问者类中增加相应的具体操作。这使得系统的扩展性降低。
    4、实现复杂：访问者模式需要定义访问者接口和实现访问者类，这会增加代码的复杂度和维护成本。同时，使用访问者模式需要对数据结构进行修改，这也会增加实现的难度和复杂度。

    总之，访问者模式虽然可以提高系统的可扩展性和灵活性，但也存在一些缺点，需要在设计时权衡考虑。

    示例：

    一、C#访问者模式

    以下是一个示例，展示了如何在C#中实现访问者模式：

    1. //首先定义一个访问者接口：
    2. public interface IVisitor  
    3. {  
    4.     void Visit(ConcreteElement1 element);  
    5.     void Visit(ConcreteElement2 element);  
    6. }
    7. //然后定义一个抽象元素类和具体元素类：
    8. public abstract class Element  
    9. {  
    10.     public void Accept(IVisitor visitor)  
    11.     {  
    12.         visitor.Visit(this);  
    13.     }  
    14. }  
    15.   
    16. public class ConcreteElement1 : Element  
    17. {  
    18.     public void SomeOperation1()  
    19.     {  
    20.         Console.WriteLine("ConcreteElement1 operation");  
    21.     }  
    22. }  
    23.   
    24. public class ConcreteElement2 : Element  
    25. {  
    26.     public void SomeOperation2()  
    27.     {  
    28.         Console.WriteLine("ConcreteElement2 operation");  
    29.     }  
    30. }
    31. //接下来定义一个访问者类：
    32. public class Visitor : IVisitor  
    33. {  
    34.     public void Visit(ConcreteElement1 element)  
    35.     {  
    36.         element.SomeOperation1();  
    37.     }  
    38.   
    39.     public void Visit(ConcreteElement2 element)  
    40.     {  
    41.         element.SomeOperation2();  
    42.     }  
    43. }
    44. //最后在客户端代码中使用访问者模式：
    45. public static void Main(string[] args)  
    46. {  
    47.     ConcreteElement1 element1 = new ConcreteElement1();  
    48.     ConcreteElement2 element2 = new ConcreteElement2();  
    49.     Visitor visitor = new Visitor();  
    50.     element1.Accept(visitor); // 调用操作1  
    51.     element2.Accept(visitor); // 调用操作2  
    52. }

    二、java访问者模式

    访问者模式通常通过以下方式实现：
     

    1. //定义元素接口（Element Interface）
    2. public interface Element {  
    3.     void accept(Visitor visitor);  
    4. }
    5. //定义访问者接口（Visitor Interface）
    6. public interface Visitor {  
    7.     void visit(ConcreteElement1 element);  
    8.     void visit(ConcreteElement2 element);  
    9. }
    10. //创建元素类（Concrete Element Classes）
    11. public class ConcreteElement1 implements Element {  
    12.     @Override  
    13.     public void accept(Visitor visitor) {  
    14.         visitor.visit(this);  
    15.     }  
    16. }    
    17. public class ConcreteElement2 implements Element {  
    18.     @Override  
    19.     public void accept(Visitor visitor) {  
    20.         visitor.visit(this);  
    21.     }  
    22. }
    23. //创建访问者类（Concrete Visitor Classes）
    24. public class Visitor implements Visitor {  
    25.     @Override  
    26.     public void visit(ConcreteElement1 element) {  
    27.         // 对元素对象进行操作  
    28.     }  
    29.   
    30.     @Override  
    31.     public void visit(ConcreteElement2 element) {  
    32.         // 对元素对象进行操作  
    33.     }  
    34. }
    35. //在客户端代码中使用访问者模式
    36. public static void main(String[] args) {  
    37.     ConcreteElement1 element1 = new ConcreteElement1();  
    38.     ConcreteElement2 element2 = new ConcreteElement2();  
    39.     Visitor visitor = new Visitor();  
    40.     element1.accept(visitor); // 调用操作1  
    41.     element2.accept(visitor); // 调用操作2  
    42. }

    三、javascript访问者模式

    在JavaScript中，访问者实现方式如下：
     

    1. //定义元素接口（Element Interface）
    2. const Element = {  
    3.   accept: function(visitor) {  
    4.     visitor.visit(this);  
    5.   }  
    6. };
    7. //定义访问者接口（Visitor Interface）
    8. const Visitor = {  
    9.   visit: function(element) {  
    10.     // 对元素对象进行操作  
    11.   }  
    12. };
    13. //创建元素类（Concrete Element Classes）
    14. class ConcreteElement1 extends Element {  
    15.   constructor() {  
    16.     super();  
    17.   }  
    18. }  
    19.   
    20. class ConcreteElement2 extends Element {  
    21.   constructor() {  
    22.     super();  
    23.   }  
    24. }
    25. //创建访问者类（Concrete Visitor Classes）
    26. class Visitor1 extends Visitor {  
    27.   visit(element) {  
    28.     // 对元素对象进行操作1  
    29.   }  
    30. }  
    31.   
    32. class Visitor2 extends Visitor {  
    33.   visit(element) {  
    34.     // 对元素对象进行操作2  
    35.   }  
    36. }
    37. //在客户端代码中使用访问者模式
    38. const element1 = new ConcreteElement1();  
    39. const element2 = new ConcreteElement2();  
    40. const visitor1 = new Visitor1();  
    41. const visitor2 = new Visitor2();  
    42. element1.accept(visitor1); // 调用操作1  
    43. element2.accept(visitor2); // 调用操作2

    四、C++访问者模式

    以下是在C++中实现访问者模式：

    1. //定义元素接口（Element Interface）
    2. class Element {  
    3. public:  
    4.   virtual void accept(Visitor* visitor) = 0;  
    5. };
    6. //定义访问者接口（Visitor Interface）
    7. class Visitor {  
    8. public:  
    9.   virtual void visit(ConcreteElement1* element) = 0;  
    10.   virtual void visit(ConcreteElement2* element) = 0;  
    11. };
    12. //创建元素类（Concrete Element Classes）
    13. class ConcreteElement1 : public Element {  
    14. public:  
    15.   void accept(Visitor* visitor) override {  
    16.     visitor->visit(this);  
    17.   }  
    18. };  
    19.   
    20. class ConcreteElement2 : public Element {  
    21. public:  
    22.   void accept(Visitor* visitor) override {  
    23.     visitor->visit(this);  
    24.   }  
    25. };
    26. //创建访问者类（Concrete Visitor Classes）
    27. class Visitor1 : public Visitor {  
    28. public:  
    29.   void visit(ConcreteElement1* element) override {  
    30.     // 对元素对象进行操作1  
    31.   }  
    32. };  
    33.   
    34. class Visitor2 : public Visitor {  
    35. public:  
    36.   void visit(ConcreteElement2* element) override {  
    37.     // 对元素对象进行操作2  
    38.   }  
    39. };
    40. //在客户端代码中使用访问者模式
    41. int main() {  
    42. 	ConcreteElement1* element1 = new ConcreteElement1();  
    43. 	ConcreteElement2* element2 = new ConcreteElement2();  
    44. 	Visitor* visitor1 = new Visitor1();  
    45. 	Visitor* visitor2 = new Visitor2();  
    46. 	element1->accept(visitor1); // 调用操作1  
    47. 	element2->accept(visitor2); // 调用操作2
    48. }

    五、python访问者模式

    以下是在python中实现访问者模式：

    1. //定义元素接口（Element Interface）
    2. from abc import ABC, abstractmethod  
    3.   
    4. class Element(ABC):  
    5.     @abstractmethod  
    6.     def accept(self, visitor):  
    7.         pass
    8. //定义访问者接口（Visitor Interface）
    9. class Visitor(ABC):  
    10.     @abstractmethod  
    11.     def visit(self, element):  
    12.         pass
    13. //创建元素类（Concrete Element Classes）
    14. class ConcreteElement1(Element):  
    15.     def accept(self, visitor):  
    16.         visitor.visit(self)  
    17.   
    18. class ConcreteElement2(Element):  
    19.     def accept(self, visitor):  
    20.         visitor.visit(self)
    21. //创建访问者类（Concrete Visitor Classes）
    22. class Visitor1(Visitor):  
    23.     def visit(self, element):  
    24.         # 对元素对象进行操作1  
    25.         pass  
    26.   
    27. class Visitor2(Visitor):  
    28.     def visit(self, element):  
    29.         # 对元素对象进行操作2  
    30.         pass
    31. //在客户端代码中使用访问者模式
    32. if __name__ == '__main__':  
    33. 	element1 = ConcreteElement1()  
    34. 	element2 = ConcreteElement2()  
    35. 	visitor1 = Visitor1()  
    36. 	visitor2 = Visitor2()  
    37. 	element1.accept(visitor1) # 调用操作1  
    38. 	element2.accept(visitor2) # 调用操作2

    六、go访问者模式

    以下是一个示例，展示了如何在go中实现访问者模式：
     

    1. //首先，定义一个接口，表示元素：
    2. type Element interface {  
    3.  Accept(Visitor)  
    4. }
    5. //然后，定义一个接口，表示访问者：
    6. type Visitor interface {  
    7.  Visit(Element)  
    8. }
    9. //接下来，创建一些具体的元素类和访问者类：
    10. type ConcreteElement1 struct{}  
    11.   
    12. func (e *ConcreteElement1) Accept(v Visitor) {  
    13.  v.Visit(*e)  
    14. }  
    15.   
    16. type ConcreteElement2 struct{}  
    17.   
    18. func (e *ConcreteElement2) Accept(v Visitor) {  
    19.  v.Visit(*e)  
    20. }  
    21.   
    22. type ConcreteVisitor struct{}  
    23.   
    24. func (v *ConcreteVisitor) Visit(e Element) {  
    25.  // 对元素进行操作的具体实现  
    26.  fmt.Println("Visiting ConcreteElement1 or ConcreteElement2")  
    27. }
    28. //最后，在客户端代码中使用访问者模式：
    29. func main() {  
    30.  element1 := &ConcreteElement1{}  
    31.  element2 := &ConcreteElement2{}  
    32.  visitor := &ConcreteVisitor{}  
    33.   
    34.  element1.Accept(visitor) // 调用操作1  
    35.  element2.Accept(visitor) // 调用操作2  
    36. }

    七、PHP访问者模式

    以下是一个示例，展示了如何在PHP中实现访问者模式：

    1. //首先，定义一个接口，表示元素：
    2. interface Element {  
    3.     public function accept(Visitor $visitor);  
    4. }
    5. //然后，定义一个接口，表示访问者：
    6. interface Visitor {  
    7.     public function visit(Element $element);  
    8. }
    9. //接下来，创建一些具体的元素类和访问者类：
    10. class ConcreteElement implements Element {  
    11.     private $data;  
    12.       
    13.     public function __construct($data) {  
    14.         $this->data = $data;  
    15.     }  
    16.       
    17.     public function accept(Visitor $visitor) {  
    18.         $visitor->visit($this);  
    19.     }  
    20. }  
    21.   
    22. class ConcreteVisitor implements Visitor {  
    23.     public function visit(Element $element) {  
    24.         // 对元素进行操作的具体实现，例如：  
    25.         echo "Visiting element: " . $element->data . "\n";  
    26.     }  
    27. }
    28. //最后，在客户端代码中使用访问者模式：
    29. $element1 = new ConcreteElement("Element 1");  
    30. $element2 = new ConcreteElement("Element 2");  
    31. $visitor = new ConcreteVisitor();  
    32.   
    33. $element1->accept($visitor); // 调用操作1  
    34. $element2->accept($visitor); // 调用操作2


    《完结》

    上一篇《状态模式》                                                                 下一篇《原型模式》

  • 相关阅读:
    8.31总结 Element-UI
    linux三次握手、四次挥手
    STP介绍
    2. gin中间件注意事项、路由拆分与注册技巧
    银河麒麟v10制作openssh 9.1 p1 rpm —— 筑梦之路
    TGK-Planner无人机运动规划算法解读
    搭建Gitlab
    Linux-0-云服务器购买与配置
    Ubuntu 20.04 设置开机自启脚本
    小程序开发直传腾讯云操作步骤
  • 原文地址：https://blog.csdn.net/yetyrain/article/details/134049303