您的位置: 首页  >  文章  >  java访问者模式

java访问者模式

分类: 文章 • 2025-04-19 13:51:22

原文链接： http://blog.****.net/sidihuo/article/details/54892215


一般场景：一个数据结构可以被多种不同对象访问操作；

类比：医院开的方子，可以被划价员计算医药费，可以被药房抓药，。。。


demo：

 抽象访问者：Visitor.Java

[java] view plain copy
  1. public abstract class Visitor {  
  2.     protected String name;  
  3.   
  4.     public void setName(String name) {  
  5.         this.name = name;  
  6.     }  
  7.       
  8.       
  9.     public abstract void visitor(MedicineA a);  
  10.       
  11.     public abstract void visitor(MedicineB b);  
  12. }  

具体访问者：划价员、Charger.java

[java] view plain copy
  1. public class Charger extends Visitor{  
  2.   
  3.     public void visitor(MedicineA a) {  
  4.         System.out.println("划价员：" + name +"给药" + a.getName() +"划价:" + a.getPrice());  
  5.     }  
  6.   
  7.     public void visitor(MedicineB b) {  
  8.         System.out.println("划价员：" + name +"给药" + b.getName() +"划价:" + b.getPrice());  
  9.     }  
  10.       
  11. }  
具体访问者：药房工作者、WorkerOfPharmacy.java

[java] view plain copy
  1. public class WorkerOfPharmacy extends Visitor{  
  2.   
  3.     public void visitor(MedicineA a) {  
  4.         System.out.println("药房工作者：" + name + "拿药 ：" + a.getName());  
  5.     }  
  6.   
  7.     public void visitor(MedicineB b) {  
  8.         System.out.println("药房工作者：" + name + "拿药 ：" + b.getName());  
  9.     }  
  10.       
  11. }  

抽象元素：Medicine.java

[java] view plain copy
  1. public abstract class Medicine {  
  2.     protected String name;  
  3.     protected double price;  
  4.   
  5.     public Medicine (String name,double price){  
  6.         this.name = name;  
  7.         this.price = price;  
  8.     }  
  9.       
  10.     public String getName() {  
  11.         return name;  
  12.     }  
  13.   
  14.     public void setName(String name) {  
  15.         this.name = name;  
  16.     }  
  17.   
  18.     public double getPrice() {  
  19.         return price;  
  20.     }  
  21.       
  22.     public void setPrice(double price) {  
  23.         this.price = price;  
  24.     }  
  25.       
  26.     public abstract void accept(Visitor visitor);  
  27. }  
具体元素：MedicineA.java

[java] view plain copy
  1. public class MedicineA extends Medicine{  
  2.   
  3.     public MedicineA(String name, double price) {  
  4.         super(name, price);  
  5.     }  
  6.   
  7.     public void accept(Visitor visitor) {  
  8.         visitor.visitor(this);  
  9.     }  
  10. }  
具体元素：MedicineB.java

[java] view plain copy
  1. public class MedicineB extends Medicine{  
  2.   
  3.     public MedicineB(String name, double price) {  
  4.         super(name, price);  
  5.     }  
  6.   
  7.     public void accept(Visitor visitor) {  
  8.         visitor.visitor(this);  
  9.     }  
  10. }  
药单：Presciption.java

[java] view plain copy
  1. public class Presciption {  
  2.     List<Medicine> list = new ArrayList<Medicine>();  
  3.       
  4.     public void accept(Visitor visitor){  
  5.         Iterator<Medicine> iterator = list.iterator();  
  6.           
  7.         while (iterator.hasNext()) {  
  8.             iterator.next().accept(visitor);  
  9.         }  
  10.     }  
  11.       
  12.     public void addMedicine(Medicine medicine){  
  13.         list.add(medicine);  
  14.     }  
  15.       
  16.     public void removeMedicien(Medicine medicine){  
  17.         list.remove(medicine);  
  18.     }  
  19. }  
客户端：Client.java

[java] view plain copy
  1. public class Client {  
  2.     public static void main(String[] args) {  
  3.         Medicine a = new MedicineA("板蓝根", 11.0);  
  4.         Medicine b = new MedicineB("感康", 14.3);  
  5.           
  6.         Presciption presciption = new Presciption();  
  7.         presciption.addMedicine(a);  
  8.         presciption.addMedicine(b);  
  9.           
  10.         Visitor charger = new Charger();  
  11.         charger.setName("张三");  
  12.           
  13.         Visitor workerOfPharmacy = new WorkerOfPharmacy();  
  14.         workerOfPharmacy.setName("李四");  
  15.           
  16.         presciption.accept(charger);  
  17.         System.out.println("-------------------------------------");  
  18.         presciption.accept(workerOfPharmacy);  
  19.     }  
  20.   
  21. }  
java访问者模式




模式优缺点

       优点

          1、使得新增新的访问操作变得更加简单。

          2、能够使得用户在不修改现有类的层次结构下，定义该类层次结构的操作。

          3、将有关元素对象的访问行为集中到一个访问者对象中，而不是分散搞一个个的元素类中。

       缺点

          1、增加新的元素类很困难。在访问者模式中，每增加一个新的元素类都意味着要在抽象访问者角色中增加一个新的抽象操作，并在每一个具体访问者类中增加相应的具体操作，违背了“开闭原则”的要求。
           2、破坏封装。当采用访问者模式的时候，就会打破组合类的封装。

          3、比较难理解。貌似是最难的设计模式了。

 模式适用场景

       1、对象结构中对象对应的类很少改变，但经常需要在此对象结构上定义新的操作。

       2、需要对一个对象结构中的对象进行很多不同的并且不相关的操作，而需要避免让这些操作“污染”这些对象的类，也不希望在增加新操作时修改这些类。

  模式总结

       1、访问者模式封装了对象结构元素之上的操作，使得新增元素的操作变得非常简单。所以它比较适用于那么对象结构很少变化的类。

       2、访问者模式中对象结构存储了不同类型的元素对象，以供不同访问者访问。


相关推荐