ftp做网站,企业网站php,深圳注册公司需要什么资料,广州网站建设网站推广文章目录 1 访问者模式#xff08;Visitor Pattern#xff09;1.1 介绍1.2 概述1.3 访问者模式的结构1.4 访问者模式的优缺点1.5 访问者模式的使用场景 2 案例一2.1 需求2.2 代码实现 3 案例二3.1 需求3.2 代码实现 4 拓展——双分派4.1 分派4.2 动态分派#xff08;多态Visitor Pattern1.1 介绍1.2 概述1.3 访问者模式的结构1.4 访问者模式的优缺点1.5 访问者模式的使用场景 2 案例一2.1 需求2.2 代码实现 3 案例二3.1 需求3.2 代码实现 4 拓展——双分派4.1 分派4.2 动态分派多态4.3 静态分派重载4.4 双分派 前言本文章为瑞_系列专栏之《23种设计模式》的访问者模式篇。本文中的部分图和概念等资料来源于博主学习设计模式的相关网站《菜鸟教程 | 设计模式》和《黑马程序员Java设计模式详解》特此注明。本文中涉及到的软件设计模式的概念、背景、优点、分类、以及UML图的基本知识和设计模式的6大法则等知识建议阅读 《瑞_23种设计模式_概述》 本系列 - 设计模式 - 链接《瑞_23种设计模式_概述》 ⬇️本系列 - 创建型模式 - 链接 单例模式《瑞_23种设计模式_单例模式》 工厂模式《瑞_23种设计模式_工厂模式》 原型模式《瑞_23种设计模式_原型模式》 抽象工厂模式《瑞_23种设计模式_抽象工厂模式》 建造者模式《瑞_23种设计模式_建造者模式》 ⬇️本系列 - 结构型模式 - 链接 代理模式《瑞_23种设计模式_代理模式》 适配器模式《瑞_23种设计模式_适配器模式》 装饰者模式《瑞_23种设计模式_装饰者模式》 桥接模式《瑞_23种设计模式_桥接模式》 外观模式《瑞_23种设计模式_外观模式》 组合模式《瑞_23种设计模式_组合模式》 享元模式《瑞_23种设计模式_享元模式》 ⬇️本系列 - 行为型模式 - 链接 模板方法模式《瑞_23种设计模式_模板方法模式》 策略模式《瑞_23种设计模式_策略模式》 命令模式《瑞_23种设计模式_命令模式》 职责链模式《瑞_23种设计模式_职责链模式》 状态模式《瑞_23种设计模式_状态模式》 观察者模式《瑞_23种设计模式_观察者模式》 中介者模式《瑞_23种设计模式_中介者模式》 迭代器模式《瑞_23种设计模式_迭代器模式》 访问者模式《后续更新》 备忘录模式《后续更新》 解释器模式《后续更新》 1 访问者模式Visitor Pattern 在访问者模式Visitor Pattern中我们使用了一个访问者类它改变了元素类的执行算法。通过这种方式元素的执行算法可以随着访问者改变而改变。这种类型的设计模式属于行为型模式。根据模式元素对象已接受访问者对象这样访问者对象就可以处理元素对象上的操作。 瑞行为型模式用于描述程序在运行时复杂的流程控制即描述多个类或对象之间怎样相互协作共同完成单个对象都无法单独完成的任务它涉及算法与对象间职责的分配。 瑞行为型模式分为类行为模式和对象行为模式前者采用继承机制来在类间分派行为后者采用组合或聚合在对象间分配行为。由于组合关系或聚合关系比继承关系耦合度低满足“合成复用原则”所以对象行为模式比类行为模式具有更大的灵活性。 访问者模式属于对象行为模式 1.1 介绍 意图主要将数据结构与数据操作分离。 主要解决稳定的数据结构和易变的操作耦合问题。 何时使用需要对一个对象结构中的对象进行很多不同的并且不相关的操作而需要避免让这些操作污染这些对象的类使用访问者模式将这些封装到类中。 如何解决在被访问的类里面加一个对外提供接待访问者的接口。 关键代码在数据基础类里面有一个方法接受访问者将自身引用传入访问者。 应用实例 您在朋友家做客您是访问者朋友接受您的访问您通过朋友的描述然后对朋友的描述做出一个判断这就是访问者模式。 优点 1️⃣ 符合单一职责原则。 2️⃣ 优秀的扩展性。 3️⃣ 灵活性。 缺点 1️⃣ 具体元素对访问者公布细节违反了迪米特原则。 2️⃣ 具体元素变更比较困难。 3️⃣ 违反了依赖倒置原则依赖了具体类没有依赖抽象。 使用场景 1️⃣ 对象结构中对象对应的类很少改变但经常需要在此对象结构上定义新的操作。 2️⃣ 需要对一个对象结构中的对象进行很多不同的并且不相关的操作而需要避免让这些操作污染这些对象的类也不希望在增加新操作时修改这些类。 注意事项 1️⃣ 访问者可以对功能进行统一可以做报表、UI、拦截器与过滤器。
1.2 概述 定义封装一些作用于某种数据结构中的各元素的操作它可以在不改变这个数据结构的前提下定义作用于这些元素的新的操作。 访问者模式的主要思想是将一些作用于某种数据结构中的各元素的操作封装起来使得可以在不改变数据结构的前提下定义作用于这些元素的新的操作。 在访问者模式中针对系统中拥有固定类型数的对象结构元素在其内提供一个accept()方法来接受访问者对象的访问。不同的访问者对同一个元素的访问内容是不同的这使得相同的元素集合可以产生不同的数据结果。
1.3 访问者模式的结构
访问者模式主要包含以下角色: 1️⃣ 抽象访问者Visitor角色定义了对每一个元素Element访问的行为它的参数就是可以访问的元素它的方法个数理论上来讲与元素类个数Element的实现类个数是一样的从这点不难看出访问者模式要求元素类的个数不能改变。 2️⃣ 具体访问者ConcreteVisitor角色给出对每一个元素类访问时所产生的具体行为。 3️⃣ 抽象元素Element角色定义了一个接受访问者的方法accept其意义是指每一个元素都要可以被访问者访问。 4️⃣ 具体元素ConcreteElement角色 提供接受访问方法的具体实现而这个具体的实现通常情况下是使用访问者提供的访问该元素类的方法。 5️⃣ 对象结构Object Structure角色定义当中所提到的对象结构对象结构是一个抽象表述具体点可以理解为一个具有容器性质或者复合对象特性的类它会含有一组元素Element并且可以迭代这些元素供访问者访问。
1.4 访问者模式的优缺点
优点 扩展性好 在不修改对象结构中的元素的情况下为对象结构中的元素添加新的功能。 复用性好 通过访问者来定义整个对象结构通用的功能从而提高复用程度。 分离无关行为 通过访问者来分离无关的行为把相关的行为封装在一起构成一个访问者这样每一个访问者的功能都比较单一。
缺点 对象结构变化很困难 在访问者模式中每增加一个新的元素类都要在每一个具体访问者类中增加相应的具体操作这违背了“开闭原则”。 违反了依赖倒置原则 访问者模式依赖了具体类而没有依赖抽象类。
1.5 访问者模式的使用场景
对象结构相对稳定但其操作算法经常变化的程序。对象结构中的对象需要提供多种不同且不相关的操作而且要避免让这些操作的变化影响对象的结构。 2 案例一 【案例】给宠物喂食 2.1 需求 现在养宠物的人特别多我们就以这个为例当然宠物还分为狗猫等要给宠物喂食的话主人可以喂其他人也可以喂食。
访问者角色给宠物喂食的人具体访问者角色主人、其他人抽象元素角色动物抽象类具体元素角色宠物狗、宠物猫结构对象角色主人家 类图如下 2.2 代码实现 创建抽象访问者接口
抽象访问者角色类接口 /*** 抽象访问者角色类** author LiaoYuXing-Ray**/
public interface Person {// 喂食宠物狗void feed(Cat cat);// 喂食宠物猫void feed(Dog dog);
}创建不同的具体访问者角色主人和其他人都需要实现 Person接口
具体访问者角色类(自己)类 /*** 具体访问者角色类(自己)** author LiaoYuXing-Ray**/
public class Owner implements Person {public void feed(Cat cat) {System.out.println(主人喂食猫);}public void feed(Dog dog) {System.out.println(主人喂食狗);}
}具体访问者角色类(其他人)类 /*** 具体访问者角色类(其他人)** author LiaoYuXing-Ray**/
public class Someone implements Person {public void feed(Cat cat) {System.out.println(其他人喂食猫);}public void feed(Dog dog) {System.out.println(其他人喂食狗);}
}定义抽象节点 – 宠物
抽象元素角色类接口 /*** 抽象元素角色类** author LiaoYuXing-Ray**/
public interface Animal {// 接受访问者访问的功能void accept(Person person);
}定义实现Animal接口的 具体节点元素
具体元素角色类宠物猫类 /*** 具体元素角色类宠物猫** author LiaoYuXing-Ray**/
public class Cat implements Animal {public void accept(Person person) {person.feed(this);// 访问者给宠物猫喂食System.out.println(好好吃喵喵喵。。。);}
}具体元素角色类宠物狗类 /*** 具体元素角色类宠物狗** author LiaoYuXing-Ray**/
public class Dog implements Animal {public void accept(Person person) {person.feed(this);// 访问者给宠物猫喂食System.out.println(好好吃汪汪汪。。。);}
}定义对象结构此案例中就是主人的家
对象结构类类 import java.util.ArrayList;
import java.util.List;/*** 对象结构类** author LiaoYuXing-Ray**/
public class Home {// 声明一个集合对象用来存储元素对象private final ListAnimal nodeList new ArrayListAnimal();// 添加元素功能public void add(Animal animal) {nodeList.add(animal);}public void action(Person person) {// 遍历集合获取每一个元素让访问者访问每一个元素for (Animal animal : nodeList) {animal.accept(person);}}
}测试类 /*** 测试类** author LiaoYuXing-Ray**/
public class Client {public static void main(String[] args) {// 创建Home对象Home home new Home();//添加元素到Home对象中home.add(new Dog());home.add(new Cat());// 创建主人对象Owner owner new Owner();Someone someone new Someone();// 让主人喂食所有的宠物home.action(owner);home.action(someone);}
} 代码运行结果如下 主人喂食狗好好吃汪汪汪。。。主人喂食猫好好吃喵喵喵。。。其他人喂食狗好好吃汪汪汪。。。其他人喂食猫好好吃喵喵喵。。。3 案例二 本案例为菜鸟教程中的案例 3.1 需求 我们将创建一个定义接受操作的 ComputerPart 接口。Keyboard、Mouse、Monitor 和 Computer 是实现了 ComputerPart 接口的实体类。我们将定义另一个接口 ComputerPartVisitor它定义了访问者类的操作。Computer 使用实体访问者来执行相应的动作。 VisitorPatternDemo我们的演示类使用 Computer、ComputerPartVisitor 类来演示访问者模式的用法。 3.2 代码实现
步骤 1 定义一个表示元素的接口。
ComputerPart.java public interface ComputerPart {public void accept(ComputerPartVisitor computerPartVisitor);
}步骤 2 创建扩展了上述类的实体类。
Keyboard.java public class Keyboard implements ComputerPart {Overridepublic void accept(ComputerPartVisitor computerPartVisitor) {computerPartVisitor.visit(this);}
}Monitor.java public class Monitor implements ComputerPart {Overridepublic void accept(ComputerPartVisitor computerPartVisitor) {computerPartVisitor.visit(this);}
}Mouse.java public class Mouse implements ComputerPart {Overridepublic void accept(ComputerPartVisitor computerPartVisitor) {computerPartVisitor.visit(this);}
}Computer.java public class Computer implements ComputerPart {ComputerPart[] parts;public Computer(){parts new ComputerPart[] {new Mouse(), new Keyboard(), new Monitor()}; } Overridepublic void accept(ComputerPartVisitor computerPartVisitor) {for (int i 0; i parts.length; i) {parts[i].accept(computerPartVisitor);}computerPartVisitor.visit(this);}
}步骤 3 定义一个表示访问者的接口。
ComputerPartVisitor.java public interface ComputerPartVisitor {public void visit(Computer computer);public void visit(Mouse mouse);public void visit(Keyboard keyboard);public void visit(Monitor monitor);
}步骤 4 创建实现了上述类的实体访问者。
ComputerPartDisplayVisitor.java public class ComputerPartDisplayVisitor implements ComputerPartVisitor {Overridepublic void visit(Computer computer) {System.out.println(Displaying Computer.);}Overridepublic void visit(Mouse mouse) {System.out.println(Displaying Mouse.);}Overridepublic void visit(Keyboard keyboard) {System.out.println(Displaying Keyboard.);}Overridepublic void visit(Monitor monitor) {System.out.println(Displaying Monitor.);}
}步骤 5 使用 ComputerPartDisplayVisitor 来显示 Computer 的组成部分。
VisitorPatternDemo.java public class VisitorPatternDemo {public static void main(String[] args) {ComputerPart computer new Computer();computer.accept(new ComputerPartDisplayVisitor());}
}步骤 6 执行程序输出结果 Displaying Mouse.Displaying Keyboard.Displaying Monitor.Displaying Computer.4 拓展——双分派 访问者模式用到了一种双分派的技术。 4.1 分派 变量被声明时的类型叫做变量的静态类型有些人又把静态类型叫做明显类型而变量所引用的对象的真实类型又叫做变量的实际类型。比如 Map map new HashMap() map变量的静态类型是 Map 实际类型是 HashMap 。根据对象的类型而对方法进行的选择就是分派(Dispatch)分派(Dispatch)又分为两种即静态分派和动态分派。 静态分派(Static Dispatch) 发生在编译时期分派根据静态类型信息发生。静态分派对于我们来说并不陌生方法重载就是静态分派。 动态分派(Dynamic Dispatch) 发生在运行时期动态分派动态地置换掉某个方法。Java通过方法的重写多态支持动态分派。
4.2 动态分派多态 通过方法的重写多态支持动态分派。 public class Animal {public void execute() {System.out.println(Animal);}
}public class Dog extends Animal {Overridepublic void execute() {System.out.println(dog);}
}public class Cat extends Animal {Overridepublic void execute() {System.out.println(cat);}
}public class Client {public static void main(String[] args) {Animal a new Dog();a.execute();Animal a1 new Cat();a1.execute();}
}执行程序输出结果 dogcat上面代码的结果大家应该直接可以说出来这不就是多态吗运行执行的是子类中的方法。 Java编译器在编译时期并不总是知道哪些代码会被执行因为编译器仅仅知道对象的静态类型而不知道对象的真实类型而方法的调用则是根据对象的真实类型而不是静态类型。
4.3 静态分派重载 通过方法重载支持静态分派。 public class Animal {
}public class Dog extends Animal {
}public class Cat extends Animal {
}public class Execute {public void execute(Animal a) {System.out.println(Animal);}public void execute(Dog d) {System.out.println(dog);}public void execute(Cat c) {System.out.println(cat);}
}public class Client {public static void main(String[] args) {Animal a new Animal();Animal a1 new Dog();Animal a2 new Cat();Execute exe new Execute();exe.execute(a);exe.execute(a1);exe.execute(a2);}
}执行程序输出结果 AnimalAnimalAnimal这个结果可能出乎一些你的意料了吧~ 因为重载方法的分派是根据静态类型进行的这个分派过程在编译时期就完成了。
4.4 双分派 所谓双分派技术就是在选择一个方法的时候不仅仅要根据消息接收者receiver的运行时区别还要根据参数的运行时区别。 public class Animal {public void accept(Execute exe) {exe.execute(this);}
}public class Dog extends Animal {public void accept(Execute exe) {exe.execute(this);}
}public class Cat extends Animal {public void accept(Execute exe) {exe.execute(this);}
}public class Execute {public void execute(Animal a) {System.out.println(animal);}public void execute(Dog d) {System.out.println(dog);}public void execute(Cat c) {System.out.println(cat);}
}public class Client {public static void main(String[] args) {Animal a new Animal();Animal d new Dog();Animal c new Cat();Execute exe new Execute();a.accept(exe);d.accept(exe);c.accept(exe);}
}在上面代码中客户端将 Execute 对象做为参数传递给 Animal 类型的变量调用的方法这里完成第一次分派这里是方法重写所以是动态分派也就是执行实际类型中的方法同时也将自己this作为参数传递进去这里就完成了第二次分派这里的 Execute 类中有多个重载的方法而传递进行的是this就是具体的实际类型的对象。 说到这里我们已经明白双分派是怎么回事了但是它有什么效果呢就是可以实现方法的动态绑定我们可以对上面的程序进行修改。运行结果如下 执行程序输出结果 animaldogcat双分派实现动态绑定的本质就是在重载方法委派的前面加上了继承体系中覆盖的环节由于覆盖是动态的所以重载就是动态的了 本文是博主的粗浅理解可能存在一些错误或不完善之处如有遗漏或错误欢迎各位补充谢谢 如果觉得这篇文章对您有所帮助的话请动动小手点波关注你的点赞收藏⭐️转发评论都是对博主最好的支持~
