对象间的联动——观察者模式（三）

23.3 完整解决方案

为了实现对象之间的联动，Sunny软件公司开发人员决定使用观察者模式来进行多人联机对战游戏的设计，其基本结构如图22-4所示：

对象间的联动——观察者模式（三） - 图1

图22-4 多人联机对战游戏结构图 在图22-4中，AllyControlCenter充当目标类，ConcreteAllyControlCenter充当具体目标类，Observer充当抽象观察者，Player充当具体观察者。完整代码如下所示：

  1. import java.util.*;  
  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. }  
  11. //战队成员类：具体观察者类  
  12. class Player implements Observer {  
  13.     private String name;  
  15.     public Player(String name) {  
  16.         this.name = name;  
  17.     }  
  19.     public void setName(String name) {  
  20.         this.name = name;  
  21.     }  
  23.     public String getName() {  
  24.         return this.name;  
  25.     }  
  27.     //支援盟友方法的实现  
  28.     public void help() {  
  29.         System.out.println("坚持住，" + this.name + "来救你！");  
  30.     }  
  32.     //遭受攻击方法的实现，当遭受攻击时将调用战队控制中心类的通知方法notifyObserver()来通知盟友  
  33.     public void beAttacked(AllyControlCenter acc) {  
  34.         System.out.println(this.name + "被攻击！");  
  35.         acc.notifyObserver(name);         
  36.     }  
  37. }  
  39. //战队控制中心类：目标类  
  40. abstract class AllyControlCenter {  
  41.     protected String allyName; //战队名称  
  42.     protected ArrayList<Observer> players = new ArrayList<Observer>(); //定义一个集合用于存储战队成员  
  44.     public void setAllyName(String allyName) {  
  45.         this.allyName = allyName;  
  46.     }  
  48.     public String getAllyName() {  
  49.         return this.allyName;  
  50.     }  
  52.     //注册方法  
  53.     public void join(Observer obs) {  
  54.         System.out.println(obs.getName() + "加入" + this.allyName + "战队！");  
  55.         players.add(obs);  
  56.     }  
  58.     //注销方法  
  59.     public void quit(Observer obs) {  
  60.         System.out.println(obs.getName() + "退出" + this.allyName + "战队！");  
  61.         players.remove(obs);  
  62.     }  
  64.     //声明抽象通知方法  
  65.     public abstract void notifyObserver(String name);  
  66. }  
  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.     }  
  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. }

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

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

编译并运行程序，输出结果如下：

  1. 金庸群侠战队组建成功！
  2. ----------------------------
  3. 杨过加入金庸群侠战队！
  4. 令狐冲加入金庸群侠战队！
  5. 张无忌加入金庸群侠战队！
  6. 段誉加入金庸群侠战队！
  7. 杨过被攻击！
  8. 金庸群侠战队紧急通知，盟友杨过遭受敌人攻击！
  9. 坚持住，令狐冲来救你！
  10. 坚持住，张无忌来救你！
  11. 坚持住，段誉来救你！

在本实例中，实现了两次对象之间的联动，当一个游戏玩家Player对象的beAttacked()方法被调用时，将调用AllyControlCenter的notifyObserver()方法来进行处理，而在notifyObserver()方法中又将调用其他Player对象的help()方法。Player的beAttacked()方法、AllyControlCenter的notifyObserver()方法以及Player的help()方法构成了一个联动触发链，执行顺序如下所示：

  1. Player.beAttacked() --> AllyControlCenter.notifyObserver() -->Player.help()。