訪問者模式

dengyantao發表於2024-08-20
模式
http://blog.csdn.net/chenssy/article/details/12029633
https://wizardforcel.gitbooks.io/design-pattern-lessons/content/lesson28.html
http://www.cnblogs.com/java-my-life/archive/2012/06/14/2545381.html




這個模式好難啊,似乎也沒有什麼應用的場景.

先記錄一下吧。

  1. import java.util.ArrayList;  
  2. import java.util.List;  
  3.   
  4. public class Test {  
  5.     public static void main(String[] args) {  
  6.         // 建立一個結構物件  
  7.         ObjectStructure os = new ObjectStructure();  
  8.         // 給結構增加一個節點  
  9.         os.add(new NodeA());  
  10.         // 給結構增加一個節點  
  11.         os.add(new NodeB());  
  12.         // 建立一個訪問者  
  13.         Visitor visitor = new VisitorA();  
  14.         os.action(visitor);  
  15.     }  
  16. }  
  17.   
  18. interface Visitor {  
  19.     /** 
  20.      * 對應於NodeA的訪問操作 
  21.      */  
  22.     public void visit(NodeA node);  
  23.   
  24.     /** 
  25.      * 對應於NodeB的訪問操作 
  26.      */  
  27.     public void visit(NodeB node);  
  28. }  
  29.   
  30. class VisitorA implements Visitor {  
  31.     /** 
  32.      * 對應於NodeA的訪問操作 
  33.      */  
  34.     @Override  
  35.     public void visit(NodeA node) {  
  36.         System.out.println(node.operationA());  
  37.     }  
  38.   
  39.     /** 
  40.      * 對應於NodeB的訪問操作 
  41.      */  
  42.     @Override  
  43.     public void visit(NodeB node) {  
  44.         System.out.println(node.operationB());  
  45.     }  
  46.   
  47. }  
  48.   
  49. class VisitorB implements Visitor {  
  50.     /** 
  51.      * 對應於NodeA的訪問操作 
  52.      */  
  53.     @Override  
  54.     public void visit(NodeA node) {  
  55.         System.out.println(node.operationA());  
  56.     }  
  57.   
  58.     /** 
  59.      * 對應於NodeB的訪問操作 
  60.      */  
  61.     @Override  
  62.     public void visit(NodeB node) {  
  63.         System.out.println(node.operationB());  
  64.     }  
  65.   
  66. }  
  67.   
  68. abstract class Node {  
  69.     /** 
  70.      * 接受操作 
  71.      */  
  72.     public abstract void accept(Visitor visitor);  
  73. }  
  74.   
  75. class NodeA extends Node {  
  76.     /** 
  77.      * 接受操作 
  78.      */  
  79.     @Override  
  80.     public void accept(Visitor visitor) {  
  81.         visitor.visit(this);  
  82.     }  
  83.   
  84.     /** 
  85.      * NodeA特有的方法 
  86.      */  
  87.     public String operationA() {  
  88.         return "NodeA";  
  89.     }  
  90.   
  91. }  
  92.   
  93. class NodeB extends Node {  
  94.     /** 
  95.      * 接受方法 
  96.      */  
  97.     @Override  
  98.     public void accept(Visitor visitor) {  
  99.         visitor.visit(this);  
  100.     }  
  101.   
  102.     /** 
  103.      * NodeB特有的方法 
  104.      */  
  105.     public String operationB() {  
  106.         return "NodeB";  
  107.     }  
  108. }  
  109.   
  110. class ObjectStructure {  
  111.   
  112.     private List<Node> nodes = new ArrayList<Node>();  
  113.   
  114.     /** 
  115.      * 執行方法操作 
  116.      */  
  117.     public void action(Visitor visitor) {  
  118.   
  119.         for (Node node : nodes) {  
  120.             node.accept(visitor);  
  121.         }  
  122.   
  123.     }  
  124.   
  125.     /** 
  126.      * 新增一個新元素 
  127.      */  
  128.     public void add(Node node) {  
  129.         nodes.add(node);  
  130.     }  
  131. } 




來自 “ ITPUB部落格 ” ，連結：http://blog.itpub.net/29254281/viewspace-2135993/，如需轉載，請註明出處，否則將追究法律責任。

相關文章