设计模式 学习 6：

 11个行为模式之6(备忘录模式，观察者模式，状态模式，策略模式，模版模式，访问者模式)

备忘录模式

 Sunny软件公司欲开发一款可以运行在Android平台的触摸式中国象棋软件，由于考虑到有些用户是“菜鸟”，经常不小心走错棋；还有些用户因为不习惯使用手指在手机屏幕上拖动棋子，常常出现操作失误，因此该中国象棋软件要提供“悔棋”功能，用户走错棋或操作失误后可恢复到前一个步骤，   如何实现“悔棋”功能是Sunny软件公司开发人员需要面对的一个重要问题，“悔棋”就是让系统恢复到某个历史状态，在很多软件中通常称之为“撤销

1. //象棋棋子类：原发器  
2. class Chessman {  
3.     private String label;  
4.     private int x;  
5.     private int y;  
6.   
7.     public Chessman(String label,int x,int y) {  
8.         this.label = label;  
9.         this.x = x;  
10.         this.y = y;  
11.     }  
12.   
13.     public void setLabel(String label) {  
14.         this.label = label;   
15.     }  
16.   
17.     public void setX(int x) {  
18.         this.x = x;   
19.     }  
20.   
21.     public void setY(int y) {  
22.         this.y = y;   
23.     }  
24.   
25.     public String getLabel() {  
26.         return (this.label);   
27.     }  
28.   
29.     public int getX() {  
30.         return (this.x);   
31.     }  
32.   
33.     public int getY() {  
34.         return (this.y);   
35.     }  
36.       
37.     //保存状态  
38.     public ChessmanMemento save() {  
39.         return new ChessmanMemento(this.label,this.x,this.y);  
40.     }  
41.       
42.     //恢复状态  
43.     public void restore(ChessmanMemento memento) {  
44.         this.label = memento.getLabel();  
45.         this.x = memento.getX();  
46.         this.y = memento.getY();  
47.     }  
48. }  
49.   
50. //象棋棋子备忘录类：备忘录  
51. class ChessmanMemento {  
52.     private String label;  
53.     private int x;  
54.     private int y;  
55.   
56.     public ChessmanMemento(String label,int x,int y) {  
57.         this.label = label;  
58.         this.x = x;  
59.         this.y = y;  
60.     }  
61.   
62.     public void setLabel(String label) {  
63.         this.label = label;   
64.     }  
65.   
66.     public void setX(int x) {  
67.         this.x = x;   
68.     }  
69.   
70.     public void setY(int y) {  
71.         this.y = y;   
72.     }  
73.   
74.     public String getLabel() {  
75.         return (this.label);   
76.     }  
77.   
78.     public int getX() {  
79.         return (this.x);   
80.     }  
81.   
82.     public int getY() {  
83.         return (this.y);   
84.     }     
85. }  
86.   
87. //象棋棋子备忘录管理类：负责人  
88. class MementoCaretaker {  
89.     private ChessmanMemento memento;  
90.   
91.     public ChessmanMemento getMemento() {  
92.         return memento;  
93.     }  
94.   
95.     public void setMemento(ChessmanMemento memento) {  
96.         this.memento = memento;  
97.     }  
98. }  

      编写如下客户端测试代码：

1. class Client {  
2.     public static void main(String args[]) {  
3.         MementoCaretaker mc = new MementoCaretaker();  
4.         Chessman chess = new Chessman("车",1,1);  
5.         display(chess);  
6.         mc.setMemento(chess.save()); //保存状态       
7.         chess.setY(4);  
8.         display(chess);  
9.         mc.setMemento(chess.save()); //保存状态  
10.         display(chess);  
11.         chess.setX(5);  
12.         display(chess);  
13.         System.out.println("******悔棋******");     
14.         chess.restore(mc.getMemento()); //恢复状态  
15.         display(chess);  
16.     }  
17.       
18.     public static void display(Chessman chess) {  
19.         System.out.println("棋子" + chess.getLabel() + "当前位置为：" + "第" + chess.getX() + "行" + "第" + chess.getY() + "列。");  
20.     }  
21. }  

多次撤销？

1. import java.util.*;  
2.   
3. class MementoCaretaker {  
4.     //定义一个集合来存储多个备忘录  
5.     private ArrayList mementolist = new ArrayList();  
6.   
7.     public ChessmanMemento getMemento(int i) {  
8.         return (ChessmanMemento)mementolist.get(i);  
9.     }  
10.   
11.     public void setMemento(ChessmanMemento memento) {  
12.         mementolist.add(memento);  
13.     }  
14. }  

      编写如下客户端测试代码：

1. class Client {  
2. private static int index = -1; //定义一个索引来记录当前状态所在位置  
3.     private static MementoCaretaker mc = new MementoCaretaker();  
4.   
5.     public static void main(String args[]) {  
6.         Chessman chess = new Chessman("车",1,1);  
7.         play(chess);          
8.         chess.setY(4);  
9.         play(chess);  
10.         chess.setX(5);  
11.         play(chess);      
12.         undo(chess,index);  
13.         undo(chess,index);    
14.         redo(chess,index);  
15.         redo(chess,index);  
16.     }  
17.       
18.     //下棋  
19.     public static void play(Chessman chess) {  
20.         mc.setMemento(chess.save()); //保存备忘录  
21.         index ++;   
22.         System.out.println("棋子" + chess.getLabel() + "当前位置为：" + "第" + chess.getX() + "行" + "第" + chess.getY() + "列。");  
23.     }  
24.   
25.     //悔棋  
26.     public static void undo(Chessman chess,int i) {  
27.         System.out.println("******悔棋******");  
28.         index --;   
29.         chess.restore(mc.getMemento(i-1)); //撤销到上一个备忘录  
30.         System.out.println("棋子" + chess.getLabel() + "当前位置为：" + "第" + chess.getX() + "行" + "第" + chess.getY() + "列。");  
31.     }  
32.   
33.     //撤销悔棋  
34.     public static void redo(Chessman chess,int i) {  
35.         System.out.println("******撤销悔棋******");   
36.         index ++;   
37.         chess.restore(mc.getMemento(i+1)); //恢复到下一个备忘录  
38.         System.out.println("棋子" + chess.getLabel() + "当前位置为：" + "第" + chess.getX() + "行" + "第" + chess.getY() + "列。");  
39.     }  
40. }   

观察者模式

   Sunny软件公司欲开发一款多人联机对战游戏（类似魔兽世界、星际争霸等游戏），在该游戏中，多个玩家可以加入同一战队组成联盟，当战队中某一成员受到敌人攻击时将给所有其他盟友发送通知，盟友收到通知后将作出响应。

      Sunny软件公司开发人员需要提供一个设计方案来实现战队成员之间的联动。

1. import java.util.*;  
2.   
3. //抽象观察类  
4. interface Observer {  
5.     public String getName();  
6.     public void setName(String name);  
7.     public void help(); //声明支援盟友方法  
8.     public void beAttacked(AllyControlCenter acc); //声明遭受攻击方法  
9. }  
10.   
11. //战队成员类：具体观察者类  
12. class Player implements Observer {  
13.     private String name;  
14.   
15.     public Player(String name) {  
16.         this.name = name;  
17.     }  
18.       
19.     public void setName(String name) {  
20.         this.name = name;  
21.     }  
22.       
23.     public String getName() {  
24.         return this.name;  
25.     }  
26.       
27.     //支援盟友方法的实现  
28.     public void help() {  
29.         System.out.println("坚持住，" + this.name + "来救你！");  
30.     }  
31.       
32.     //遭受攻击方法的实现，当遭受攻击时将调用战队控制中心类的通知方法notifyObserver()来通知盟友  
33.     public void beAttacked(AllyControlCenter acc) {  
34.         System.out.println(this.name + "被攻击！");  
35.         acc.notifyObserver(name);         
36.     }  
37. }  
38.   
39. //战队控制中心类：目标类  
40. abstract class AllyControlCenter {  
41.     protected String allyName; //战队名称  
42.     protected ArrayList<Observer> players = new ArrayList<Observer>(); //定义一个集合用于存储战队成员  
43.       
44.     public void setAllyName(String allyName) {  
45.         this.allyName = allyName;  
46.     }  
47.       
48.     public String getAllyName() {  
49.         return this.allyName;  
50.     }  
51.       
52.     //注册方法  
53.     public void join(Observer obs) {  
54.         System.out.println(obs.getName() + "加入" + this.allyName + "战队！");  
55.         players.add(obs);  
56.     }  
57.       
58.     //注销方法  
59.     public void quit(Observer obs) {  
60.         System.out.println(obs.getName() + "退出" + this.allyName + "战队！");  
61.         players.remove(obs);  
62.     }  
63.       
64.     //声明抽象通知方法  
65.     public abstract void notifyObserver(String name);  
66. }  
67.   
68. //具体战队控制中心类：具体目标类  
69. class ConcreteAllyControlCenter extends AllyControlCenter {  
70.     public ConcreteAllyControlCenter(String allyName) {  
71.         System.out.println(allyName + "战队组建成功！");  
72.         System.out.println("----------------------------");  
73.         this.allyName = allyName;  
74.     }  
75.       
76.     //实现通知方法  
77.     public void notifyObserver(String name) {  
78.         System.out.println(this.allyName + "战队紧急通知，盟友" + name + "遭受敌人攻击！");  
79.         //遍历观察者集合，调用每一个盟友（自己除外）的支援方法  
80.         for(Object obs : players) {  
81.             if (!((Observer)obs).getName().equalsIgnoreCase(name)) {  
82.                 ((Observer)obs).help();  
83.             }  
84.         }         
85.     }  
86. }  

      编写如下客户端测试代码：

[java] view plain copy

1. class Client {  
2.     public static void main(String args[]) {  
3.         //定义观察目标对象  
4. AllyControlCenter acc;  
5.         acc = new ConcreteAllyControlCenter("金庸群侠");  
6.           
7.         //定义四个观察者对象  
8.         Observer player1,player2,player3,player4;  
9.           
10.         player1 = new Player("杨过");  
11.         acc.join(player1);  
12.           
13.         player2 = new Player("令狐冲");  
14.         acc.join(player2);  
15.           
16.         player3 = new Player("张无忌");  
17.         acc.join(player3);  
18.           
19.         player4 = new Player("段誉");  
20.         acc.join(player4);  
21.           
22.         //某成员遭受攻击  
23.         Player1.beAttacked(acc);  
24.     }  
25. }  

状态模式

   Sunny软件公司欲为某银行开发一套信用卡业务系统，银行账户(Account)是该系统的核心类之一，通过分析，Sunny软件公司开发人员发现在该系统中，账户存在三种状态，且在不同状态下账户存在不同的行为，具体说明如下：

       (1) 如果账户中余额大于等于0，则账户的状态为正常状态(Normal State)，此时用户既可以向该账户存款也可以从该账户取款；

       (2) 如果账户中余额小于0，并且大于-2000，则账户的状态为透支状态(Overdraft State)，此时用户既可以向该账户存款也可以从该账户取款，但需要按天计算利息；

       (3) 如果账户中余额等于-2000，那么账户的状态为受限状态(Restricted State)，此时用户只能向该账户存款，不能再从中取款，同时也将按天计算利息；

       (4) 根据余额的不同，以上三种状态可发生相互转换。

实现代码：

[java] view plain copy

1. class Account {  
2.     private String state; //状态  
3.     private int balance; //余额  
4.     ......  
5.       
6.     //存款操作    
7.     public void deposit() {  
8.         //存款  
9.         stateCheck();     
10.     }  
11.       
12.     //取款操作  
13.     public void withdraw() {  
14.         if (state.equalsIgnoreCase("NormalState") || state.equalsIgnoreCase("OverdraftState ")) {  
15.             //取款  
16.             stateCheck();  
17.         }  
18.         else {  
19.             //取款受限  
20.         }  
21.     }  
22.       
23.     //计算利息操作  
24.     public void computeInterest() {  
25.         if(state.equalsIgnoreCase("OverdraftState") || state.equalsIgnoreCase("RestrictedState ")) {  
26.             //计算利息  
27.         }  
28.     }  
29.       
30.     //状态检查和转换操作  
31.     public void stateCheck() {  
32.         if (balance >= 0) {  
33.             state = "NormalState";  
34.         }  
35.         else if (balance > -2000 && balance < 0) {  
36.             state = "OverdraftState";  
37.         }  
38.         else if (balance == -2000) {  
39.             state = "RestrictedState";  
40.         }  
41.         else if (balance < -2000) {  
42.             //操作受限  
43.         }  
44.     }  
45.     ......  
46. }  

       分析上述代码，我们不难发现存在如下几个问题：

       (1) 几乎每个方法中都包含状态判断语句，以判断在该状态下是否具有该方法以及在特定状态下该方法如何实现，导致代码非常冗长，可维护性较差；

       (2) 拥有一个较为复杂的stateCheck()方法，包含大量的if…else if…else…语句用于进行状态转换，代码测试难度较大，且不易于维护；

       (3) 系统扩展性较差，如果需要增加一种新的状态，如冻结状态（Frozen State，在该状态下既不允许存款也不允许取款），需要对原有代码进行大量修改，扩展起来非常麻烦。

       为了解决这些问题，我们可以使用状态模式，在状态模式中，我们将对象在每一个状态下的行为和状态转移语句封装在一个个状态类中，通过这些状态类来分散冗长的条件转移语句，让系统具有更好的灵活性和可扩展性，状态模式可以在一定程度上解决上述问题。

1. //银行账户：环境类  
2. class Account {  
3.     private AccountState state; //维持一个对抽象状态对象的引用  
4.     private String owner; //开户名  
5.     private double balance = 0; //账户余额  
6.       
7.     public Account(String owner,double init) {  
8.         this.owner = owner;  
9.         this.balance = balance;  
10.         this.state = new NormalState(this); //设置初始状态  
11.         System.out.println(this.owner + "开户，初始金额为" + init);   
12.         System.out.println("---------------------------------------------");      
13.     }  
14.       
15.     public double getBalance() {  
16.         return this.balance;  
17.     }  
18.       
19.     public void setBalance(double balance) {  
20.         this.balance = balance;  
21.     }  
22.       
23.     public void setState(AccountState state) {  
24.         this.state = state;  
25.     }  
26.       
27.     public void deposit(double amount) {  
28.         System.out.println(this.owner + "存款" + amount);  
29.         state.deposit(amount); //调用状态对象的deposit()方法  
30.         System.out.println("现在余额为"+ this.balance);  
31.         System.out.println("现在帐户状态为"+ this.state.getClass().getName());  
32.         System.out.println("---------------------------------------------");              
33.     }  
34.       
35.     public void withdraw(double amount) {  
36.         System.out.println(this.owner + "取款" + amount);  
37.         state.withdraw(amount); //调用状态对象的withdraw()方法  
38.         System.out.println("现在余额为"+ this.balance);  
39.         System.out.println("现在帐户状态为"+ this. state.getClass().getName());          
40.         System.out.println("---------------------------------------------");  
41.     }  
42.       
43.     public void computeInterest()  
44.     {  
45.         state.computeInterest(); //调用状态对象的computeInterest()方法  
46.     }  
47. }  
48.   
49. //抽象状态类  
50. abstract class AccountState {  
51.     protected Account acc;  
52.     public abstract void deposit(double amount);  
53.     public abstract void withdraw(double amount);  
54.     public abstract void computeInterest();  
55.     public abstract void stateCheck();  
56. }  
57.   
58. //正常状态：具体状态类  
59. class NormalState extends AccountState {  
60.     public NormalState(Account acc) {  
61.         this.acc = acc;  
62.     }  
63.   
64. public NormalState(AccountState state) {  
65.         this.acc = state.acc;  
66.     }  
67.           
68.     public void deposit(double amount) {  
69.         acc.setBalance(acc.getBalance() + amount);  
70.         stateCheck();  
71.     }  
72.       
73.     public void withdraw(double amount) {  
74.         acc.setBalance(acc.getBalance() - amount);  
75.         stateCheck();  
76.     }  
77.       
78.     public void computeInterest()  
79.     {  
80.         System.out.println("正常状态，无须支付利息！");  
81.     }  
82.       
83.     //状态转换  
84.     public void stateCheck() {  
85.         if (acc.getBalance() > -2000 && acc.getBalance() <= 0) {  
86.             acc.setState(new OverdraftState(this));  
87.         }  
88.         else if (acc.getBalance() == -2000) {  
89.             acc.setState(new RestrictedState(this));  
90.         }  
91.         else if (acc.getBalance() < -2000) {  
92.             System.out.println("操作受限！");  
93.         }     
94.     }     
95. }    
96.   
97. //透支状态：具体状态类  
98. class OverdraftState extends AccountState  
99. {  
100.     public OverdraftState(AccountState state) {  
101.         this.acc = state.acc;  
102.     }  
103.       
104.     public void deposit(double amount) {  
105.         acc.setBalance(acc.getBalance() + amount);  
106.         stateCheck();  
107.     }  
108.       
109.     public void withdraw(double amount) {  
110.         acc.setBalance(acc.getBalance() - amount);  
111.         stateCheck();  
112.     }  
113.       
114.     public void computeInterest() {  
115.         System.out.println("计算利息！");  
116.     }  
117.       
118.     //状态转换  
119.     public void stateCheck() {  
120.         if (acc.getBalance() > 0) {  
121.             acc.setState(new NormalState(this));  
122.         }  
123.         else if (acc.getBalance() == -2000) {  
124.             acc.setState(new RestrictedState(this));  
125.         }  
126.         else if (acc.getBalance() < -2000) {  
127.             System.out.println("操作受限！");  
128.         }  
129.     }  
130. }  
131.   
132. //受限状态：具体状态类  
133. class RestrictedState extends AccountState {  
134.     public RestrictedState(AccountState state) {  
135.         this.acc = state.acc;  
136.     }  
137.       
138.     public void deposit(double amount) {  
139.         acc.setBalance(acc.getBalance() + amount);  
140.         stateCheck();  
141.     }  
142.       
143.     public void withdraw(double amount) {  
144.         System.out.println("帐号受限，取款失败");  
145.     }  
146.       
147.     public void computeInterest() {  
148.         System.out.println("计算利息！");  
149.     }  
150.       
151.     //状态转换  
152.     public void stateCheck() {  
153.         if(acc.getBalance() > 0) {  
154.             acc.setState(new NormalState(this));  
155.         }  
156.         else if(acc.getBalance() > -2000) {  
157.             acc.setState(new OverdraftState(this));  
158.         }  
159.     }  
160. }  

       编写如下客户端测试代码：

1. class Client {  
2.     public static void main(String args[]) {  
3.         Account acc = new Account("段誉",0.0);  
4.         acc.deposit(1000);  
5.         acc.withdraw(2000);  
6.         acc.deposit(3000);  
7.         acc.withdraw(4000);  
8.         acc.withdraw(1000);  
9.         acc.computeInterest();  
10.     }  
11. }  

策略模式

Sunny软件公司为某电影院开发了一套影院售票系统，在该系统中需要为不同类型的用户提供不同的电影票打折方式，具体打折方案如下：

      (1) 学生凭学生证可享受票价8折优惠；

      (2) 年龄在10周岁及以下的儿童可享受每张票减免10元的优惠（原始票价需大于等于20元）；

      (3) 影院VIP用户除享受票价半价优惠外还可进行积分，积分累计到一定额度可换取电影院赠送的奖品。

      该系统在将来可能还要根据需要引入新的打折方式。

一般实现：

1. //电影票类  
2. class MovieTicket {  
3.     private double price; //电影票价格  
4.     private String type; //电影票类型  
5.       
6.     public void setPrice(double price) {  
7.         this.price = price;  
8.     }  
9.       
10.     public void setType(String type) {  
11.         this.type = type;  
12.     }  
13.       
14.     public double getPrice() {  
15.         return this.calculate();  
16.     }  
17.       
18.          //计算打折之后的票价  
19.     public double calculate() {  
20.                   //学生票折后票价计算  
21.         if(this.type.equalsIgnoreCase("student")) {  
22.             System.out.println("学生票：");  
23.             return this.price * 0.8;  
24.         }  
25.                   //儿童票折后票价计算  
26.         else if(this.type.equalsIgnoreCase("children") && this.price >= 20 ) {  
27.             System.out.println("儿童票：");  
28.             return this.price - 10;  
29.         }  
30.                   //VIP票折后票价计算  
31.         else if(this.type.equalsIgnoreCase("vip")) {  
32.             System.out.println("VIP票：");  
33.             System.out.println("增加积分！");  
34.             return this.price * 0.5;  
35.         }  
36.         else {  
37.             return this.price; //如果不满足任何打折要求，则返回原始票价  
38.         }  
39.     }  
40. }  

      编写如下客户端测试代码：

1. class Client {  
2.     public static void main(String args[]) {  
3.         MovieTicket mt = new MovieTicket();  
4.         double originalPrice = 60.0; //原始票价  
5.         double currentPrice; //折后价  
6.           
7.         mt.setPrice(originalPrice);  
8.         System.out.println("原始价为：" + originalPrice);  
9.         System.out.println("---------------------------------");  
10.               
11.         mt.setType("student"); //学生票  
12.         currentPrice = mt.getPrice();  
13.         System.out.println("折后价为：" + currentPrice);  
14.         System.out.println("---------------------------------");  
15.           
16.         mt.setType("children"); //儿童票  
17.         currentPrice = mt.getPrice();  
18.         System.out.println("折后价为：" + currentPrice);  
19.     }  
20. }  

1. //电影票类：环境类  
2. class MovieTicket {  
3.     private double price;  
4.     private Discount discount; //维持一个对抽象折扣类的引用  
5.   
6.     public void setPrice(double price) {  
7.         this.price = price;  
8.     }  
9.   
10.     //注入一个折扣类对象  
11.     public void setDiscount(Discount discount) {  
12.         this.discount = discount;  
13.     }  
14.   
15.     public double getPrice() {  
16.         //调用折扣类的折扣价计算方法  
17.         return discount.calculate(this.price);  
18.     }  
19. }  
20.   
21. //折扣类：抽象策略类  
22. interface Discount {  
23.     public double calculate(double price);  
24. }  
25.   
26. //学生票折扣类：具体策略类  
27. class StudentDiscount implements Discount {  
28.     public double calculate(double price) {  
29.         System.out.println("学生票：");  
30.         return price * 0.8;  
31.     }  
32. }   
33.   
34. //儿童票折扣类：具体策略类  
35. class ChildrenDiscount implements Discount {  
36.     public double calculate(double price) {  
37.         System.out.println("儿童票：");  
38.         return price - 10;  
39.     }  
40. }   
41.   
42. //VIP会员票折扣类：具体策略类  
43. class VIPDiscount implements Discount {  
44.     public double calculate(double price) {  
45.         System.out.println("VIP票：");  
46.         System.out.println("增加积分！");  
47.         return price * 0.5;  
48.     }  
49. }  

1. import javax.xml.parsers.*;  
2. import org.w3c.dom.*;  
3. import org.xml.sax.SAXException;  
4. import java.io.*;  
5. class XMLUtil {  
6. //该方法用于从XML配置文件中提取具体类类名，并返回一个实例对象  
7.     public static Object getBean() {  
8.         try {  
9.             //创建文档对象  
10.             DocumentBuilderFactory dFactory = DocumentBuilderFactory.newInstance();  
11.             DocumentBuilder builder = dFactory.newDocumentBuilder();  
12.             Document doc;                             
13.             doc = builder.parse(new File("config.xml"));   
14.           
15.             //获取包含类名的文本节点  
16.             NodeList nl = doc.getElementsByTagName("className");  
17.             Node classNode=nl.item(0).getFirstChild();  
18.             String cName=classNode.getNodeValue();  
19.               
20.             //通过类名生成实例对象并将其返回  
21.             Class c=Class.forName(cName);  
22.             Object obj=c.newInstance();  
23.             return obj;  
24.         }     
25.         catch(Exception e) {  
26.             e.printStackTrace();  
27.             return null;  
28.         }  
29.     }  
30. }  

      在配置文件config.xml中存储了具体策略类的类名，代码如下所示：

[html] view plain copy

1. <?xml version="1.0"?>  
2. <config>  
3.     <className>StudentDiscount</className>  
4. </config>  

      编写如下客户端测试代码：

1. class Client {  
2.     public static void main(String args[]) {  
3.         MovieTicket mt = new MovieTicket();  
4.         double originalPrice = 60.0;  
5.         double currentPrice;  
6.           
7.         mt.setPrice(originalPrice);  
8.         System.out.println("原始价为：" + originalPrice);  
9.         System.out.println("---------------------------------");  
10.               
11.         Discount discount;  
12.         discount = (Discount)XMLUtil.getBean(); //读取配置文件并反射生成具体折扣对象  
13.         mt.setDiscount(discount); //注入折扣对象  
14.           
15.         currentPrice = mt.getPrice();  
16.         System.out.println("折后价为：" + currentPrice);  
17.     }  
18. }  

模板方法模式

   在现实生活中，很多事情都包含几个实现步骤，例如请客吃饭，无论吃什么，一般都包含点单、吃东西、买单等几个步骤，通常情况下这几个步骤的次序是：点单 --> 吃东西 --> 买单。在这三个步骤中，点单和买单大同小异，最大的区别在于第二步——吃什么？吃面条和吃满汉全席可大不相同，在软件开发中，有时也会遇到类似的情况，某个方法的实现需要多个步骤（类似“请客”），其中有些步骤是固定的（类似“点单”和“买单”），而有些步骤并不固定，存在可变性（类似“吃东西”），为了提高代码的复用性和系统的灵活性，可以使用一种称之为模板方法模式的设计模式来对这类情况进行设计

访问者模式

 Sunny软件公司欲为某银行开发一套OA系统，在该OA系统中包含一个员工信息管理子系统，该银行员工包括正式员工和临时工，每周人力资源部和财务部等部门需要对员工数据进行汇总，汇总数据包括员工工作时间、员工工资等。该公司基本制度如下：

       (1) 正式员工(Full time  Employee)每周工作时间为40小时，不同级别、不同部门的员工每周基本工资不同；如果超过40小时，超出部分按照100元/小时作为加班费；如果少于40小时，所缺时间按照请假处理，请假所扣工资以80元/小时计算，直到基本工资扣除到零为止。除了记录实际工作时间外，人力资源部需记录加班时长或请假时长，作为员工平时表现的一项依据。

       (2) 临时工(Part time  Employee)每周工作时间不固定，基本工资按小时计算，不同岗位的临时工小时工资不同。人力资源部只需记录实际工作时间。

       人力资源部和财务部工作人员可以根据各自的需要对员工数据进行汇总处理，人力资源部负责汇总每周员工工作时间，而财务部负责计算每周员工工资。

1. import java.util.*;  
2.   
3. class EmployeeList  
4. {  
5.     private ArrayList<Employee> list = new ArrayList<Employee>(); //员工集合  
6.   
7.     //增加员工  
8.     public void addEmployee(Employee employee)   
9.     {  
10.         list.add(employee);  
11.     }  
12.       
13.     //处理员工数据  
14.     public void handle(String departmentName)  
15.     {  
16.         if(departmentName.equalsIgnoreCase("财务部")) //财务部处理员工数据  
17.         {  
18.             for(Object obj : list)  
19.             {  
20.                 if(obj.getClass().getName().equalsIgnoreCase("FulltimeEmployee"))  
21.                 {  
22.                     System.out.println("财务部处理全职员工数据！");           
23.                 }  
24.                 else   
25.                 {  
26.                     System.out.println("财务部处理兼职员工数据！");  
27.                 }  
28.             }  
29.         }  
30.         else if(departmentName.equalsIgnoreCase("人力资源部")) //人力资源部处理员工数据  
31.         {  
32.             for(Object obj : list)  
33.             {  
34.                 if(obj.getClass().getName().equalsIgnoreCase("FulltimeEmployee"))  
35.                 {  
36.                     System.out.println("人力资源部处理全职员工数据！");                     
37.                 }  
38.                 else   
39.                 {  
40.                     System.out.println("人力资源部处理兼职员工数据！");  
41.                 }  
42.             }             
43.         }  
44.     }  
45. }  

1. import java.util.*;  
2.   
3. //员工类：抽象元素类  
4. interface Employee  
5. {  
6.     public void accept(Department handler); //接受一个抽象访问者访问  
7. }  
8.   
9. //全职员工类：具体元素类  
10. class FulltimeEmployee implements Employee  
11. {  
12.     private String name;  
13.     private double weeklyWage;  
14.     private int workTime;  
15.   
16.     public FulltimeEmployee(String name,double weeklyWage,int workTime)  
17.     {  
18.         this.name = name;  
19.         this.weeklyWage = weeklyWage;  
20.         this.workTime = workTime;  
21.     }     
22.   
23.     public void setName(String name)   
24.     {  
25.         this.name = name;   
26.     }  
27.   
28.     public void setWeeklyWage(double weeklyWage)   
29.     {  
30.         this.weeklyWage = weeklyWage;   
31.     }  
32.   
33.     public void setWorkTime(int workTime)   
34.     {  
35.         this.workTime = workTime;   
36.     }  
37.   
38.     public String getName()   
39.     {  
40.         return (this.name);   
41.     }  
42.   
43.     public double getWeeklyWage()   
44.     {  
45.         return (this.weeklyWage);   
46.     }  
47.   
48.     public int getWorkTime()   
49.     {  
50.         return (this.workTime);   
51.     }  
52.   
53.     public void accept(Department handler)  
54.     {  
55.         handler.visit(this); //调用访问者的访问方法  
56.     }  
57. }  
58.   
59. //兼职员工类：具体元素类  
60. class ParttimeEmployee implements Employee  
61. {  
62.     private String name;  
63.     private double hourWage;  
64.     private int workTime;  
65.   
66.     public ParttimeEmployee(String name,double hourWage,int workTime)  
67.     {  
68.         this.name = name;  
69.         this.hourWage = hourWage;  
70.         this.workTime = workTime;  
71.     }     
72.   
73.     public void setName(String name)   
74.     {  
75.         this.name = name;   
76.     }  
77.   
78.     public void setHourWage(double hourWage)   
79.     {  
80.         this.hourWage = hourWage;   
81.     }  
82.   
83.     public void setWorkTime(int workTime)   
84.     {  
85.         this.workTime = workTime;   
86.     }  
87.   
88.     public String getName()   
89.     {  
90.         return (this.name);   
91.     }  
92.   
93.     public double getHourWage()   
94.     {  
95.         return (this.hourWage);   
96.     }  
97.   
98.     public int getWorkTime()   
99.     {  
100.         return (this.workTime);   
101.     }  
102.   
103.     public void accept(Department handler)  
104.     {  
105.         handler.visit(this); //调用访问者的访问方法  
106.     }  
107. }  
108.   
109. //部门类：抽象访问者类  
110. abstract class Department  
111. {  
112.     //声明一组重载的访问方法，用于访问不同类型的具体元素  
113.     public abstract void visit(FulltimeEmployee employee);  
114.     public abstract void visit(ParttimeEmployee employee);    
115. }  
116.   
117. //财务部类：具体访问者类  
118. class FADepartment extends Department  
119. {  
120.     //实现财务部对全职员工的访问  
121.     public void visit(FulltimeEmployee employee)  
122.     {  
123.         int workTime = employee.getWorkTime();  
124.         double weekWage = employee.getWeeklyWage();  
125.         if(workTime > 40)  
126.         {  
127.             weekWage = weekWage + (workTime - 40) * 100;  
128.         }  
129.         else if(workTime < 40)  
130.         {  
131.             weekWage = weekWage - (40 - workTime) * 80;  
132.             if(weekWage < 0)  
133.             {  
134.                 weekWage = 0;  
135.             }  
136.         }  
137.         System.out.println("正式员工" + employee.getName() + "实际工资为：" + weekWage + "元。");             
138.     }  
139.   
140.     //实现财务部对兼职员工的访问  
141.     public void visit(ParttimeEmployee employee)  
142.     {  
143.         int workTime = employee.getWorkTime();  
144.         double hourWage = employee.getHourWage();  
145.         System.out.println("临时工" + employee.getName() + "实际工资为：" + workTime * hourWage + "元。");       
146.     }         
147. }  
148.   
149. //人力资源部类：具体访问者类  
150. class HRDepartment extends Department  
151. {  
152.     //实现人力资源部对全职员工的访问  
153.     public void visit(FulltimeEmployee employee)  
154.     {  
155.         int workTime = employee.getWorkTime();  
156.         System.out.println("正式员工" + employee.getName() + "实际工作时间为：" + workTime + "小时。");  
157.         if(workTime > 40)  
158.         {  
159.             System.out.println("正式员工" + employee.getName() + "加班时间为：" + (workTime - 40) + "小时。");  
160.         }  
161.         else if(workTime < 40)  
162.         {  
163.             System.out.println("正式员工" + employee.getName() + "请假时间为：" + (40 - workTime) + "小时。");  
164.         }                         
165.     }  
166.   
167.     //实现人力资源部对兼职员工的访问  
168.     public void visit(ParttimeEmployee employee)  
169.     {  
170.         int workTime = employee.getWorkTime();  
171.         System.out.println("临时工" + employee.getName() + "实际工作时间为：" + workTime + "小时。");  
172.     }         
173. }  
174.   
175. //员工列表类：对象结构  
176. class EmployeeList  
177. {  
178.     //定义一个集合用于存储员工对象  
179.     private ArrayList<Employee> list = new ArrayList<Employee>();  
180.   
181.     public void addEmployee(Employee employee)  
182.     {  
183.         list.add(employee);  
184.     }  
185.   
186.     //遍历访问员工集合中的每一个员工对象  
187.     public void accept(Department handler)  
188.     {  
189.         for(Object obj : list)  
190.         {  
191.             ((Employee)obj).accept(handler);  
192.         }  
193.     }  
194. }  

      为了提高系统的灵活性和可扩展性，我们将具体访问者类的类名存储在配置文件中，并通过工具类XMLUtil来读取配置文件并反射生成对象，XMLUtil类的代码如下所示：

[java] view plain copy

1. import javax.xml.parsers.*;  
2. import org.w3c.dom.*;  
3. import org.xml.sax.SAXException;  
4. import java.io.*;  
5. class XMLUtil  
6. {  
7.     //该方法用于从XML配置文件中提取具体类类名，并返回一个实例对象  
8.     public static Object getBean()  
9.     {  
10.         try  
11.         {  
12.             //创建文档对象  
13.             DocumentBuilderFactory dFactory = DocumentBuilderFactory.newInstance();  
14.             DocumentBuilder builder = dFactory.newDocumentBuilder();  
15.             Document doc;                             
16.             doc = builder.parse(new File("config.xml"));   
17.           
18.             //获取包含类名的文本节点  
19.             NodeList nl = doc.getElementsByTagName("className");  
20.             Node classNode=nl.item(0).getFirstChild();  
21.             String cName=classNode.getNodeValue();  
22.               
23.             //通过类名生成实例对象并将其返回  
24.             Class c=Class.forName(cName);  
25.             Object obj=c.newInstance();  
26.             return obj;  
27.         }     
28.         catch(Exception e)  
29.         {  
30.             e.printStackTrace();  
31.             return null;  
32.         }  
33.     }  
34. }  

       配置文件config.xml中存储了具体访问者类的类名，代码如下所示：

[html] view plain copy

1. <?xml version="1.0"?>  
2. <config>  
3.     <className>FADepartment</className>  
4. </config>  

     编写如下客户端测试代码：

[java] view plain copy

1. class Client  
2. {  
3.     public static void main(String args[])  
4.     {  
5.         EmployeeList list = new EmployeeList();  
6.         Employee fte1,fte2,fte3,pte1,pte2;  
7.   
8.         fte1 = new FulltimeEmployee("张无忌",3200.00,45);  
9.         fte2 = new FulltimeEmployee("杨过",2000.00,40);  
10.         fte3 = new FulltimeEmployee("段誉",2400.00,38);  
11.         pte1 = new ParttimeEmployee("洪七公",80.00,20);  
12.         pte2 = new ParttimeEmployee("郭靖",60.00,18);  
13.   
14.         list.addEmployee(fte1);  
15.         list.addEmployee(fte2);  
16.         list.addEmployee(fte3);  
17.         list.addEmployee(pte1);  
18.         list.addEmployee(pte2);  
19.   
20.         Department dep;  
21.         dep = (Department)XMLUtil.getBean();  
22.         list.accept(dep);  
23.     }  
24. }