您当前的位置： 首页 >  Python

dawn

暂无认证

  • 4浏览

    0关注

    204博文

    0收益

  • 0浏览

    0点赞

    0打赏

    0留言

私信
关注
热门博文

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

dawn 发布时间：2022-06-20 22:20:17 ，浏览量：4

　　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代码演示：



	
		
		访问者模式
	
	
		

		
			//定义被访问者的基础结构
			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+"";
			}
			
			PrintInfo("系统执行：");
			II=new Integrator();
			II.Run();

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

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

　　网页里的输出：

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

　　3、PHP代码演示：

　　网页里的输出：

系统执行：
执行命令:执行初始化命令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演示代码

关注
打赏
1664252102
查看更多评论

最近更新

热门博客

[ 申请 ]友情链接：

ClashX教程 绘画宝宝 配音宝宝
立即登录/注册

微信扫码登录

0.0967s