观察者模式(设计模式_15)

观察者模式，用通俗易懂的话来理解就是，在一个对象的改变会改变其他很多的对象，而且还不知道会改变多少个其他对象的时候，就该要考虑观察者模式了

其实观察者模式在的主要工作就是解除双方的耦合度，让两端不依赖具体细节，而去依赖于抽象，所以其中一方的改变，会去更新到其他的N多方

以下就举三个例子来说明，看完三个例子后，你会发现观察者模式把（依赖倒置原则）表现出来了

案例一：（服务器更新手机）

更新全国所有的QQ，有很多手机种类 ，例如（小米，魅族，步步高，三星，等等…. 省略）

/**
* 通知主题更新的抽象类
* @author Liudeli
*
*/
public abstract class Service {

/**
* 增加我要通知者，这里存入的是抽象（抽象包括抽象类或）
* @param iPhone
*/
public abstract void add(IPhone iPhone);

/**
* 发出更新消息给各个手机
*/
public abstract void sendUpdateMsg();

}

package com.oop.demo5;

import java.util.ArrayList;
import java.util.List;

/**
* 华为服务器对象
* @author Liudeli
*
*/
public class HUAWEIService extends Service {

private List<IPhone> listPhone = new ArrayList<IPhone>();

@Override
public void add(IPhone iPhone) {
listPhone.add(iPhone);
}

@Override
public void sendUpdateMsg() {
for (IPhone iphone : listPhone) {
iphone.update();
}
}

}

package com.oop.demo5;

import java.util.ArrayList;
import java.util.List;

/**
* 戴尔服务器对象
* @author Liudeli
*
*/
public class DELLService extends Service {

private List<IPhone> listPhone = new ArrayList<IPhone>();

@Override
public void add(IPhone iPhone) {
listPhone.add(iPhone);
}

@Override
public void sendUpdateMsg() {
for (IPhone iphone : listPhone) {
iphone.update();
}
}

}

package com.oop.demo5;

/**
* 更新手机的规范
* @author Liudeli
*
*/
public interface IPhone {

/**
* 更新所有手机的行为标准规范
*/
public void update();

}

package com.oop.demo5;

/**
* 魅族手机对象
* @author Liudeli
*
*/
public class MeizuPhone implements IPhone {

public void update() {
System.out.println("魅族手机需要去更新QQ了哦...");
}

}

package com.oop.demo5;

/**
* 小米手机对象
* @author Liudeli
*
*/
public class MIPhone implements IPhone {

public void update() {
System.out.println("小米手机更新QQ了...");
}

}

package com.oop.demo5;

/**
* 三星手机对象
* @author Liudeli
*
*/
public class SamsungPhone implements IPhone {

public void update() {
System.out.println("三星手机该更新QQ啦...");
}

}

package com.oop.demo5;

/**
* 步步高手机对象
* @author Liudeli
*
*/
public class VivoPhone implements IPhone {

public void update() {
System.out.println("步步高手机需要去更新手机QQ了哦...");
}

}

/**
* 测试端程序
* @author Liudeli
*
*/
public class Main {

public static void main(String[] args) {

// 使用戴尔服务器，来更新手机QQ
Service service = new DELLService();

// 增加观察者（增加需要更新的手机对象）
service.add(new MIPhone());
service.add(new MeizuPhone());
service.add(new SamsungPhone());
service.add(new VivoPhone());

// 给手机发出通知
service.sendUpdateMsg();

System.out.println("省略...");
}

}

运行结果：



如果某天，戴尔服务器出问题了，自动切换到备用服务器 华为服务器：

// 使用华为服务器，来更新手机QQ
Service service = new HUAWEIService();

案例二：（通知同事）

package com.oop.demo3;

/**
* 定义观察者抽象类
* @author Liudeli
*
*/
public abstract class Observer {

private String name;
private ISecretary secretary;

public Observer(String name, ISecretary secretary) {
this.name = name;
this.secretary = secretary;
}

/**
* 更新
*/
public abstract void update();

}

package com.oop.demo3;

/**
* 不能依赖细节，细节应该依赖抽象，老板，和秘书，和其他秘书都是细节，抽象则是这些细节所定义的规范
* @author Liudeli
*
*/
public interface ISecretary {

/**
* 增加
* @param stockObserver
*/
public void add(Observer observer);

/**
* 通知
*/
public void notice();

/**
* 前台状态
*/

public String getAction();

public void setAction(String action);

}

package com.oop.demo3;

/**
* 定义股票观察员对象
* @author Liudeli
*
*/
public class StockObserver extends Observer{

private String name;
private ISecretary secretary;

public StockObserver(String name, ISecretary secretary) {
super(name, secretary);
this.name = name;
this.secretary = secretary;
}

@Override
public void update() {
System.out.println(secretary.getAction() + name + " 请你关闭股票行情，继续工作");
}

}

package com.oop.demo3;

/**
* 定义看NBA的同事
* @author Liudeli
*
*/
public class NBAObserver extends Observer {

private String name;
private ISecretary secretary;

public NBAObserver(String name, ISecretary secretary) {
super(name, secretary);
this.name = name;
this.secretary = secretary;
}

@Override
public void update() {
System.out.println(secretary.getAction() + name + " 请你关闭NBA视频画面，继续工作");
}

}

package com.oop.demo3;

import java.util.ArrayList;
import java.util.List;

/**
* 前台秘书类
* @author Liudeli
*
*/
public class Secretary implements ISecretary{

/**
* 定义同事集合
*/
private List<Observer> list = new ArrayList<Observer>();

/**
* 增加
* @param stockObserver
*/
public void add(Observer observer) {
list.add(observer);
}

/**
* 通知
*/
public void notice() {

for (Observer observer : list) {
observer.update();
}
}

/**
* 前台状态
*/
private String action;

public String getAction() {
return this.action;
}

public void setAction(String action) {
this.action = action;
}

}

package com.oop.demo3;

import java.util.ArrayList;
import java.util.List;

/**
* 老板对象
* @author Liudeli
*
*/
public class Boss implements ISecretary {

/**
* 定义同事集合（具体抽象）
*/
private List<Observer> list = new ArrayList<Observer>();

/**
* 增加
* @param stockObserver
*/
public void add(Observer observer) {
list.add(observer);
}

/**
* 通知
*/
public void notice() {

for (Observer observer : list) {
observer.update();
}
}

/**
* 前台状态
*/
private String action;

public String getAction() {
return this.action;
}

public void setAction(String action) {
this.action = action;
}

}

package com.oop.demo3;

/**
* 测试程序
* @author Liudeli
*
*/
public class Main {

public static void main(String[] args) {

// 前台小姐如花
ISecretary secretary = new Secretary();

// 看股票的两位同事
StockObserver stockObserver1 = new StockObserver("刘奋", secretary);
StockObserver stockObserver2 = new StockObserver("刘忙", secretary);

// 看NBA的一位同事
NBAObserver nbaObserver = new NBAObserver("黄流", secretary);

// 如花记下两位同事
secretary.add(stockObserver1);
secretary.add(stockObserver2);

// 如花记下一个看NBA的同事
secretary.add(nbaObserver);

// 发现老板回来了
secretary.setAction("老板回来了！");

// 通知通知，老板回来了
secretary.notice();
}

}

运行结果：



简化理解：

抽象通知类

/**
* 主题，抽象通知类
* @author Liudeli
*
*/
public abstract class Subject {

/**
* 增加
* @param observer
*/
public abstract void add(Observer observer);

/**
* 通知观察者
*/
public abstract void notice();

// 通知的内容
public abstract String getNoticeContext();

public abstract void setNoticeContext(String noticeContext);

}

观察者抽象类

package com.oop.demo4;

/**
* 观察者抽象类
* @author Liudeli
*
*/
public abstract class Observer {

/**
* 更新（具体观察者打印状态）
*/
public abstract void update();

}

具体通知对象：

package com.oop.demo4;

import java.util.ArrayList;
import java.util.List;

/**
* 通知的具体对象
* @author Liudeli
*
*/
public class SubjectSpecific extends Subject {

// 定义所有观察者集合
private List<Observer> list = new ArrayList<Observer>();

@Override
public void add(Observer observer) {
list.add(observer);
}

@Override
public void notice() {
for (Observer observer : list) {
observer.update();
}
}

private String noticeContext;

@Override
public String getNoticeContext() {
return noticeContext;
}

@Override
public void setNoticeContext(String noticeContext) {
this.noticeContext = noticeContext;
}

}

具体观察对象：

package com.oop.demo4;

public class ObserverSpecific extends Observer {

private Subject subject;
private String name;

public ObserverSpecific(Subject subject, String name) {
this.subject = subject;
this.name = name;
}

@Override
public void update() {
System.out.println("通知我，" + name + subject.getNoticeContext() + "好好工作...");
}

}

测试程序：

package com.oop.demo4;

public class Main {
public static void main(String[] args) {
// 得到通知者
Subject subject = new SubjectSpecific();

Observer observerA = new ObserverSpecific(subject, "旺财");
Observer observerB = new ObserverSpecific(subject, "局花");

subject.add(observerA);
subject.add(observerB);

subject.setNoticeContext("，Boss 回来了!");

subject.notice();
}
}

运行结果：



谢谢大家的观看，更多精彩技术博客，会不断的更新，请大家访问，

刘德利CSDN博客， http://blog.csdn.net/u011967006