设计模式第12次作业——访问者模式

于 2020-06-12 17:39:13 发布
阅读量201 收藏
点赞数
分类专栏： 设计模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/weixin_43470016/article/details/106717306
版权
本文深入解析访问者模式，探讨其在数据结构相对稳定而算法易变的系统中的应用。通过多个代码实例展示如何在不同场景下实现访问者模式，包括学校检查机制的模拟。讨论了访问者模式的优点，如易于增加新操作，以及缺点，如增加新节点类的难度。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

访问者模式

1)访问者模式(Visitor Pattern),封装一些作用于某种数据结构的各元素的操作，它可以在不改变数据结构的前提下定义作用于这些元素的新的操作。
2)主要将数据结构与数据操作分离，解决数据结构和操作捐合性问题。
3)访问者模式的基本工作原理足：在被访问的类显面加一个对外提供接待访问者的接口。

访问者模式——学校检查机制代码实现

实现一

import java.util.ArrayList;
import java.util.List;
public class main {

	public static void main(String[] args) {
		List<Person>listperson=new ArrayList<Person>();
		Person p1=new Teacher("张老师","编译原理",48);
		Person p2=new Teacher("王老师","数据库",54);
		Person p3=new Student("赵同学","编译原理",90);
		Person p4=new Student("刘同学","数据库",82);
		listperson.add(p1);
		listperson.add(p2);
		listperson.add(p3);
		listperson.add(p4);
		PresidentVisitor pv=new PresidentVisitor();//创建校长
		for(Person b:listperson) {
			pv.visit(b);
		}
		DeanVisitor dv=new DeanVisitor();//创建校长
		for(Person b:listperson) {
			dv.visit(b);
		}
	}
}
//创建一个人员基类
abstract class Person{
	private String name;
	public Person(String name) {
		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 void setCourse(String course) {
		this.course = course;
	}

	public int getAmount() {
		return amount;
	}

	public void setAmount(int amount) {
		this.amount = 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 void setCourse(String course) {
		this.course = course;
	}
	public int getGrade() {
		return grade;
	}
	public void setGrade(int grade) {
		this.grade = 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.getAmount());
		}else if(person instanceof Student) {
			Student student=(Student)person;
			System.out.println("院长访问学生"+student.getName()+"课程："+student.getCourse());
		}
	}
}

实现二

//实现二
public class main {

	public static void main(String[] args) {
		List<Person> listperson = new ArrayList<Person>();
		Person p1 = new Teacher("张老师", "编译原理", 48);
		Person p2 = new Teacher("王老师", "数据库", 54);
		Person p3 = new Student("赵同学", "编译原理", 90);
		Person p4 = new Student("刘同学", "数据库", 82);
		listperson.add(p1);
		listperson.add(p2);
		listperson.add(p3);
		listperson.add(p4);
		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;
				pv.visit(teacher);
			}else if(b instanceof Student) {
				Student student=(Student)b;
				pv.visit(student);
			}
			dv.visit(b);
		}
	}
}

//创建一个人员基类
abstract class Person {
	private String name;

	public Person(String name) {
		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 void setCourse(String course) {
		this.course = course;
	}

	public int getAmount() {
		return amount;
	}

	public void setAmount(int amount) {
		this.amount = 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 void setCourse(String course) {
		this.course = course;
	}

	public int getGrade() {
		return grade;
	}

	public void setGrade(int grade) {
		this.grade = 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.getAmount());
		} else if (person instanceof Student) {
			Student student = (Student) person;
			System.out.println("院长访问学生" + student.getName() + "课程：" + student.getCourse());
		}
	}
}

实现三

public class main {

	public static void main(String[] args) {
		List<Person> listperson = new ArrayList<Person>();
		Person p1 = new Teacher("张老师", "编译原理", 48);
		Person p2 = new Teacher("王老师", "数据库", 54);
		Person p3 = new Student("赵同学", "编译原理", 90);
		Person p4 = new Student("刘同学", "数据库", 82);
		listperson.add(p1);
		listperson.add(p2);
		listperson.add(p3);
		listperson.add(p4);
		Visitor pv = new PresidentVisitor();// 创建校长
		Visitor dv = new DeanVisitor();// 创建院长
		for (Person b : listperson) {
			b.accept(pv);
		}
		System.out.println();
		for (Person b : listperson) {
			b.accept(dv);
		}
	}
}

//创建一个人员基类
abstract class Person {
	private String name;

	public Person(String name) {
		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 void setCourse(String course) {
		this.course = course;
	}

	public int getAmount() {
		return amount;
	}

	public void setAmount(int amount) {
		this.amount = amount;
	}
	public void accept(Visitor visitor) {
		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 void setCourse(String course) {
		this.course = course;
	}

	public int getGrade() {
		return grade;
	}

	public void setGrade(int grade) {
		this.grade = grade;
	}

	public void accept(Visitor visitor) {
		visitor.visit(this);
		
	}

}

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.getAmount());
		} else if (person instanceof Student) {
			Student student = (Student) person;
			System.out.println("院长访问学生" + student.getName() + "课程：" + student.getCourse());
		}
	}
}

实现四

public class main {

	public static void main(String[] args) {
		Person p1 = new Teacher("张老师", "编译原理", 48);
		Person p2 = new Teacher("王老师", "数据库", 54);
		Person p3 = new Student("赵同学", "编译原理", 90);
		Person p4 = new Student("刘同学", "数据库", 82);
		Visitor pv = new PresidentVisitor();// 创建校长
		Visitor dv = new DeanVisitor();// 创建院长
		ObjectList listperson=new ObjectList();
		listperson.Attach(p1);
		listperson.Attach(p2);
		listperson.Attach(p3);
		listperson.Attach(p4);
		listperson.Display(pv);
		System.out.println();
		listperson.Display(dv);
	}
}
//增加客户端的类
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) {
		ObjectStructure o=new ObjectStructure();
		o.Attach(new ConcreteElementA());
		o.Attach(new ConcreteElementB());
		ConcreteVisitor1 v1=new ConcreteVisitor1();
		ConcreteVisitor2 v2=new ConcreteVisitor2();
		o.Accepet(v1);
		o.Accepet(v2);
	}
}

//抽象元素（节点）类
abstract class Element {
	public abstract void Accept(Visitor visitor);
}

class ConcreteElementA extends Element {

	public void Accept(Visitor visitor) {
		visitor.ConcreteElementA(this);
	}

	public void OperetionA() {

	}

}

class ConcreteElementB extends Element {

	public void Accept(Visitor visitor) {
		visitor.ConcreteElementB(this);
	}

	public void OperetionB() {

	}

}

//Visitor类
abstract class Visitor {
	public abstract void ConcreteElementA(ConcreteElementA concreteElementA);

	public abstract void ConcreteElementB(ConcreteElementB concreteElementB);
}

class ConcreteVisitor1 extends Visitor {

	public void ConcreteElementA(sheji11.ConcreteElementA concreteElementA) {
		System.out.println(concreteElementA.getClass().toString() + "被" + this.getClass() + "访问");

	}

	public void ConcreteElementB(sheji11.ConcreteElementB concreteElementB) {
		System.out.println(concreteElementB.getClass().toString() + "被" + this.getClass() + "访问");
	}

}
class ConcreteVisitor2 extends Visitor {

	public void ConcreteElementA(sheji11.ConcreteElementA concreteElementA) {
		System.out.println(concreteElementA.getClass().toString() + "被" + this.getClass() + "访问");

	}

	public void ConcreteElementB(sheji11.ConcreteElementB concreteElementB) {
		System.out.println(concreteElementB.getClass().toString() + "被" + this.getClass() + "访问");
	}

}
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 Accepet(Visitor visitor) {
		for(Element e:elements) {
			e.Accept(visitor);
		}
	}
}

访问者模式的特点

访问者模式运用于数据结构相对稳定而算法又易变化的系统。
因为访问者模式使得算法操作增加变得容易。若系统数据结构对象易于变化，经常有新的数据对象增加进来，则不运合使用访问者模式。

使用访问者模式的优点和缺点

优点：

访问者模式使得增加新的操作变得很容易 如果一些操作依赖于一个复 杂的结构对 象的话， 那么一 般而言， 增加新的操作会 很复杂。
而使用访问 者模式增加新的操作 就意味增 加一个新的访问者类， 因此，变得很容易。
访问者模式将有关的行为集中的一个访门者对象中而不是分 散到一个个的节 点类中 。

缺点：

增加新的节点类变得很困难。 每增加一个新的节点都意味着要在抽象访问者角色中增加一个新的抽象操作， 并在每一个实体访问者类中增加相应的具体操作。
破坏封装 。访问者模式要求访门者对象访问并调用每一个节点对象的操作，这隐含了一个对所有节点对象的要求：它们必须暴露一些自己的操作和内部状态。

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Sweet y y y y u

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值