行为型模式[访问者模式]
访问者模式是一种将数据结构与数据操作分离的设计模式。是指封装一些作用于某些数据结构中的各元素的操作，它可以在不改变数据结构的前提下定义作用于这些元素的新的操作。属于行为型模式。
访问者模式被称为最复杂的设计模式，并且使用频率不高，设计模式的作者也评论为：大多数情况下，你不需要使用访问者模式，但是一旦需要使用它时，那就是真的需要使用了。访问者模式的基本思想时，针对系统中拥有固定类型数的对象结构（元素），在其内提供一个accept()方法用来接受访问者对象的访问。不同的访问者对同一元素的访问内容不同，使得相同的元素集合可以产生不同的数据结果。accept()方法可以接收不同的访问者对象，然后在内部将自己（元素）转发到接收到的访问者对象的visit()方法内。访问者内部对应类型的visit()方法就会得到回调执行，对元素进行操作。也就是通过两次动态转发（第一次是对访问者的分发accept()方法，第二次是对元素的分发visit()方法），才最终将一个具体的元素传递到一个具体的访问者。如此一来，就解耦了数据结构与操作，且数据操作不会改变元素状态。
访问者模式的核心是，解耦数据结构与数据操作，使得对元素的操作具备优秀的扩展性。可以通过扩展不同的数据操作类型（访问者）实现对相同元素集的不同的操作。
访问者模式的应用场景
1、数据结构稳定，作用于数据结构的操作经常变化的场景。
2、需要数据结构与数据操作分离的场景。
3、需要对不同数据类型（元素）进行操作，而不使用分支判断具体类型的场景。
访问者模式通用UML类图：
1、抽象访问者（visit）：接口或者抽象类，该类对应了每一个具体元素（Hero子类）的访问行为visit()方法，其参数就是具体的元素(Hero)对象。理论上来说，visit的方法个数与元素(Hero子类)个数是相等的。如果元素
（Hero）个数变动会导致visit的方法也要进行变动，此时，该情形并不适用访问者模式。
2、具体访问者（Player子类）：实现对具体元素的操作。
3、抽象元素（Hero）：接口或抽象类，定义了一个接受访问者访问的方法accept()，表示所有元素类型都支持被访问者访问。
4、具体元素（Hero子类）：具体元素类型，提供接受访问者的具体实现。
5、结构对象（ObjectStruture）：该类内部维护了元素集合，并提供方法接受访问者对该集合所有元素进行操作。
// 抽象元素
public interface Hero { // 英雄
void accept(Player player);
}
// 具体元素
public class DaYeHero implements Hero{// 打野英雄
private String name;
private int score;
public DaYeHero(String name) {
this.name = name;
this.score = score();
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getScore() {
return score;
}
public void setScore(int score) {
this.score = score;
}
public void accept(Player player) {
player.visit(this);
}
public int score() {
return new Random().nextInt(100);
}
}
public class FuZhuHero implements Hero {// 辅助英雄
private String name;
private int score;
public FuZhuHero(String name) {
this.name = name;
this.score = score();
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getScore() {
return score;
}
public void setScore(int score) {
this.score = score;
}
public void accept(Player player) {
player.visit(this);
}
public int score() {
return new Random().nextInt(100);
}
}
public class ShangDanHero implements Hero {// 上单英雄
private String name;
private int score;
public ShangDanHero(String name) {
this.name = name;
this.score = score();
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getScore() {
return score;
}
public void setScore(int score) {
this.score = score;
}
public void accept(Player player) {
player.visit(this);
}
public int score() {
return new Random().nextInt(100);
}
}
public class SheShouHero implements Hero {// 射手英雄
private String name;
private int score;
public SheShouHero(String name) {
this.name = name;
this.score = score();
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getScore() {
return score;
}
public void setScore(int score) {
this.score = score;
}
public void accept(Player player) {
player.visit(this);
}
public int score() {
return new Random().nextInt(100);
}
}
public class ZhongDanHero implements Hero{// 中单英雄
private String name;
private int score;
public ZhongDanHero(String name) {
this.name = name;
this.score = score();
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getScore() {
return score;
}
public void setScore(int score) {
this.score = score;
}
public void accept(Player player) {
player.visit(this);
}
public int score() {
return new Random().nextInt(100);
}
}
// 抽象访问者（visit）
public interface Player { // 玩家
void visit(DaYeHero daYeHero);
void visit(FuZhuHero fuZhuHero);
void visit(ShangDanHero shangDanHero);
void visit(SheShouHero sheShouHero);
void visit(ZhongDanHero zhongDanHero);
}
// 具体访问者
public class DaYePlayer implements Player{ // 打野玩家
public void visit(DaYeHero daYeHero) {
System.out.println("没有打野他们啥都不是，打野无敌，给"+daYeHero.getName()+"这个英雄打个"+(daYeHero.score()*0.5));
}
public void visit(FuZhuHero fuZhuHero) {
System.out.println("辅助这个位置就是大混子，给"+fuZhuHero.getName()+"这个英雄打个"+(fuZhuHero.score()*0.2));
}
public void visit(ShangDanHero shangDanHero) {
System.out.println("上单这个位置混子，给"+shangDanHero.getName()+"这个英雄打个"+(shangDanHero.score()*0.6));
}
public void visit(SheShouHero sheShouHero) {
System.out.println("射手这个位置混子，给"+sheShouHero.getName()+"这个英雄打个"+(sheShouHero.score()*0.1));
}
public void visit(ZhongDanHero zhongDanHero) {
System.out.println("中单菜就算了还不给我吃线，混子，给"+zhongDanHero.getName()+"这个英雄打个"+(zhongDanHero.score()));
}
}
public class FuZhuPlayer implements Player{ //辅助玩家
public void visit(DaYeHero daYeHero) {
System.out.println("打野马仔，给"+daYeHero.getName()+"这个英雄打个"+(daYeHero.score()*0.2));
}
public void visit(FuZhuHero fuZhuHero) {
System.out.println("辅助是baba，给"+fuZhuHero.getName()+"这个英雄打个"+(fuZhuHero.score()*1.1));
}
public void visit(ShangDanHero shangDanHero) {
System.out.println("上单废物，给"+shangDanHero.getName()+"这个英雄打个"+(shangDanHero.score()*0.2));
}
public void visit(SheShouHero sheShouHero) {
System.out.println("射手erzi，给"+sheShouHero.getName()+"这个英雄打个"+(sheShouHero.score()*0.3));
}
public void visit(ZhongDanHero zhongDanHero) {
System.out.println("中单废物，给"+zhongDanHero.getName()+"这个英雄打个"+(zhongDanHero.score()*2));
}
}
public class ZhongDanPlayer implements Player{ // 中单玩家
public void visit(DaYeHero daYeHero) {
System.out.println("打野这个位置嘛，就会吃我中路线啥用都没有，给"+daYeHero.getName()+"这个英雄打个"+(daYeHero.score()*0.5));
}
public void visit(FuZhuHero fuZhuHero) {
System.out.println("辅助这个位置就是大混子，给"+fuZhuHero.getName()+"这个英雄打个"+(fuZhuHero.score()*0.2));
}
public void visit(ShangDanHero shangDanHero) {
System.out.println("上单这个位置也不会支援人，就知道在上路呆着，给"+shangDanHero.getName()+"这个英雄打个"+(shangDanHero.score()*0.6));
}
public void visit(SheShouHero sheShouHero) {
System.out.println("射手这个位置不用说就只会补兵啥事不会，给"+sheShouHero.getName()+"这个英雄打个"+(sheShouHero.score()*0.1));
}
public void visit(ZhongDanHero zhongDanHero) {
System.out.println("中单无敌误解，给"+zhongDanHero.getName()+"这个英雄打个"+(zhongDanHero.score()));
}
}
// 结构对象
public class ObjectStructure {
private List<Hero> list = new ArrayList<Hero>();
{
this.list.add(new DaYeHero("娜可露露"));
this.list.add(new FuZhuHero("牛魔"));
this.list.add(new ZhongDanHero("高渐离"));
this.list.add(new DaYeHero("赵云"));
this.list.add(new FuZhuHero("大乔"));
this.list.add(new FuZhuHero("太乙真人"));
this.list.add(new ShangDanHero("马超"));
this.list.add(new SheShouHero("艾琳"));
this.list.add(new ShangDanHero("关羽"));
this.list.add(new SheShouHero("公孙离"));
this.list.add(new ZhongDanHero("杨玉环"));
this.list.add(new SheShouHero("李元芳"));
}
public void accept(Player player) {
for (Hero hero : this.list) {
hero.accept(player);
System.out.println();
}
}
}
public class Test {
public static void main(String[] args) {
ObjectStructure objectStructure = new ObjectStructure();
System.out.println("===============打野评论=================");
objectStructure.accept(new DaYePlayer());
System.out.println("===============中单评论=================");
objectStructure.accept(new ZhongDanPlayer());
System.out.println("===============辅助评论=================");
objectStructure.accept(new FuZhuPlayer());
}
}
访问者模式优缺点
优点：
1、解耦了数据结构与数据操作，使得操作集合可以独立变化。
2、扩展性好：可以通过扩展访问者角色，实现对数据集得不同操作。
3、元素具体类型并非单一，访问者均可操作.
4、各角色职责分离，符合单一职责原则。
缺点：
1、无法添加元素类型：诺系统数据结构对象易于变化，经常有新的数据对象添加进来，则访问者类必须添加对应元素类型的操作，违背了开闭原则。
2、具体元素变更困难：具体元素添加属性，删除属性等操作会导致对应的访问者类需要进行相应的修改，尤其当大量访问者类时，修改范围太大。
3、违背依赖倒置原则：为了达到【区别对待】，访问者依赖的时具体元素类型，而不是抽象。
1175
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
