模式说明

当一个对象变化时，所有与他有关联关系的对象都将因为这个变化而变化，将前者称为目标对象，后者称为观察者对象。例如以人行道上的红绿灯为目标对象，行人和车辆为观察者对象。当红绿灯从红灯变为绿灯时，行人因为这个变化而从等待转变为过马路，而汽车则从通过转变为等待，这些观察者都对目标的变化做出了反映。此类场景可以用观察者模式实现。

本示例以人民币汇率为目标对象，进口公司和出口公司作为观察者对象。演示目标对象变化时，如何通知所有观察者做出其响应的动作。

结构

抽象目标类
观察者需要观察的对象，类内实现添加和删除观察者的普通方法，定义一个通知所有观察者的抽象方法。
具体目标类
继承抽象目标类，实现抽象方法。
抽象观察者类
持有一个name属性，并有对应的getter/setter。定义了一个响应目标对象变化的抽象方法action，被目标类通知时执行。
具体观察者类
继承抽象观察者类，实现抽象方法action。

代码演示

  1. package com.yukiyama.pattern.behavior;
  3. import java.util.ArrayList;
  4. import java.util.List;
  6. /**
  7.  * 观察者模式
  8.  */
  9. public class ObserverDemo {
  11.     public static void main(String[] args) {
  12.         // 声明一个具体目标对象，人民币汇率
  13.         Rate rate = new RMBRate();
  14.         // 声明两个不同的观察者对象，进口公司和出口公司
  15.         Company watcher1 = new ImportCompany();
  16.         Company watcher2 = new ExportCompany();
  17.         // 将观察者都加入到目标对象中，以便目标能够在自身产生变化时通知所有观察者
  18.         rate.add(watcher1);
  19.         rate.add(watcher2);
  20.         // 当汇率升高3.5%时，进出口公司分别对这个变化做出应对
  21.         rate.change(0.035);
  22.         // 当汇率下降6.8%时，进出口公司分别对这个变化做出应对
  23.         rate.change(-0.068);
  24.     }
  26. }
  28. /**
  29.  * 抽象目标类(被观察事物)
  30.  * 持有一个观察者类实例的集合，实现两个非抽象方法，add方法用来添加观察者
  31.  * 实例，remove方法用来删除观察者实例。另有一个抽象方法change，传入变化。
  32.  */
  33. abstract class Rate{
  34.     protected List<Company> companies = new ArrayList<>();
  36.     public void add(Company company) {
  37.         companies.add(company);
  38.     }
  39.     public void remove(Company company) {
  40.         companies.remove(company);
  41.     }
  42.     public abstract void change(double changedRate);
  43. }
  45. /**
  46.  * 具体目标类
  47.  * 继承抽象目标类，实现抽象方法change，在方法内遍历其持有的所有观察者，
  48.  * 传入变化，执行观察者的action方法。
  49.  */
  50. class RMBRate extends Rate{
  51.     @Override
  52.     public void change(double changedRate) {
  53.         System.out.printf("人民币汇率变动%.1f%%\n", changedRate*100);
  54.         for(Company company : this.companies) {
  55.             company.action(changedRate);
  56.         }
  57.     }
  58. }
  60. /**
  61.  * 抽象观察者类
  62.  * 持有一个name属性，并有对应的getter/setter。定义了一个action抽象方法。
  63.  * 下例以公司为抽象观察者类。
  64.  */
  65. abstract class Company{
  66.     private String name;
  68.     public String getName() {
  69.         return name;
  70.     }
  71.     public void setName(String name) {
  72.         this.name = name;
  73.     }
  74.     public abstract void action(double changedRate);
  75. }
  77. /**
  78.  * 具体观察者类
  79.  * 通过无参构造器初始化name。实现抽象观察者类中的抽象方法action。
  80.  * 下例是进口公司观察者，action内实现当人民币汇率降低时减少相应比例
  81.  * 的进口量，升高时增加相应比例的进口量。
  82.  */
  83. class ImportCompany extends Company{
  84.     public ImportCompany() {
  85.         this.setName("进口公司");
  86.     }
  87.     @Override
  88.     public void action(double changedRate) {
  89.         System.out.printf("%s动作：\n", this.getName());
  90.         if(changedRate < 0) {
  91.             System.out.printf("人民币汇率下降了%.1f%%，减少%.1f%%进口量。\n", 
  92.                     -changedRate*100, -changedRate*100);
  93.         } else {
  94.             System.out.printf("人民币汇率上升了%.1f%%，增加%.1f%%进口量。\n", 
  95.                     changedRate*100, changedRate*100);
  96.         }
  97.     }
  98. }
  100. /**
  101.  * 具体观察者类
  102.  * 下例是出口公司观察者，action内实现当人民币汇率降低时增加相应比例
  103.  * 的进口量，升高时减少相应比例的进口量。
  104.  */
  105. class ExportCompany extends Company{
  106.     public ExportCompany() {
  107.         this.setName("出口公司");
  108.     }
  109.     @Override
  110.     public void action(double changedRate) {
  111.         System.out.printf("%s动作：\n", this.getName());
  112.         if(changedRate < 0) {
  113.             System.out.printf("人民币汇率下降了%.1f%%，增加%.1f%%出口量。\n", 
  114.                     -changedRate*100, -changedRate*100);
  115.         } else {
  116.             System.out.printf("人民币汇率上升了%.1f%%，下降%.1f%%出口量。\n", 
  117.                     changedRate*100, changedRate*100);
  118.         }
  119.     }
  120. }