两种语言实现设计模式（C++和Java）（十七：观察者模式）

观察者（Observer）模式的定义：指多个对象间存在一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。这种模式有时又称作发布-订阅模式、模型-视图模式，它是对象行为型模式。

观察者模式是一种对象行为型模式，其主要优点如下。

1. 降低了目标与观察者之间的耦合关系，两者之间是抽象耦合关系。
2. 目标与观察者之间建立了一套触发机制。

它的主要缺点如下。

1. 目标与观察者之间的依赖关系并没有完全解除，而且有可能出现循环引用。
2. 当观察者对象很多时，通知的发布会花费很多时间，影响程序的效率。

UML:

示例：

当“人民币汇率”升值时，进口公司的进口产品成本降低且利润率提升，出口公司的出口产品收入降低且利润率降低；当“人民币汇率”贬值时，进口公司的进口产品成本提升且利润率降低，出口公司的出口产品收入提升且利润率提升。

C++实现：

#include <iostream>
#include <vector>

using namespace std;

class Company{
public:
    virtual void response(int number)=0;
};

class Rate{
protected:
    vector<Company*> companies;
public:
    void add(Company* pCompany){
        companies.push_back(pCompany);
    }

    void remove(){
        companies.pop_back();
    }

    virtual void change(int number)=0;
};

class RMBrate:public Rate{
public:
    void change(int number){
        for(Company* company:companies){
            company->response(number);
        }
    }
};

class ImportCompany:public Company{
public:
    virtual void response(int number){
        if (number > 0){
            cout << "RMB rate improved by " << number << "%, the cost of import product reduced and benefit rate of the company improved." << endl;
        } else if (number < 0){
            cout << "RMB rate decreased by " << number << "%, the cost of import product improved and benefit rate of the company decreased." << endl;
        }
    }
};

class ExportCompany:public Company{
public:
    virtual void response(int number){
        if (number > 0){
            cout << "RMB rate improved by " << number << "%, the cost of export product reduced and benefit rate of the company reduced." << endl;
        } else if (number < 0){
            cout << "RMB rate decreased by " << number << "%, the cost of export product improved and benefit rate of the company improved." << endl;
        }
    }
};

int main()
{
    Rate* rate = new RMBrate();
    Company* company1 = new ImportCompany();
    Company* company2 = new ExportCompany();
    rate->add(company1);
    rate->add(company2);
    rate->change(5);
    rate->change(-6);
    return 0;
}

 

Java实现：

import java.util.*;
public class RMBrateTest
{
    public static void main(String[] args)
    {
        Rate rate=new RMBrate();         
        Company watcher1=new ImportCompany(); 
        Company watcher2=new ExportCompany();           
        rate.add(watcher1); 
        rate.add(watcher2);           
        rate.change(10);
        rate.change(-9);
    }
}
//抽象目标：汇率
abstract class Rate
{
    protected List<Company> companys=new ArrayList<Company>();   
    //增加观察者方法
    public void add(Company company)
    {
        companys.add(company);
    }    
    //删除观察者方法
    public void remove(Company company)
    {
        companys.remove(company);
    }   
    public abstract void change(int number);
}
//具体目标：人民币汇率
class RMBrate extends Rate 
{
    public void change(int number)
    {       
        for(Company obs:companys)
        {
            ((Company)obs).response(number);
        }       
    }

}
//抽象观察者：公司
interface Company
{
    void response(int number);
}
//具体观察者1：进口公司 
class ImportCompany implements Company 
{
    public void response(int number) 
    {
        if(number>0)
        {
            System.out.println("人民币汇率升值"+number+"个基点，降低了进口产品成本，提升了进口公司利润率。"); 
        }
        else if(number<0)
        {
              System.out.println("人民币汇率贬值"+(-number)+"个基点，提升了进口产品成本，降低了进口公司利润率。"); 
        }
    } 
} 
//具体观察者2：出口公司
class ExportCompany implements Company 
{
    public void response(int number) 
    {
        if(number>0)
        {
            System.out.println("人民币汇率升值"+number+"个基点，降低了出口产品收入，降低了出口公司的销售利润率。"); 
        }
        else if(number<0)
        {
              System.out.println("人民币汇率贬值"+(-number)+"个基点，提升了出口产品收入，提升了出口公司的销售利润率。"); 
        }
    } 
}