设计模式----访问者模式（JAVA）

最新推荐文章于 2023-05-19 10:59:47 发布
最新推荐文章于 2023-05-19 10:59:47 发布
阅读量132 收藏 2
点赞数
分类专栏： 设计模式 文章标签： 设计模式 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45499076/article/details/106713765
版权

模式简析

/**
 * 
 */
/**
 * 访问者模式
 * 动机：将数据结构与数据操作分离。
 * 解决的问题：稳定的数据结构和易变的操作耦合问题。
 * 优点： 
 * 1、符合单一职责原则。 
 * 2、优秀的扩展性。 
 * 3、灵活性。
 * 缺点： 
 * 1、具体元素对访问者公布细节，违反了迪米特原则。 
 * 2、具体元素变更比较困难。 
 * 3、违反了依赖倒置原则，依赖了具体类，没有依赖抽象。
 * 使用场景： 
 * 1、对象结构中对象对应的类很少改变，但经常需要在此对象结构上定义新的操作。 
 * 2、需要对一个对象结构中的对象进行很多不同的并且不相关的操作，而需要避免让这些操作影响这些对象的类，也不希望在增加新操作时修改这些类。
 *
 */

具体实例

import java.util.ArrayList;
import java.util.List;

/*
 * 实例
 * 校长和院长对老师学生的检查
 * 校长关注老师的工作和学生的课程
 * 院长关注老师的课程和学生的成绩
 * 
 * 简单的面向对象的方法实现
 */
public class Demo1 {
	public static void main(String[] args) {
		List<Person> list = new ArrayList<Person>();
		Person p1 = new Teacher("王老师","设计模式",48);
		Person p2 = new Teacher("李老师","数据库",48);
		Person p3 = new Student("张同学","设计模式",100);
		Person p4 = new Student("王同学","数据库",100);
		list.add(p4);
		list.add(p3);
		list.add(p2);
		list.add(p1);
		PresidentVisiter p =new PresidentVisiter();
		for(Person person :list) {
			p.Visit(person);
		}
		YuanZHangVisiter y = new YuanZHangVisiter();
		for(Person person:list) {
			y.Visit(person);
		}
	}
}
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 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 PresidentVisiter{
	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 YuanZHangVisiter{
	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());
		}
	}
}

import java.util.ArrayList;
import java.util.List;

/*
 * 实例
 * 校长和院长对老师学生的检查
 * 校长关注老师的工作和学生的课程
 * 院长关注老师的课程和学生的成绩
 * 
 * 简单的面向对象的方法实现
 * 
 * 重构代码
 */
public class Demo1 {
	public static void main(String[] args) {
		List<Person> list = new ArrayList<Person>();
		Person p1 = new Teacher("王老师","设计模式",48);
		Person p2 = new Teacher("李老师","数据库",48);
		Person p3 = new Student("张同学","设计模式",100);
		Person p4 = new Student("王同学","数据库",100);
		list.add(p4);
		list.add(p3);
		list.add(p2);
		list.add(p1);
		PresidentVisiter p =new PresidentVisiter();
		for(Person person :list) {
			if(person instanceof Teacher) {
				Teacher t =(Teacher)person;
				p.Visit(t);
			}else if(person instanceof Student) {
				Student s =(Student)person;
				p.Visit(s);
			}
		}
		YuanZHangVisiter y = new YuanZHangVisiter();
		for(Person person:list) {
			if(person instanceof Teacher) {
				Teacher t =(Teacher)person;
				y.Visit(t);
			}else if(person instanceof Student) {
				Student s =(Student)person;
				y.Visit(s);
			}
		}
	}
}
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 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 Visiter{
	void Visit(Teacher teacher);
	void Visit(Student student);
}
class PresidentVisiter implements Visiter{

	@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 YuanZHangVisiter implements Visiter{
	@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());
	}
}

import java.util.ArrayList;
import java.util.List;

/*
 * 实例
 * 校长和院长对老师学生的检查
 * 校长关注老师的工作和学生的课程
 * 院长关注老师的课程和学生的成绩
 * 
 * 访问者模式实现
 * 
 * 
 */
public class Demo1 {
	public static void main(String[] args) {
		Person p1 = new Teacher("王老师","设计模式",48);
		Person p2 = new Teacher("李老师","数据库",48);
		Person p3 = new Student("张同学","设计模式",100);
		Person p4 = new Student("王同学","数据库",100);
		PresidentVisiter p =new PresidentVisiter();
		YuanZHangVisiter y = new YuanZHangVisiter();
		ObjectList ol = new ObjectList();
		ol.Attach(p4);
		ol.Attach(p3);
		ol.Attach(p2);
		ol.Attach(p1);
		ol.Display(p);
		System.out.println("============================================");
		ol.Display(y);
	}
}
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(Visiter visiter);
}
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(Visiter visiter) {
		// TODO Auto-generated method stub
		visiter.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(Visiter visiter) {
		// TODO Auto-generated method stub
		visiter.Visit(this);
	}
	
}
interface Visiter{
	void Visit(Teacher teacher);
	void Visit(Student student);
}
class PresidentVisiter implements Visiter{

	@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 YuanZHangVisiter implements Visiter{
	@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> list = new ArrayList<Person>();
	public void Attach(Person person) {
		list.add(person);
	}
	public void Detach(Person person) {
		list.remove(person);
	}
	public void Display(Visiter visiter) {
		for(Person p:list) {
			p.accept(visiter);
		}
	}
}

import java.util.ArrayList;
import java.util.List;

/*
 * 访问者模式基本代码
 */
public class Demo2 {
	public static void main(String[] args) {
		ObjecStructure o =new ObjecStructure();
		o.Attach(new ConcreteA());
		o.Attach(new ConcreteB());
		Visitor1 v1 = new Visitor1();
		Visitor2 v2 = new Visitor2();
		o.Accept(v1);
		System.out.println("=====================================");
		o.Accept(v2);
	}
}
interface Visitor{
	void VisitConcreteA(ConcreteA A);
	void VisitConcreteB(ConcreteB B);
}
class Visitor1 implements Visitor{

	@Override
	public void VisitConcreteA(ConcreteA A) {
		// TODO Auto-generated method stub
		System.out.println(A.getClass().toString()+"被"+this.getClass().toString()+"访问");
	}

	@Override
	public void VisitConcreteB(ConcreteB B) {
		// TODO Auto-generated method stub
		System.out.println(B.getClass().toString()+"被"+this.getClass().toString()+"访问");
	}
	
}
class Visitor2 implements Visitor{

	@Override
	public void VisitConcreteA(ConcreteA A) {
		// TODO Auto-generated method stub
		System.out.println(A.getClass().toString()+"被"+this.getClass().toString()+"访问");
	}

	@Override
	public void VisitConcreteB(ConcreteB B) {
		// TODO Auto-generated method stub
		System.out.println(B.getClass().toString()+"被"+this.getClass().toString()+"访问");
	}
}
abstract class Element{
	public abstract void Accept(Visitor visitor);
}
class ConcreteA extends Element{

	@Override
	public void Accept(Visitor visitor) {
		// TODO Auto-generated method stub
		visitor.VisitConcreteA(this);
	}
	public void OperatorA() {
		
	}
	
}
class ConcreteB extends Element{

	@Override
	public void Accept(Visitor visitor) {
		// TODO Auto-generated method stub
		visitor.VisitConcreteB(this);
	}
	public void OperatorB() {
		
	}
	
}
class ObjecStructure{
	private List<Element> list = new ArrayList<Element>();
	public void Attach(Element element) {
		list.add(element);
	}
	public void Detach(Element element) {
		list.remove(element);
	}
	public void Accept(Visitor visitor) {
		for(Element p:list) {
			p.Accept(visitor);
		}
	}
}

在这里插入图片描述

月照彩云归*
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JAVA-设计模式-行为型模式-访问者模式
08-10
JAVA-设计模式-行为型模式-访问者模式
Java设计模式之访问者模式
Bulut0907
09-06 1203
定义：访问者模式(Visitor Pattern)，封装一些作用于某种数据结构的各元素的操作，它可以在不改变数据结构的前提下定义作用于这些元素的新的操作。基本工作原理是：在被访问的类里面加一个对外提供接待访问者的接口优点可以很方便的添加新的访问者，保证了开闭原则，利于维护将数据结构与数据操作分离，解决数据结构和操作耦合性问题符合单一职责原则、让程序具有优秀的扩展性、灵活性非常高可以对功能进行统一，可以做报表、UI、拦截器与过滤器，适用于数据结构相对稳定的系统缺点不能方便的添加新的元素者。
【每天一个java设计模式（二十三）】 - 访问者模式
1+1=王的博客
12-24 4250
在访问者模式中，我们使用了一个访问者类，它改变了元素类的执行算法。通过这种方式，元素的执行算法可以随着访问者改变而改变。这种类型的设计模式属于行为型模式。根据模式，元素对象已接受访问者对象，这样访问者对象就可以处理元素对象上的操作。 访问者模式包含以下主要角色。 抽象访问者角色：定义一个访问具体元素的接口，为每个具体元素类对应一个访问操作 visit() ，该操作中的参数类型标识了被访问的具体元素。 具体访问者角色：实现抽象访问者角色中声明的各个访问操作，确定访问者访问一个元素时该做什么。 抽象元素角色：
Java设计模式（八）—— 访问者模式
weixin_49561506的博客
03-28 724
设计模式之访问者模式
Java设计模式（二十一）行为型- 访问者模式 Visitor Pattern（史上最全访问者模式）与使用场景以及优缺点
移动端开发与最新技术
05-19 460
访问者模式
Java描述设计模式(23)：访问者模式
【积累】，是一个长期持续的过程。
11-26 450
1、优点描述(1)访问者模式符合单一职责原则、使程序具有良好的扩展性、灵活性；(2)访问者模式适用与拦截器与过滤器等常见功能，数据结构相对稳定的场景；2、缺点描述(1)访问者关注其他类的内部细节，依赖性强，违反迪米特法则,这样导致具体元素更新麻烦；(2)访问者依赖具体元素，不是抽象元素，面向细节编程，违背依赖倒转原则；ENDhttpshttps。...
java设计模式-访问者模式
02-27
设计模式（Design pattern）代表了最佳的实践，通常被有经验的面向对象的软件开发人员所采用。设计模式是软件开发人员在软件开发过程中面临的一般问题的解决方案。这些解决方案是众多软件开发人员经过相当长的一段...
Java设计模式-图解-附代码.doc
09-19
包括策略模式、模板方法模式、观察者模式、迭代器模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、解释器模式等。这些模式涉及到算法选择、事件处理、异步通信等多种软件设计问题。 设计模式不仅仅...
Java-设计模式.zip
06-15
这个“Java-设计模式.zip”压缩包很可能是包含一系列关于Java设计模式的教程或者代码示例。其中，“2.Java面对-10-设计模式”可能是一个文档或章节，专门讨论面向对象的设计模式。 设计模式分为三类：创建型、结构...
design-pattern-Java设计模式
最新发布
04-10
Java设计模式是软件开发中的重要概念，它是一种在特定情境下解决常见问题的经验总结和标准解决方案。设计模式并不直接提供代码实现，而是提供了一种通用的语言，让开发者能够更好地理解和交流复杂的系统架构。这些...
Java使用访问者模式解决公司层级结构图问题详解
08-27
主要介绍了Java使用访问者模式解决公司层级结构图问题,结合实例形式分析了访问者模式的概念、原理及Java使用访问者模式解决公司曾经结构图问题的相关操作技巧与注意事项,需要的朋友可以参考下
访问者模式讨论篇：java的动态绑定与双分派
12-22
java的动态绑定 　　所谓的动态绑定是指程执行期间（而不是在编译期间）判断所引用对象的实际类型，根据其实际的类型调用其相应的方法。java继承体系中的覆盖是动态绑定的，看一下如下的代码： class Father { public void method(){ System.out.println("This is Father's method"); } } class Son1 extends Father{ public void method(){ System.out.println("This is Son1's method"); } } class S
举例讲解设计模式中的访问者模式在Java编程中的运用
09-02
主要介绍了举例讲解设计模式中的访问者模式在Java编程中的运用,访问者模式是一种将算法与对象结构分离的软件设计模式,需要的朋友可以参考下
设计模式的访问者模式的例子
12-21
设计模式的访问者模式的例子，希望对大家有用~~~~~~~~
访问者模式
实践求真知
02-20 445
一 点睛 定义 封装一些作用于某种数据结构中的各元素的操作，它可以在不改变这个数据结构的前提下定义作用于这些元素的新的操作。 二 结构 访问者模式包含以下主要角色: 抽象访问者（Visitor）角色：定义了对每一个元素（Element）访问的行为，它的参数就是可以访问的元素，它的方法个数理论上来讲与元素类个数（Element的实现类个数）是一样的，从这点不难看出，访问者模式要求元素类的个数不能改变。 具体访问者（ConcreteVisitor）角色：给出对每一个元素类访问时所产生的具体行为。 抽象元素（E
访问者模式(JAVA)
qq_38785977的博客
07-23 264
/基础用户信息publicabstractclassUser{//姓名publicStringidentity;//身份；重点班、普通班|特级教师、普通教师、实习教师publicStringclazz;//班级publicUser(Stringname,Stringidentity,Stringclazz){}//核心访问方法publicabstractvoidaccept(Visitorvisitor);}基础信息包括。...
Java 访问者设计模式
湖人•总冠军
02-25 276
前言： 访问者模式，是行为型设计模式之一。访问者模式是一种将数据操作与数据结构分离的设计模式，它可以算是 23 中设计模式中最复杂的一个，但它的使用频率并不是很高，大多数情况下，你并不需要使用访问者模式，但是当你一旦需要使用它时，那你就是需要使用它了。 当我们想要在不改变类的情况下为对象结构的类定义新操作时，我们使用访问者模式。想象一下，对API执行HTTP请求的软件场景。...
设计模式学习（十四）访问者模式
qq_41816516的博客
10-26 348
访问者模式 前言 首先通过一个案例来看看为何要访问者模式： 传统方法分析： 如果系统比较小，还是 ok 的，但是考虑系统增加越来越多新的功能时，对代码改动较大，违反了 ocp 原则， 不利于维护 扩展性不好，比如增加了新的人员类型，或者管理方法，都不好做 基本介绍 访问者模式封装一些作用于某种数据结构的各元素的操作，它可以在不改变数据结构的前提下定义作用于这些元素的新的操作 。 主要将数据结构与数据操作分离，解决数据结构和操作耦合性问题 访问者模式的基本工作原理是： 在被访问的类里面加一个对外提供接
java visitor_Java设计模式(三) Visitor(访问者)模式及多分派场景应用
weixin_36206388的博客
02-21 219
基本概念Visitor封装一些作用于数据结构中的各元素的操作，不同的操作可以借助新的visitor实现，降低了操作间的耦合性 访问者可以将数据结构和对数据的操作解耦，使得增加对数据结构的操作不需要取修改数据结构，也不必去修改原有的操作，而执行时再定义新的Visitor时闲着就行了(在操作添加上易拓展)模式中角色分工Visitor:抽象访问者，在重载的visit函数中声明访问者可以访问的对象。 Co...
图解Java设计模式-23种设计模式
08-28
- 访问者模式（Visitor Pattern） 4. 并发型模式（Concurrency Patterns）： - 保护性暂停模式（Guarded Suspension Pattern） - 生产者-消费者模式（Producer-Consumer Pattern） - 读写锁模式（Read-Write ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值