访问者模式Visitor

最新推荐文章于 2020-07-10 15:13:04 发布
最新推荐文章于 2020-07-10 15:13:04 发布
阅读量201 收藏 1
点赞数
分类专栏： 设计模式 文章标签： 设计模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43774908/article/details/106765594
版权

访问者模式Visitor

例题：

  • 校长和院长检查教师和学生
  • 校长和院长检查教师的工作情况和学生的学习情况
  • 校长关注教师的教学工作量，学生学习的课程
  • 院长关注教师的课程，学生的学习成绩
  • 由于校长和院长对于教师和学生的关注点是不一样的，这就需要对教师和学生进行不同的处理
  • 教师的工作和学生的学习相对稳定，访问者和处理方式多种多样。
import java.util.ArrayList;
import java.util.List;
 
//创建一个人员基类
abstract class Person{
	private String name;
	public Person(String name) {
		super();
		this.name = name;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
}
//教师
class Teacher extends Person{
	private String course;//所教课程
	private int amount;//学时
	public Teacher(String name, String course, int amount) {
		super(name);
		this.course = course;
		this.amount = amount;
	}
	public String getCourse() {
		return course;
	}
	public int getAmount() {
		return amount;
	}
	
}
//学生
class Student extends Person{
	private String course;//所学课程
	private int grade;//成绩
	public Student(String name, String course, int grade) {
		super(name);
		this.course = course;
		this.grade = grade;
	}
	public String getCourse() {
		return course;
	}
	public int getGrade() {
		return grade;
	}
}
class PresidentVisitor{//校长访问
	public void visit(Person person) {
		if(person instanceof Teacher) {
			Teacher teacher=(Teacher)person;
			System.out.println("校长 访问老师 "+teacher.getName()+"学时："+teacher.getAmount());
		}else if(person instanceof Student) {
			Student student=(Student)person;
			System.out.println("校长 访问学生 "+student.getName()+"课程："+student.getCourse());
		}
	}
}
class DeanVisitor{//院长访问
	public void visit(Person person) {
		if(person instanceof Teacher) {
			Teacher teacher=(Teacher)person;
			System.out.println("院长 访问老师 "+teacher.getName()+"课程："+teacher.getCourse());
		}else if(person instanceof Student) {
			Student student=(Student)person;
			System.out.println("院长 访问学生 "+student.getName()+"成绩："+student.getGrade());
		}
	}
}
public  class Main{
	public static void main(String[] args){
		List<Person>listperson=new ArrayList<Person>();
		Person t1=new Teacher("张老师","编译原理",48);//创建老师
		Person t2=new Teacher("王老师","数据库",54);
		Student s1=new Student("赵同学","编译原理",90);//创建学生
		Student s2=new Student("刘同学","数据库",82);
		listperson.add(t1);listperson.add(t2);
		listperson.add(s1);listperson.add(s2);
		PresidentVisitor pv=new PresidentVisitor();//创建校长
		for(Person b:listperson) {
			pv.visit(b);
		}
		DeanVisitor dv=new DeanVisitor();//创建院长
		for(Person b:listperson) {
			dv.visit(b);
		}
	}
}

改进：发现类PresidentVisitor和DeanVisitor有相同的方法visit,就可以提出一个接口Visitor,它含有抽象方法visit(),类PresidentVisitor和DeanVisitor实现它并实现其中的visit方法。

import java.util.ArrayList;
import java.util.List;
 
//创建一个人员基类
abstract class Person{
	private String name;
	public Person(String name) {
		super();
		this.name = name;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
}
//教师
class Teacher extends Person{
	private String course;//所教课程
	private int amount;//学时
	public Teacher(String name, String course, int amount) {
		super(name);
		this.course = course;
		this.amount = amount;
	}
	public String getCourse() {
		return course;
	}
	public int getAmount() {
		return amount;
	}
	
}
//学生
class Student extends Person{
	private String course;//所学课程
	private int grade;//成绩
	public Student(String name, String course, int grade) {
		super(name);
		this.course = course;
		this.grade = grade;
	}
	public String getCourse() {
		return course;
	}
	public int getGrade() {
		return grade;
	}
}
interface Visitor{
	abstract void visit(Person person);
}
class PresidentVisitor implements Visitor{//校长访问
	public void visit(Person person) {
		if(person instanceof Teacher) {
			Teacher teacher=(Teacher)person;
			System.out.println("校长 访问老师 "+teacher.getName()+"学时："+teacher.getAmount());
		}else if(person instanceof Student) {
			Student student=(Student)person;
			System.out.println("校长 访问学生 "+student.getName()+"课程："+student.getCourse());
		}
	}
}
class DeanVisitor implements Visitor{//院长访问
	public void visit(Person person) {
		if(person instanceof Teacher) {
			Teacher teacher=(Teacher)person;
			System.out.println("院长 访问老师 "+teacher.getName()+"课程："+teacher.getCourse());
		}else if(person instanceof Student) {
			Student student=(Student)person;
			System.out.println("院长 访问学生 "+student.getName()+"成绩："+student.getGrade());
		}
	}
}
public  class Main{
	public static void main(String[] args){
		List<Person>listperson=new ArrayList<Person>();
		Person t1=new Teacher("张老师","编译原理",48);//创建老师
		Person t2=new Teacher("王老师","数据库",54);
		Student s1=new Student("赵同学","编译原理",90);//创建学生
		Student s2=new Student("刘同学","数据库",82);
		listperson.add(t1);listperson.add(t2);
		listperson.add(s1);listperson.add(s2);
		Visitor pv=new PresidentVisitor();//创建校长
		for(Person b:listperson) {
			pv.visit(b);
		}
		Visitor dv=new DeanVisitor();//创建院长
		for(Person b:listperson) {
			dv.visit(b);
		}
	}
}

再次改进
Visitor中定义visit为重载函数，声明两个visit方法，参数分别是Teacher和Student.
对于Teacher.、Student的访问会调用两个不同的方法，以此达成区别对待、差异化处理。

import java.util.ArrayList;
import java.util.List;
 
//创建一个人员基类
abstract class Person{
	private String name;
	public Person(String name) {
		super();
		this.name = name;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
}
//教师
class Teacher extends Person{
	private String course;//所教课程
	private int amount;//学时
	public Teacher(String name, String course, int amount) {
		super(name);
		this.course = course;
		this.amount = amount;
	}
	public String getCourse() {
		return course;
	}
	public int getAmount() {
		return amount;
	}
	
}
//学生
class Student extends Person{
	private String course;//所学课程
	private int grade;//成绩
	public Student(String name, String course, int grade) {
		super(name);
		this.course = course;
		this.grade = grade;
	}
	public String getCourse() {
		return course;
	}
	public int getGrade() {
		return grade;
	}
}
interface Visitor{
	void visit(Teacher teacher);
	void visit(Student student);
}
class PresidentVisitor implements Visitor{//校长访问
@Override
public void visit(Teacher teacher) {
	// TODO Auto-generated method stub
	System.out.println("校长 访问老师 "+teacher.getName()+"学时："+teacher.getAmount());
}
 
@Override
public void visit(Student student) {
	// TODO Auto-generated method stub
	System.out.println("校长 访问学生 "+student.getName()+"课程："+student.getCourse());
}
}
class DeanVisitor implements Visitor{//院长访问
@Override
public void visit(Teacher teacher) {
	// TODO Auto-generated method stub
	System.out.println("院长 访问老师 "+teacher.getName()+"课程："+teacher.getCourse());
}
 
@Override
public void visit(Student student) {
	// TODO Auto-generated method stub
	System.out.println("院长 访问学生 "+student.getName()+"成绩："+student.getGrade());
}
}
public  class Main{
	public static void main(String[] args){
		List<Person>listperson=new ArrayList<Person>();
		Person t1=new Teacher("张老师","编译原理",48);//创建老师
		Person t2=new Teacher("王老师","数据库",54);
		Person s1=new Student("赵同学","编译原理",90);//创建学生
		Person s2=new Student("刘同学","数据库",82);
		listperson.add(t1);listperson.add(t2);
		listperson.add(s1);listperson.add(s2);
		Visitor pv=new PresidentVisitor();//创建校长
		for(Person b:listperson) {
			if(b instanceof Teacher) {
				Teacher teacher=(Teacher)b;
				pv.visit(teacher);
			}else if(b instanceof Student) {
				Student student=(Student)b;
				pv.visit(student);
				
			}
		}
		Visitor dv=new DeanVisitor();//创建院长
		for(Person b:listperson) {
			if(b instanceof Teacher) {
				Teacher teacher=(Teacher)b;
				dv.visit(teacher);
			}else if(b instanceof Student) {
				Student student=(Student)b;
				dv.visit(student);
			}
		}
	}
}

如果在老师和学生类定义方法accept ( Visitor visitor )接受校长或院长访问，在方法实现时通过：visitor.visit(this),当前老师或学生作为实参传递，就去除了判断

import java.util.ArrayList;
import java.util.List;
 
//创建一个人员基类
abstract class Person{
	private String name;
	public Person(String name) {
		super();
		this.name = name;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public abstract void accept(Visitor visitor);
}
//教师
class Teacher extends Person{
	private String course;//所教课程
	private int amount;//学时
	public Teacher(String name, String course, int amount) {
		super(name);
		this.course = course;
		this.amount = amount;
	}
	
	public String getCourse() {
		return course;
	}
	public int getAmount() {
		return amount;
	}
 
	@Override
	public void accept(Visitor visitor) {
		// TODO Auto-generated method stub
		visitor.visit(this);
	}
	
}
//学生
class Student extends Person{
	private String course;//所学课程
	private int grade;//成绩
	public Student(String name, String course, int grade) {
		super(name);
		this.course = course;
		this.grade = grade;
	}
	public String getCourse() {
		return course;
	}
	public int getGrade() {
		return grade;
	}
	@Override
	public void accept(Visitor visitor) {
		// TODO Auto-generated method stub
		visitor.visit(this);
	}
}
interface Visitor{
	void visit(Teacher teacher);
	void visit(Student student);
}
class PresidentVisitor implements Visitor{//校长访问
@Override
public void visit(Teacher teacher) {
	// TODO Auto-generated method stub
	System.out.println("校长 访问老师 "+teacher.getName()+"学时："+teacher.getAmount());
}
 
@Override
public void visit(Student student) {
	// TODO Auto-generated method stub
	System.out.println("校长 访问学生 "+student.getName()+"课程："+student.getCourse());
}
}
class DeanVisitor implements Visitor{//院长访问
@Override
public void visit(Teacher teacher) {
	// TODO Auto-generated method stub
	System.out.println("院长 访问老师 "+teacher.getName()+"课程："+teacher.getCourse());
}
 
@Override
public void visit(Student student) {
	// TODO Auto-generated method stub
	System.out.println("院长 访问学生 "+student.getName()+"成绩："+student.getGrade());
}
}
class ObjectList{
	private List<Person>lists=new ArrayList<Person>();
	public void Attach(Person element) {//增加
		lists.add(element);
	}
	public void Detach(Person element) {//移除
		lists.remove(element);
	}
	public void Display(Visitor visitor) {//查看显示
		for(Person element:lists) {
			element.accept(visitor);
		}
	}
}
public  class Main{
	public static void main(String[] args){
		Person t1=new Teacher("张老师","编译原理",48);//创建老师
		Person t2=new Teacher("王老师","数据库",54);
		Person s1=new Student("赵同学","编译原理",90);//创建学生
		Person s2=new Student("刘同学","数据库",82);
		Visitor p=new PresidentVisitor();//创建校长
		Visitor d=new DeanVisitor();//院长
		ObjectList listperson=new ObjectList();
		listperson.Attach(t1);
		listperson.Attach(t2);
		listperson.Attach(s1);
		listperson.Attach(s2);
		listperson.Display(p);
		System.out.println("================");
		listperson.Display(d);
	}
}

访问者模式：

  • 访问者模式(Visitor Pattern),封装一些作用于某种数据结构的各元素的操作，它可以在不改变数据结构的前提下定义作用于这些元素的新的操作。
  • 主要将数据结构与数据操作分离，解决数据结构和操作耦合性问题。
  • 访问者模式的基本工作原理是:在被访问的类里面加一个对外提供接待访问者的接口。
    访问者模式的基本结构代码
import java.util.ArrayList;
import java.util.List;
 
abstract class Element{
	public abstract void Accept(Visitor visitor);
}
class ConcreteElementA extends Element{
	public void Accept(Visitor visitor) {
		visitor.VisitConcreteElementA(this);
	}
	public void OperationA() {}
}
class ConcreteElementB extends Element{
	public void Accept(Visitor visitor) {
		visitor.VisitConcreteElementB(this);
	}
	public void OperationB() {}
}
abstract class Visitor{
	public abstract void VisitConcreteElementA(ConcreteElementA concreteElementA);
	public abstract void VisitConcreteElementB(ConcreteElementB concreteElementB);
}
class ConcreteVisitor1 extends Visitor{
 
	@Override
	public void VisitConcreteElementA(ConcreteElementA concreteElementA) {
		// TODO Auto-generated method stub
		System.out.println(concreteElementA.getClass().toString()+"被"+this.getClass().toString()+"访问");
	}
 
	@Override
	public void VisitConcreteElementB(ConcreteElementB concreteElementB) {
		// TODO Auto-generated method stub
		System.out.println(concreteElementB.getClass().toString()+"被"+this.getClass().toString()+"访问");
	}
	
}
class ConcreteVisitor2 extends Visitor{
 
	@Override
	public void VisitConcreteElementA(ConcreteElementA concreteElementA) {
		// TODO Auto-generated method stub
		System.out.println(concreteElementA.getClass().toString()+"被"+this.getClass().toString()+"访问");
	}
 
	@Override
	public void VisitConcreteElementB(ConcreteElementB concreteElementB) {
		// TODO Auto-generated method stub
		System.out.println(concreteElementB.getClass().toString()+"被"+this.getClass().toString()+"访问");
	}
	
}
class ObjectStructure{
	private List<Element>elements=new ArrayList<Element>();
	public void Attach(Element element) {
		elements.add(element);
	}
	public void Detach(Element element) {
		elements.remove(element);
	}
	public void Accept(Visitor visitor) {
		for(Element e:elements) {
			e.Accept(visitor);
		}
	}
}
public  class Main{
	public static void main(String[] args){
	ObjectStructure o=new ObjectStructure();
	o.Attach(new ConcreteElementA());
	o.Attach(new ConcreteElementB());
	ConcreteVisitor1 v1=new ConcreteVisitor1();
	ConcreteVisitor2 v2=new ConcreteVisitor2();
	o.Accept(v1);
	o.Accept(v2);
	}
}

Visitor：是抽象访问者。为该对象结构中的ConerteElement的每一个类声明一个visit操作
ConcreteVisitor:是一个具体的访问者，实现每个有Visitor声明的操作，是每个操作实现的部分
ObjectStructure：能枚举它的元素可以提供一个高层的接口，用来允许访问者访问元素
Element：定义一个accept方法，接收一个访问者对象
ConcreteElement：为具体元素，实现了accept方法

优点：

  • 增加新的操作很容易
  • 访问者模式将有关的行为集中到一个访问者对象中，而不是分散到一个个的节点类中。

缺点：

  • 增加新的节点类变得很困难
  • 破坏封装
☀加油＾０＾~
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
访问者模式VisitorPattern
10-08
**访问者模式(VisitorPattern)** 访问者模式是一种行为设计模式，它使你能在不修改对象结构的前提下向对象添加新的操作。这种模式常用于处理具有复杂逻辑的对象结构，特别是当你需要对这些对象进行多态操作时。访问...
java中visit函数_Java设计模式(三) Visitor(訪问者)模式及多分派场景应用
weixin_42524824的博客
02-24 1022
基本概念Visitor封装一些作用于数据结构中的各元素的操作，不同的操作能够借助新的visitor实现。减少了操作间的耦合性訪问者能够将数据结构和对数据的操作解耦，使得添加对数据结构的操作不须要取改动数据结构，也不必去改动原有的操作，而运行时再定义新的Visitor时闲着即可了(在操作加入上易拓展)模式中角色分工Visitor:抽象訪问者，在重载的visit函数中声明訪问者能够訪问的对象。Conc...
Java设计模式(三) Visitor(访问者)模式及多分派场景应用
llin-黎辰
04-14 8021
基本概念Visitor 封装一些作用于数据结构中的各元素的操作，不同的操作可以借助新的visitor实现，降低了操作间的耦合性 访问者可以将数据结构和对数据的操作解耦，使得增加对数据结构的操作不需要取修改数据结构，也不必去修改原有的操作，而执行时再定义新的Visitor时闲着就行了(在操作添加上易拓展) 模式中角色分工 Visitor:抽象访问者，在重载的visit函数中声明访问者可以访问的对象。
访问者模式
★探梦少年☆的博客
06-14 147
访问者模式 访问者模式的目的是封装一些施加于某种数据结构元素之上的操作，一旦这些操作需要修改的话，接受这个操作的数据结构可以保持不变。为不同类型的元素提供多种访问操作方式，且可以在不修改原有系统的情况下增加新的操作方式，这就是访问者模式的模式动机。 案例：学校领导访问老师和学生 源代码： package Visitor; import java.util.ArrayList; import java.util.List; public class Visitor { public sta.
访问者模式（Visitor）
weixin_34138377的博客
12-14 94
访问者模式（Visitor） 访问者模式（Visitor）意图：表示一个作用于某对象结构中的各元素的操作，它使你在不改变各元素的类的前提下定义作用于这些元素的新操作。应用：作用于编译器语法树的语义分析算法。模式结构：心得：访问者模式是要解决对对象添加新的操作和功能时候，如何尽可能不修改对象的类的一种方法。一般为对象添加功能，是需要向对象添加成员函数。但这里对对象（ConcreteElem...
Java 设计模式：实战访问者模式「模拟家长与校长，对学生和老师的不同视角信息的访问场景」
成都汇智动力的博客
07-10 333
一、前言 能力，是你前行的最大保障 年龄会不断的增长，但是什么才能让你不慌张。一定是能力，即使是在一个看似还很安稳的工作中也是一样，只有拥有能留下的本事和跳出去的能力，你才会是安稳的。而能力的提升是不断突破自己的未知也就是拓展宽度，以及在专业领域建设个人影响力也就是深度。如果日复日365天，天天搬砖，一切都没有变化的重复只能让手上增长点老茧，岁月又叹人生苦短。 站得高看的远吗？ 站得高确实能看得远，也能给自己更多的追求。但，站的高了，原本看的清的东西就变得看不清了。视角和重点的不同，会让我们有很多不
设计模式C++学习之访问者模式（Visitor）
09-07
访问者模式（Visitor）是一种行为设计模式，它允许在不修改对象结构的前提下向对象结构中的元素添加新的操作。这种模式将算法与数据结构分离，使得算法可以独立于数据结构进行变化，增强了系统的可扩展性。 在C++中...
php设计模式 Visitor 访问者模式
10-28
访问者模式（Visitor Pattern）是一种行为设计模式，它在不修改已有对象结构的情况下，为对象增加新的功能。这种模式在PHP和其他面向对象编程语言中都得到了广泛应用，尤其在需要对对象进行多样化操作，且不想破坏...
访问者模式(VisitorPattern)
01-27
访问者模式（VisitorPattern）是一种行为设计模式，其主要目的是为了在不改变数据结构的前提下，增加对元素集合的新操作。这种模式将操作封装在独立的访问者类中，使得操作和数据结构解耦，允许两者独立演进。 **...
设计模式-访问者模式（Visitor）
09-20
访问者模式（Visitor）是一种行为设计模式，它允许在不修改对象结构的前提下向对象结构中的元素添加新的操作。这种模式的核心思想是分离了算法和对象结构，使得算法可以在不改变对象结构的情况下独立变化。 访问者...
实例讲解访问者模式(Visitor Pattern)
youthon的专栏
08-21 2944
六个角色：         抽象访问者(Visitor)、具体访问者(ConcreteVisitor)、抽象元素(Element)、具体元素(ConcreteElement)、对象结构类(ObjectStructure)、客户端(Client)          抽象访问者(Visitor)：抽象出访问元素的动作         具体访问者(ConcreteVisitor)：实现访问元素的动
第一次使用processon画图——UML类图
qq_43774908的博客
03-03 3156
首先直接搜索processon打开就可以或者使用下面的链接进入https://www.processon.com/ 进入之后可以注册自己的账号，然后就可以开始画图了。
设计模式七大原则之合成/聚合复用原则(CARP)
qq_43774908的博客
03-31 462
合成/聚合复用原则(CARP) 问题的提出： 如果有类A和类B，类A有方法opertion1()、 opertion2() 和 opertion3()，类B需要用类A的方法opertion2() ，如何做？ 法1： 让类B继承类A，则类B可以使用类A的所有方法，当 然包括opertion2() 。 分析： 1、暴露了类A的另外2个方法,虽然类B不需要使用， 但是破坏封装。 2、如果类A的实现发生...
详细介绍一下UML类图
qq_43774908的博客
03-10 407
下面详细的介绍一下UML类图 注释(comment) 注释就是对类图的补充说明，可以附加在任何元素上，用右上角有折角的矩形来表示，其内放置说明文字，通过虚线连接被注释的元素。 类（Class) 在面向对象（OO) 编程中，类是对现实世界中一组具有相同特征的物体的抽象。在UML类图中，类使用包含类名、属性(field) 和方法(method) 且带有分割线的矩形来表示： 类的属性的完整表示方式：...
职责链( Chain of Responsibility)模式
qq_43774908的博客
06-14 300
职责链( Chain of Responsibility)模式 职责链模式动机(Motivation) ➢在软件构建过程中，一个请求可能被多个对象处理，但是每个请求在运行时只能有一个接受者，如果显式指定，将必不可少地带来请求发送者与接受者的紧耦合。 ➢如何使请求的发送者不需要指定具体的接受者?让请求的接受者自己在运行时决定来处理请求，从而使两者解耦。 模式定义 使多个对象都有机会处理请求，从而避免请求的发送者和.接收者之间的耦合关系。将这些对象连成一条链，并沿着这条链传递请求，直到有一个对象处理它为止。 问
设计模式七大原则之开放-封闭原则
qq_43774908的博客
03-20 270
开放-封闭原则 1.基本介绍 1)开闭原则(Open Closed Principle)是编程中最基础、 最重要的设计原则——面向对象设计的终极目标。 2)一个软件实体如类，模块和函数应该对扩展开放 (对提供方)，对修改关闭(对使用方)。用抽象构建 框架，用实现扩展细节。 3)当软件需要变化时，尽量通过扩展软件实体的行 为来实现变化，而不是通过修改已有的代码来实现 变化。 4)编程中遵循其它原则，...
设计模式七大原则之迪米特法则（LoD）
qq_43774908的博客
03-31 234
迪米特法则（LoD） 基本介绍 1)一个对象应该对其他对象保持最少的了解 2)类与类关系越密切，耦合度越大 3)迪米特法则(Demeter Principle)又叫最少知道原则，即一个类对自己依赖的类知道的越少越好。也就是说，对于被依赖的类不管多么复杂，都尽量将逻辑封装在类的内部。对外除了提供的public方法，不泄露任何信息。 4)迪米特法则还有个更简单的定义:只与直接的朋友通信 5)直接的朋友...
组合（Composite）模式
qq_43774908的博客
06-14 214
组合（Composite）模式 商品类别树 +服装 +男装 -衬衣 -夹克 +女装 -裙子 -套装 特点： 有一个根节点 树枝节点 叶子节点 现在需要管理商品类别树，假设要求能实现输出如上商品类别树的结构功能，应该如何实现？ 分析： 商品类别树的节点被分成两种，一种是容器节点，另一种是叶子节点。 容器节点可以包含其他容器节点或者叶子节点 不带模式的解决方案 import java.util.ArrayList; import java.util.Collection;
为别人做嫁衣——代理模式
qq_43774908的博客
04-28 205
代理模式 场景描述 前提:卓贾易喜欢娇娇,但是，娇娇并不认识卓贾易: 1.卓贾易给娇娇送花，送巧克力,送洋娃娃 2.卓贾易也可以找一个人，让这个人把鲜花，巧克力和洋娃娃送给娇娇。 这是两种方式，但达到的目的是一样的。 下面看看这两个代码的实现。 没有代理的代码 //追求者类 class Pursuit{ SchoolGirl mm; public Pursuit(SchoolGirl mm) ...
设计模式 访问者模式 C++
最新发布
03-27
在访问者模式中，有两个主要的角色：访问者（Visitor）和元素（Element）。元素是一个接口或抽象类，定义了接受访问者的方法。访问者是一个接口或抽象类，定义了对元素进行操作的方法。 以下是访问者模式的基本实现...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值