设计模式之访问者模式（C# / JavaScript / PHP / Java / Python 演示代码）

已于 2022-06-30 11:55:35 修改
阅读量186 收藏 1
点赞数
分类专栏： 设计模式 文章标签： 访问者模式 设计模式
于 2022-06-20 22:20:17 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dawn0718/article/details/125381552
版权

　　GoF定义：表示一个作用于某对象结构中的各元素的操作。它使你可以在不改变各元素的类的前提下定义作用于这些元素的新操作。

　　在访问者模式中，使用了一个访问者类来改变元素类的执行算法。通过这种方式，元素的执行算法可以随着访问者改变而改变。这种类型的设计模式属于行为型模式。根据这个模式，元素对象已接受访问者对象，这样访问者对象就可以处理元素对象上的操作。

　　简单理解：一个应用的内部多个模块不变，但是可以接收外部的指令来改变应用的功能。

　　1、C#代码演示：

class program
{
    static void Main(string[] args)
    {
        Console.WriteLine("系统执行：");
        Intergrator II = new Intergrator();
        II.Run();
        Console.WriteLine("系统接收访问者1的指令：");
        Visitor V1 = new Visitor1();
        II.Accept(V1);
        II.Run();
        Console.WriteLine("系统接收访问者2的指令：");
        Visitor V2 = new Visitor2();
        II.Accept(V2);
        II.Run();
    }
}

//定义受访者的结构
public abstract class Interviewee{
    private string CommandStr="";//命令
    public void Interviewss(string CommStr){
        CommandStr = CommStr;
    }
    public void UpdateCommand(string CommStr){
        CommandStr = CommStr;
    }

    public void Run(){
        Console.WriteLine("执行命令：{0}",CommandStr);
    }

    public abstract void Accept(Visitor V);
}

//受访者A
public class IntervieweeA : Interviewee {
    public override void Accept(Visitor V){
        V.VisitIntervieweeA(this);
    }
}

//受访者B
public class IntervieweeB : Interviewee
{
    public override void Accept(Visitor V){
        V.VisitIntervieweeB(this);
    }
}

//集成者：集成上面的两个被访问者
public class Intergrator{
    private IntervieweeA IA = new IntervieweeA();
    private IntervieweeB IB = new IntervieweeB();

    public Intergrator(){
        IA.UpdateCommand("执行初始化命令A");
        IB.UpdateCommand("执行初始化命令B");
    }

    public void Run(){
        IA.Run();
        IB.Run();
    }
    public void Accept(Visitor V){
        IA.Accept(V);
        IB.Accept(V);
    }
}

public interface Visitor{
    public void VisitIntervieweeA(IntervieweeA IA);
    public void VisitIntervieweeB(IntervieweeB IB);
}

public class Visitor1:Visitor{
    public void VisitIntervieweeA(IntervieweeA IA){
        IA.UpdateCommand("访问者1的新命令A");
    }
    public void VisitIntervieweeB(IntervieweeB IB){
        IB.UpdateCommand("访问者1的新命令B");
    }
}

public class Visitor2 : Visitor
{
    public void VisitIntervieweeA(IntervieweeA IA){
        IA.UpdateCommand("访问者2的新命令A");
    }
    public void VisitIntervieweeB(IntervieweeB IB){
        IB.UpdateCommand("访问者2的新命令B");
    }
}

　　控制台的输出：

 　　2、JavaScript代码演示：

<!DOCTYPE html>
<html>
	<head>
		<meta charset="utf-8">
		<title>访问者模式</title>
	</head>
	<body>
		<div id="demo"></div>
		<script>
			//定义被访问者的基础结构
			function Interviewee(){
				this.Command="";
				this.Run=function(){
					PrintInfo("执行命令："+this.Command);
				};
				this.UpdateCommand=function(CommStr){
					this.Command=CommStr;
				};
				this.Accept=function(V){
					
				}				
			}
			//被访问者1
			var IntervieweeA =new Interviewee();
			IntervieweeA.Accept=function(V){
				V.VisitIntervieweeA(this);
			}
			//被访问者2			
			var IntervieweeB =new Interviewee();
			IntervieweeB.Accept=function(V){
				V.VisitIntervieweeA(this);
			}
			//集成者：集成上面的两个被访问者			
			function Integrator(){
				this.IntervieweeA=IntervieweeA;
				this.IntervieweeB=IntervieweeB;
				this.IntervieweeA.Command="执行初始化命令A";
				this.IntervieweeB.Command="执行初始化命令B";
				this.Run=function(){
					this.IntervieweeA.Run();
					this.IntervieweeB.Run();
				};
				this.Accept=function(V){
					this.IntervieweeA.Accept(V);
					this.IntervieweeB.Accept(V);
				}
			}
			//定义访问者的结构
			function Visitor(){
				this.VisitIntervieweeA=function(){};
				this.VisitIntervieweeB=function(){};
			}
			//定义访问者1
			var Visitor1=new Visitor();
			Visitor1.VisitIntervieweeA=function(IA){
					IA.UpdateCommand("访问者1的新命令A");
			}
			Visitor1.VisitIntervieweeB=function(IB){
					IB.UpdateCommand("访问者1的新命令B");
			}
			//定义访问者2			
			var Visitor2=new Visitor();
			Visitor2.VisitIntervieweeA=function(IA){
					IA.UpdateCommand("访问者2的新命令A");
			Visitor2.VisitIntervieweeB=function(IB){
			}
					IB.UpdateCommand("访问者2的新命令B");
			}
			
			function PrintInfo(Str){
				document.getElementById("demo").innerHTML = document.getElementById("demo").innerHTML + Str+"<br>";
			}
			
			PrintInfo("系统执行：");
			II=new Integrator();
			II.Run();

			PrintInfo("系统接收访问者1的指令：");
			II=new Integrator(Visitor1);
			II.Run();

			PrintInfo("系统接收访问者2的指令：");
			II=new Integrator(Visitor2);
			II.Run();			
		</script>
	</body>
</html>

　　网页里的输出：

系统执行：
执行命令：执行初始化命令A
执行命令：执行初始化命令B
系统接收访问者1的指令：
执行命令：执行初始化命令A
执行命令：执行初始化命令B
系统接收访问者2的指令：
执行命令：执行初始化命令A
执行命令：执行初始化命令B

　　3、PHP代码演示：

<?php
	//定义被访问者的基础结构
	abstract class Interviewee{
		private $Command;//命令
		function __construct($Command){//初始化：接收命令
			$this->Command=$Command;
		}
		function Run(){//执行内部方法
			echo "执行命令:".$this->Command."<br>";
		}
		function UpdateCommand($Command){//更新命令
			$this->Command=$Command;
		}
		abstract function Accept(Visitor $V);//定义接收访问者的动作
	}

	class IntervieweeA extends Interviewee{
		function Accept(Visitor $V){
			$V->VisitIntervieweeA($this);//将自己交给访问者来访问
		}
	}

	class IntervieweeB extends Interviewee{
		function Accept(Visitor $V){
			$V->VisitIntervieweeB($this);//将自己交给访问者来访问
		}
	}

	class Integrator{//集成者:集成上述两个被访问者
		private $IntervieweeA;
		private $IntervieweeB;
		function __construct(){
			$this->IntervieweeA=new IntervieweeA("执行初始化命令A");
			$this->IntervieweeB=new IntervieweeB("执行初始化命令B");			
		}
		function Run(){
			$this->IntervieweeA->Run();
			$this->IntervieweeB->Run();
		}
		function Accept(Visitor $V){
			$this->IntervieweeA->Accept($V);
			$this->IntervieweeB->Accept($V);			
		}
	}
	
	interface Visitor{
		function VisitIntervieweeA(IntervieweeA $IA);
		function VisitIntervieweeB(IntervieweeB $IB);		
	}

	class Visitor1 implements Visitor{
		function VisitIntervieweeA(IntervieweeA $IA){
			$IA->UpdateCommand("访问者1的新命令A");
		}
		function VisitIntervieweeB(IntervieweeB $IB){
			$IB->UpdateCommand("访问者1的新命令B");			
		}		
	}

	class Visitor2 implements Visitor{
		function VisitIntervieweeA(IntervieweeA $IA){
			$IA->UpdateCommand("访问者2的新命令A");
		}
		function VisitIntervieweeB(IntervieweeB $IB){
			$IB->UpdateCommand("访问者2的新命令B");			
		}		
	}
	
	echo "系统执行：<br>";
	$I=new Integrator;
	$I->Run();
	echo "<br>";
	echo "系统接收访问者1的指令：<br>";
	$V1=new Visitor1;
	$I->Accept($V1);
	$I->Run();
	echo "<br>";
	echo "系统接收访问者2的指令：<br>";
	$V2=new Visitor2;
	$I->Accept($V2);
	$I->Run();
?>

　　网页里的输出：

系统执行：
执行命令:执行初始化命令A
执行命令:执行初始化命令B

系统接收访问者1的指令：
执行命令:访问者1的新命令A
执行命令:访问者1的新命令B

系统接收访问者2的指令：
执行命令:访问者2的新命令A
执行命令:访问者2的新命令B

　　4、Java代码演示：

class DesignModeVistor {
	public static void main(String[] args) {
        System.out.println("系统执行：");
        Intergrator II = new Intergrator();
        II.Run();

        System.out.println("系统接收访问者1的指令：");		
        Visitor V1 = new Visitor1();
        II.Accept(V1);
        II.Run();
		
        System.out.println("系统接收访问者2的指令：");
        Visitor V2 = new Visitor2();
        II.Accept(V2);
        II.Run();
	}
}

//定义受访者的抽象类
abstract class Interviewee{
	protected String CommandStr="";//指令

	public void UpdateCommand(String CommStr){
		this.CommandStr=CommStr;
	}
	
	public void Run(){
		System.out.println("执行命令：" + this.CommandStr);
	}
	
	public abstract void Accept(Visitor V);
}

//受访问者A
class IntervieweeA extends Interviewee {
	public IntervieweeA(String CommStr){
		super.CommandStr=CommStr;
	}
	
	public void Accept(Visitor V){
		V.VisitIntervieweeA(this);
	}
}

class IntervieweeB extends Interviewee {
	public IntervieweeB(String CommStr){
		super.CommandStr=CommStr;
	}
	public void Accept(Visitor V){
		V.VisitIntervieweeB(this);
	}
}

//集成者：集成受访问者A和受访问者B
class Intergrator{
	private IntervieweeA IA = new IntervieweeA("");
	private IntervieweeB IB = new IntervieweeB("");
	public Intergrator(){
		IA.UpdateCommand("执行初始化命令A");
		IB.UpdateCommand("执行初始化命令B");
	}
	
	public void Run(){
		IA.Run();
		IB.Run();
	}
	
	public void Accept(Visitor V){
		IA.Accept(V);
		IB.Accept(V);
	}
}

interface Visitor{
	public void VisitIntervieweeA(IntervieweeA IA);
	public void VisitIntervieweeB(IntervieweeB IB);
}

class Visitor1 implements Visitor{
    public void VisitIntervieweeA(IntervieweeA IA){
        IA.UpdateCommand("访问者1的新命令A");
    }
    public void VisitIntervieweeB(IntervieweeB IB){
        IB.UpdateCommand("访问者1的新命令B");
    }	
}

class Visitor2 implements Visitor
{
    public void VisitIntervieweeA(IntervieweeA IA){
        IA.UpdateCommand("访问者2的新命令A");
    }
    public void VisitIntervieweeB(IntervieweeB IB){
        IB.UpdateCommand("访问者2的新命令B");
    }
}

　　输出：

G:\Java>javac DesignModeVistor.java

G:\Java>java DesignModeVistor
系统执行：
执行命令：执行初始化命令A
执行命令：执行初始化命令B
系统接收访问者1的指令：
执行命令：访问者1的新命令A
执行命令：访问者1的新命令B
系统接收访问者2的指令：
执行命令：访问者2的新命令A
执行命令：访问者2的新命令B

　　5、Python代码演示：

import abc #利用abc模块实现抽象类

class InterViewee(metaclass=abc.ABCMeta):
    def __init__(self,command):
        self.command=command
    def run(self):
        print("执行命令：{}".format(self.command))
    def changecommand(self,command):
        self.command=command
    @abc.abstractmethod  # 定义抽象方法，不需要写具体的实现内容
    def accept(self,v):  # 接收访问者
        pass

class IntervieweeA(InterViewee):
    def accept(self,v):
        mine=self
        v.VisitIntervieweeA(mine)

class IntervieweeB(InterViewee):
    def accept(self,v):
        mine=self
        v.VisitIntervieweeB(mine)

class Integrator:
    def __init__(self):
        self.IntervieweeAAA=IntervieweeA("执行初始化命令A")
        self.IntervieweeBBB=IntervieweeB("执行初始化命令B")
    def run(self):
        self.IntervieweeAAA.run()
        self.IntervieweeBBB.run()
    def accept(self,v):
        self.IntervieweeAAA.accept(v)
        self.IntervieweeBBB.accept(v)

class Visitor:
    @abc.abstractmethod  # 定义抽象方法，不需要写具体的实现内容
    def VisitIntervieweeA(self,ia):
        pass

    @abc.abstractmethod  # 定义抽象方法，不需要写具体的实现内容
    def VisitIntervieweeB(self,ib):
        pass

class Visitor1(Visitor):
    def VisitIntervieweeA(self,ia):
        ia.changecommand("访问者1的新命令A")
    def VisitIntervieweeB(self,ib):
        ib.changecommand("访问者1的新命令B")

class Visitor2(Visitor):
    def VisitIntervieweeA(self,ia):
        ia.changecommand("访问者2的新命令A")
    def VisitIntervieweeB(self,ib):
        ib.changecommand("访问者2的新命令B")

print("系统执行：")
III=Integrator()
III.run()
print("系统接收访问者1的指令：")
v1=Visitor1()
III.accept(v1)
III.run()
print("系统接收访问者2的指令：")
V2=Visitor2()
III.accept(V2)
III.run()

　　输出：

系统执行：
执行命令：执行初始化命令A
执行命令：执行初始化命令B
系统接收访问者1的指令：
执行命令：访问者1的新命令A
执行命令：访问者1的新命令B
系统接收访问者2的指令：
执行命令：访问者2的新命令A
执行命令：访问者2的新命令B

　　2022年6月22日第一次更新：加入Java演示代码

　　2022年6月30日第二次更新：加入Python演示代码

dawn
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
深入探究基于发布/订阅模式的轻量级消息传输协议 MQTT
dvlinker的技术专栏
10-13 2万+
深入探究基于发布 / 订阅模式的轻量级消息传输协议MQTT。
访问者模式代码举例(java语言版)
qq_35386002的博客
04-16 372
前言：服访问者模式解决稳定的数据结构和易变的操作耦合问题。比如下面例子：鼠标，显示器，键盘，电脑它们的关系就是稳定的，所以鼠标，显示器，键盘，电脑实体类组成的结构就是稳定的数据结构。访问方式是多变的，所以可以在访问的时候根据具体需求去访问。 JAVA语言版访问者模式 创建电脑接口： public interface ComputerPart { void accept(Comput...
访问者模式的分析、结构图及基本代码
脚踏实地，用心编写出客户满意的代码，为公司创造出应有的价值。
07-24 1095
 之前我对所有的23种设计模式作了一个小总结，现在我们来对每一种设计模式作详细的分析。首先是访问者模式： 定义：表示一个作用于某对象结构中的各元素的操作。它可使你可以在不改变各元素的类的前提下定义作用于这些元素的新操作。 适用地方：访问者模式的目的是要把处理从数据结构分离出来。很多系统可以按照算法和数据结构分开，如果这样的系统有比较稳定的数据结构，又有易于变化的算法的话，使用访问者模式就
设计模式——访问者模式（附代码示例）
枫陵的博客
05-25 944
一. 传统模式 以观众（分为男女两类）对歌手评价（分为成功、失败两类）为例 1. 传统方式解决 通过继承的方式实现男女分类，并直接在类中实现评价方法 2. 传统方式问题分析 如果系统比较小，还是可以的，但是考虑系统增加越来越多新的功能时，对代码改动较大，违反了ocp原则，不利于维护; 且扩展性不好，比如增加了新的人员类型，或者管理方法。故引出访问者模式。 二. 访问者模式 1. 概念 访问者模式(Visitor Pattern)，封装一些作用于某种数据...
设计模式之访问者模式【Visitor Pattern】
Rogera的博客
05-20 1152
访问者模式是23种设计模式中最复杂的一个，使用频率并不高。大多数情况下，并不需要访问者模式，但一旦需要使用它时，那就真的是需要它了。 1、定义 封装一些作用于某种数据结构中的各元素的操作，它可以在不改变这个数据结构的前提下，定义作用于这些元素的新操作。 2、使用场景 对象结构比较稳定，但是经常需要在此对象结构上定义新的操作。 如果想对一个对象结构中的各个元素进行很多不同的而且不相关的操作...
Java设计模式—访问者模式
weixin6688的博客
05-27 247
访问者模式 Visitor Pattern1. 访问者模式概述1.1 定义1.2 结构1.3 适用环境2. 访问者模式应用案例2.1 类图2.2 代码实现2.3 运行结果3. 访问者模式优缺点 1. 访问者模式概述 访问者模式是行为型模式，它包含访问者和被访问元素两个主要组成部分。 被访问的元素通常具有不同的类型，且不同的访问者可以对它们进行不同的访问操作。 访问者模式使得用户可以在不修改现有系统的情况下扩展系统的功能，为这些不同类型的元素增加新的元素。 1.1 定义 访问者模式让用户可以在不改变各元素
C#23种设计模式简单记录
Wanderer_Night的博客
06-26 1436
建立流程 优点 缺点 适用场景
设计模式之"你低估了的面向对象"编程
阿甘的码路
03-14 1171
目录：三大编程范式函数式编程面向过程编程面向对象编程面向对象编程的优点适合大规模复杂项目模块化组织代码封装、抽象、继承、多态面向对象语言丰富指导落地案例丰富封装、继承、多态、抽象封装抽象继...
设计模式-7种开发语言（C#、JAVA、JavaScript、C++、Python、Go、PHP）.pdf
10-30
在标题提及的《设计模式-7种开发语言（C#、JAVA、JavaScript、C++、Python、Go、PHP）》中，作者林晨一点详细介绍了24种经典的设计模式，并提供了这七种主流编程语言的代码示例。以下将对其中一些关键的设计模式进行...
两个设计模式与一个线程回调
07-24
为了解决这个问题，现代编程语言引入了诸如Promise（JavaScript）、async/await（C#、Python等）等异步编程模型，它们能以更简洁的方式处理异步流程。 在"DesignPattern2ThreadCallback"这个主题中，我们可以深入...
计算机毕业设计大学生就业信息管理系统源码.zip
05-20
【压缩包子文件的文件名称列表】中的“code”可能是所有源代码文件所在的目录或者文件，这通常包含多个不同编程语言（如Java、Python、C#）的文件，涵盖了系统的各个组成部分，如数据库连接、前端界面、后端逻辑等。...
mualda:算法和数据结构（C#、C++、Javascript、Python）
06-07
《算法和数据结构：C#、C++、Javascript、Python 实现》 在信息技术领域，算法和数据结构是核心基础知识，它们是构建高效软件和系统的基石。本资源库"mualda"涵盖了四种广泛使用的编程语言——C#、C++、Javascript...
十七、访问者模式
qq_61350148的博客
08-13 906
讲解了访问者模式，并介绍了其在JDK中的使用。
第六天：java设计模式、GUI编程与面向对象设计原则
JavaUpgrade
08-13 347
设计模式的定义：回顾设计模式的定义，即解决特定设计问题的通用解决方案。常见设计模式：了解并掌握几种常见的设计模式，如单例模式、工厂模式、策略模式、观察者模式等。了解它们的基本结构、应用场景和优缺点。设计模式的应用：通过实际例子或练习，尝试将设计模式应用到Java代码中，以解决实际问题。
设计模式-策略模式
不断努力向上攀登的路，比站在顶峰更加让人热血沸腾！
08-15 322
也是一种行为型的设计模式，它主要是定义一系列的算法封装起来，然后可以通过策略进行互换，提高代码的复用性和可维护性质。其主要实现分为，通过扩展算法类来扩展算法，调用策略类来传入不同的算法，实现对应的接口方法。举例：小明要去外地，有汽车和火车两种方式，小明该如何选择，请设计实现。
IO流用到的设计模式
qq_53199639的博客
08-13 474
IO流用到的设计模式 装饰器（Decorator）模式 可以在不改变原有对象的情况下拓展其功能。例如，可以通过 BufferedInputStream（字节缓冲输入流）来增强 FileInputStream 的功能。 适配器（Adapter Pattern）模式 主要用于接口互不兼容的类的协调工作。例如，InputStreamReader 使用 StreamDecoder （流解码器）对字节进行解码，实现字节流到字符流的转换，OutputStreamWriter 使用StreamEncoder（流编码器
【1】设计模式简介
2201_75414908的博客
08-12 237
设计模式简介
设计模式--单例模式
最新发布
qq_29751083的博客
08-15 314
每种实现方式都有其优缺点，在选择时可以根据实际需求进行考虑。例如，如果你的应用程序是多线程环境并且希望实例在第一次使用时创建，那么可以采用双重检查锁定的方式；如果你的应用程序是单线程环境，那么简单的懒汉式实现就足够了。单例模式是一种常用的软件设计模式，它确保一个类只有一个实例，并提供一个全局访问点。这种模式经常用于系统中只需要一个实例的对象，例如日志管理器、数据库连接池、线程池等。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值