程序博客网 > 淘宝怎么上掌柜热卖

vistor模式

来源：互联网 发布：淘宝怎么上掌柜热卖 编辑：程序博客网 时间：2024/05/16 19:30

这个访问者模式写的太棒了。。我也就不自己整理了 直接转过来

做了标题党=。=这一篇并没有介绍关于访问者模式的进阶，先说一下访问者模式的使用情况，这里引用大话设计模式的例子，因为讲得比较精辟。

假设有男人和女人两种元素，要分别打印出他们在不同状态时的不同表现。
用OO的思想把表现(行为)提取出来作为一个抽象方法，代码如下：

用if-else对状态进行判断
Person接口

Java代码 复制代码 收藏代码
  1. public interface Person {   
  2.       public void action(String state);   
  3. }  



Man实现类

Java代码 复制代码 收藏代码
  1. public class Man implements Person{   
  2.   
  3.     public void action(String state) {   
  4.         if(state == "success"){   
  5.             System.out.println("当男人成功时，背后多半有一个伟大的女人");   
  6.         }   
  7.         else if(state == "love"){   
  8.             System.out.println("当男人恋爱时，凡事不懂也装懂");   
  9.         }   
  10.     }      
  11. }  



Woman实现类

Java代码 复制代码 收藏代码
  1. public class Woman implements Person{   
  2.   
  3.     public void action(String state) {   
  4.         if(state == "success"){   
  5.             System.out.println("当女人成功时，背后大多有一个不成功的男人");   
  6.         }   
  7.         else if(state == "love"){   
  8.             System.out.println("当女人恋爱时，遇事懂也装不懂");   
  9.         }   
  10.     }   
  11.   
  12. }  



客户端测试代码

Java代码 复制代码 收藏代码
  1. public class Client {   
  2.      public static void main(String[] args) {   
  3.         Person man = new Man();   
  4.         Person woman = new Woman();   
  5.         man.action("success");   
  6.         woman.action("success");   
  7.            
  8.         man.action("love");   
  9.         woman.action("love");   
  10.     }   
  11. }  



结果显示：
当男人成功时，背后多半有一个伟大的女人
当女人成功时，背后大多有一个不成功的男人
当男人恋爱时，凡事不懂也装懂
当女人恋爱时，遇事懂也装不懂


当需求发生变化时，要增加一种失败状态时，增加男人女人的不同表现，这时就要修改Man类与Woman类的if else，违反了ocp原则(对增加开放-对修改封闭)。而且随着需求的增加，Man类与Woman类的if,else越来越臃肿，需要取消时，又要去修改if,else,既不方便，又容易出错。
这时候访问者模式可以派上用场了。
请看下面经修改后的类图:




使用访问者模式

把状态抽象出来成为一个接口(访问者)，不同的状态就作为状态的不同实现类(不同的访问者)。
状态的接口(访问者接口)

Java代码 复制代码 收藏代码
  1. public interface Visitor {   
  2.       public void visit(Man man);   
  3.       public void visit(Woman woman);   
  4. }  



具体访问者实现类(分别代表不同的状态)

Java代码 复制代码 收藏代码
  1. //成功时Man与Woman的不同表现   
  2. public class Success implements Visitor{   
  3.   
  4.     public void visit(Man man) {   
  5.         System.out.println("当男人成功时，背后多半有一个伟大的女人");   
  6.     }   
  7.   
  8.     public void visit(Woman woman) {   
  9.         System.out.println("当女人成功时，背后大多有一个不成功的男人");   
  10.     }   
  11. }   
  12.   
  13.   
  14. public class Love implements Visitor{   
  15.   
  16.     public void visit(Man man) {   
  17.         System.out.println("当男人恋爱时，凡事不懂也装懂");   
  18.     }   
  19.   
  20.     public void visit(Woman woman) {   
  21.         System.out.println("当女人恋爱时，遇事懂也装不懂");   
  22.     }   
  23. }  



按照类图改造一下人的接口与实现类

Java代码 复制代码 收藏代码
  1. public interface Person {   
  2.       void accept(Visitor visitor);   
  3. }   
  4.   
  5.   
  6. public class Man implements Person{   
  7.   
  8.     public void accept(Visitor visitor) {   
  9.         visitor.visit(this);   
  10.     }   
  11. }   
  12.   
  13.   
  14. public class Woman implements Person{   
  15.   
  16.     public void accept(Visitor visitor) {   
  17.           visitor.visit(this);   
  18.     }   
  19. }  


这时Man与Woman变得轻盈多了，不再需要写一大段的if,else，只需要按不同的状态，传入不同的访问者，执行访问者的方法就OK了。


为了更好地实现客户类与具体元素的解耦，加入一个ObjectStructure类。有了ObjectStructure能更方便地执行一些任何，其具体细节对于客户端来说是透明的。

Java代码 复制代码 收藏代码
  1. import java.util.*;   
  2.   
  3. public class ObjectStructure {   
  4.     private List<Person> elements = new ArrayList<Person>();   
  5.   
  6.     public void attach(Person element){   
  7.         elements.add(element);   
  8.     }   
  9.        
  10.     public void detach(Person element){   
  11.         elements.remove(elements);   
  12.     }   
  13.        
  14.     //遍历各种具体元素并执行他们的accept方法   
  15.     public void display(Visitor visitor){   
  16.         for(Person p:elements){   
  17.             p.accept(visitor);   
  18.         }   
  19.     }   
  20. }  



客户端测试代码：

Java代码 public class Client {   
  1.       public static void main(String[] args) {   
  2.         ObjectStructure o = new ObjectStructure();  //依赖于ObjectStructure   
  3.         //实例化具体元素   
  4.         o.attach(new Man());     
  5.         o.attach(new Woman());   
  6.            
  7.         //当成功时不同元素的不同反映   
  8.         Visitor success = new Success();           //依赖于抽象的Visitor接口   
  9.         o.display(success);   
  10.            
  11.         //当恋爱时的不同反映   
  12.         Visitor amativeness = new Love();          //依赖于抽象的Visitor接口   
  13.         o.display(amativeness);   
  14.     }   
  15. }  



这时客户端只依赖于ObjectStructure类与Visitor接口，实现了高度的解耦，具体Visitor实现类的实例化与具体元素(Man,Woman)的创建可以通过工厂模式甚至配合properties/xml配置文件创建，无需客户端关注。而Man与Gril的创建的代码也可以放在其他地方，客户端无需知道，如可以放到ObjectStructure的构造函数中完成

Java代码public ObjectStructure(){   
  1.     attach(new Man());     
  2.     attach(new Woman());   
  3. }  


在实例块{ }中完成实例化也可以。这时如果要增加一种状态的不同操作，只需要增加一个具体访问者，无需要修改具体元素类Man与Woman。代码如下，

Java代码 复制代码 收藏代码
  1. public class Fail implements Visitor{   
  2.   
  3.     public void visit(Man man) {   
  4.         System.out.println("当男人失败时，闷头喝酒，谁也不用劝");   
  5.     }   
  6.   
  7.     public void visit(Woman woman) {   
  8.         System.out.println("当女人失败时，眼泪汪汪，谁也劝不了");   
  9.     }   
  10. }  



修改一下客户端测试代码就OK：

Java代码 public class Client {   
  1.       public static void main(String[] args) {   
  2.         ObjectStructure o = new ObjectStructure();  //依赖于ObjectStructure   
  3.         //实例化具体元素   
  4.         o.attach(new Man());     
  5.         o.attach(new Woman());   
  6.            
  7.         //当成功时不同元素的不同反映   
  8.         Visitor success = new Success();           //依赖于抽象的Visitor接口   
  9.         o.display(success);   
  10.            
  11.         //当恋爱时的不同反映   
  12.         Visitor amativeness = new Love();          //依赖于抽象的Visitor接口   
  13.         o.display(amativeness);   
  14.            
  15.         //当失败时的不同反映   
  16.         Visitor fail = new Fail();   
  17.         o.display(fail);   
  18.     }   
  19. }  



结果显示：
当男人成功时，背后多半有一个伟大的女人
当女人成功时，背后大多有一个不成功的男人
当男人恋爱时，凡事不懂也装懂
当女人恋爱时，遇事懂也装不懂
当男人失败时，闷头喝酒，谁也不用劝
当女人失败时，眼泪汪汪，谁也劝不了



现在来让我们看看访问者模式的定义与类图：
访问者模式定义：表示一个作用于某个对象结构中的各元素的操作。它使可以在不改变各元素的类的前提下定义作用于这些元素的新操作。

在我看来可以把访问者模式想象成状态模式的或者策略模式的扩展版(说策略模式会更贴切，策略与状态是有区别的)，都是实现对象在不同情况下的不同表现，只是状态与策略主要是针对一种对象，而访问者是针对多种对象。





访问者模式的特点：
1)优点：使用了访问者模式以后，对于原来的类层次增加新的操作，仅仅需要实现一个具体访问者角色就可以了，而不必修改整个类层次，使得类层次结构的代码臃肿难以维护。而且这样符合“开闭原则”的要求。而且每个具体的访问者角色都对应于一个相关操作，因此如果一个操作的需求有变，那么仅仅修改一个具体访问者角色，而不用改动整个类层次。

2)访问者模式的双重分派技术
(1)将具体访问者作为参数传递给具体元素角色
(2)进入具体元素角色后，具体元素角色调用者作为参数的具体访问者的visit方法，同时将自己(this)作为参数传递进行。具体访问者再根据参数的不同来执行相应的方法

3)前提:开闭原则”的遵循总是片面的。如果系统中的类层次发生了变化，会对访问者模式产生什么样的影响呢？你必须修改访问者接口和每一个具体访问者。因此4人组曾经提出，访问者模式适用于数据结构相对稳定的系统。

4)适用情况：访问者模式的目的是要把处理从数据结构分离出来。很多系统可以按照算法和数据结构分开，如果这样的系统有比较稳定的数据结构，又有易于变化的算法的话，使用访问者模式是比较合适的，因为访问者模式似得算法操作的增加变得容易。反之，如果这样的系统的数据结构对象易于变化，经常要有新的数据对象增加进来，就不适合使用访问者模式。

 

 

淘宝怎么上掌柜热卖 淘宝怎么上掌柜热卖
原创粉丝点击
热门IT博客
unity3d 5.0 教程 pdfunity3d 5.0 教程 pdf
淘宝店铺怎样免费装修淘宝店铺怎样免费装修
录歌的软件
罗斯特里尔 知乎
java session失效时间
网络意识形态
假如不抗美援朝 知乎
苹果茶软件
ubuntu主文件夹在哪
权贵子弟的生活知乎
淘宝永久封店注销重开
淘宝账号注册流程
php use namespace
知柏地黄丸治疗性早熟
系统优化意义
scdmagsm是什么网络
php html2pdf中文乱码
上海诗悦网络
天猫国际与淘宝全球购
手机自学英语软件 知乎
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 江团鱼怎么做 江团鱼的做法大全集 团鱼的做法大全 江团鱼的家常做法 江团鱼怎么做好吃 团鱼价格 江团鱼简单做法大全集 清炖江团鱼的家常做法 江团和鲶鱼是垃圾鱼吗 红烧江团鱼 正宗江团鱼图片 团鱼的功效 蓝团 嘉峪关住宿 嘉峪关市 旅游 团鼠 团鼠真实图片 召唤之百将军团 月鼠 海囤全球自营是正品吗 囤积居奇 囤积 囤积强迫症 私人可以囤积多少黄金 末世前囤积物资在空间 家国梦相册囤积 囤积居奇是什么意思 私人可以囤积多少汽油 末日大囤积 黑暗沸腾 囤积居奇的意思 粮囤 出粮 太粮 代理不囤货 不用囤货的微商 纸尿裤囤货数量 纸尿裤囤货 微商囤货卖不掉怎么办 纸尿裤如何囤货 渠道货 大话手游新区囤货技巧 囧囧有妖

程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里