观察者模式【Observer Pattern】

Observer，观察者模式：定义对象间一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知自动更新。

 

package com.cbf4life.common;
/**
* 类似韩非子这花样的人，被监控起来了还不知道
*/
public interface IHanFeiZi {
public void haveBreakfast();
public void haveFun();
}

package com.cbf4life.common;
public class HanFeiZi implements IHanFeiZi{

private boolean isHaveBreakfast = false;

private boolean isHaveFun = false;

public void haveBreakfast(){
System.out.println("韩非子:开始吃饭了...");
this.isHaveBreakfast =true;
}

public void haveFun(){
System.out.println("韩非子:开始娱乐了...");
this.isHaveFun = true;
}

public boolean isHaveBreakfast() {
return isHaveBreakfast;
}
public void setHaveBreakfast(boolean isHaveBreakfast) {
this.isHaveBreakfast = isHaveBreakfast;
}
public boolean isHaveFun() {
return isHaveFun;
}
public void setHaveFun(boolean isHaveFun) {
this.isHaveFun = isHaveFun;
}
}

package com.cbf4life.common;
/**
* 类似于李斯的这种人，现代嘛叫做偷窥狂
*/
public interface ILiSi {
//一发现别人有动静，自己也要行动起来
public void update(String context);
}

package com.cbf4life.common;
/**
*
* 李斯这个人，是个观察者，只要韩非子一有动静，这边就知道
*/
public class LiSi implements ILiSi{
public void update(String str){
System.out.println("李斯:观察到韩非子活动，开始向老板汇报了...");
this.reportToQiShiHuang(str);
System.out.println("李斯：汇报完毕，秦老板赏给他两个萝卜吃吃...\n");
}
private void reportToQiShiHuang(String reportContext){
System.out.println("李斯：报告，秦老板！韩非子有活动了--->"+reportContext);
}
}

package com.cbf4life.common;
/**
* 监控程序
*/
class Watch extends Thread{
private HanFeiZi hanFeiZi;
private LiSi liSi;
private String type;
//通过构造函数传递参数，我要监控的是谁,谁来监控,要监控什么
public Watch(HanFeiZi _hanFeiZi,LiSi _liSi,String _type){
this.hanFeiZi =_hanFeiZi;
this.liSi = _liSi;
this.type = _type;
}
@Override
public void run(){
while(true){
if(this.type.equals("breakfast")){ //监控是否在吃早餐
//如果发现韩非子在吃饭，就通知李斯
if(this.hanFeiZi.isHaveBreakfast()){
this.liSi.update("韩非子在吃饭");
//重置状态，继续监控
this.hanFeiZi.setHaveBreakfast(false);
}
}else{
if(this.hanFeiZi.isHaveFun()){
this.liSi.update("韩非子在娱乐");
this.hanFeiZi.setHaveFun(false);
}
}
}
}
}

package com.cbf4life.common;
/**
* 这个Client就是我们，用我们的视角看待这段历史
*/
public class Client {
public static void main(String[] args) throws InterruptedException {

LiSi liSi = new LiSi();
HanFeiZi hanFeiZi = new HanFeiZi();

Watch watchBreakfast = new Watch(hanFeiZi,liSi,"breakfast");
watchBreakfast.start();
Watch watchFun = new Watch(hanFeiZi,liSi,"fun");
watchFun.start();


Thread.sleep(1000); //主线程等待1秒后后再往下执行
hanFeiZi.haveBreakfast();
Thread.sleep(1000);
hanFeiZi.haveFun();
}
}

//上面的程序，别的就不多说了，使用了一个while(true)这样一个死循环来做监听，CPU飙升，而且这个程序根本就不是面向对象的程序，这完全是面向过程的
//既然韩非子一吃饭李斯就知道了，那我们为什么不把李斯这个类聚集到韩非子这里类上呢？说
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
package com.cbf4life.advance;
public class HanFeiZi implements IHanFeiZi{
private ILiSi liSi =new LiSi();
public void haveBreakfast(){
System.out.println("韩非子:开始吃饭了...");
this.liSi.update("韩非子在吃饭");
}
public void haveFun(){
System.out.println("韩非子:开始娱乐了...");
this.liSi.update("韩非子在娱乐");
}
}
:
package com.cbf4life.advance;
/**
* 这个Client就是我们，用我们的视角看待这段历史
*/
public class Client {
public static void main(String[] args) {

HanFeiZi hanFeiZi = new HanFeiZi();
hanFeiZi.haveBreakfast();
hanFeiZi.haveFun();
}
}

--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
package com.cbf4life.advance2;
/**
* 所有被观察者者，通用接口
*/
public interface Observable {
public void addObserver(Observer observer);

public void deleteObserver(Observer observer);

public void notifyObservers(String context);
}

package com.cbf4life.advance2;
import java.util.ArrayList;
/**
* 韩非子，被观察者
*/
public class HanFeiZi implements Observable{
//定义个变长数组，存放所有的观察者
private ArrayList<Observer> observerList = new ArrayList<Observer>();

public void addObserver(Observer observer){
this.observerList.add(observer);
}

public void deleteObserver(Observer observer){
this.observerList.remove(observer);
}
//通知所有的观察者
public void notifyObservers(String context){
for(Observer observer:observerList){
observer.update(context);
}
}

public void haveBreakfast(){

System.out.println("韩非子:开始吃饭了...");
this.notifyObservers("韩非子在吃饭");
}

public void haveFun(){
System.out.println("韩非子:开始娱乐了...");
this.notifyObservers("韩非子在娱乐");
}
}

package com.cbf4life.advance2;
/**
* 所有观察者，通用接口
*/
public interface Observer {
//一发现别人有动静，自己也要行动起来
public void update(String context);
}
//然后是三个很无耻的观察者，偷窥狂嘛：
package com.cbf4life.advance2;
public class LiSi implements Observer{

public void update(String str){

System.out.println("李斯：观察到李斯活动，开始向老板汇报了...");
this.reportToQiShiHuang(str);
System.out.println("李斯：汇报完毕，秦老板赏给他两个萝卜吃吃...\n");
}

private void reportToQiShiHuang(String reportContext){
System.out.println("李斯：报告，秦老板！韩非子有活动了--->"+reportContext);
}
}
package com.cbf4life.advance2;
/**
* 王斯，也是观察者，杜撰的人名
*/
public class WangSi implements Observer{
public void update(String str){
System.out.println("王斯：观察到韩非子活动，自己也开始活动了...");
this.cry(str);
System.out.println("王斯：真真的哭死了...\n");
}
private void cry(String context){
System.out.println("王斯：因为"+context+"，——所以我悲伤呀！");
}
}
package com.cbf4life.advance2;
/**
* 刘斯这个人，是个观察者，只要韩非子一有动静，这边就知道
* 杜撰的人名
*/
public class LiuSi implements Observer{
public void update(String str){
System.out.println("刘斯：观察到韩非子活动，开始动作了...");
this.happy(str);
System.out.println("刘斯：真被乐死了\n");
}
private void happy(String context){
System.out.println("刘斯：因为" +context+",——所以我快乐呀！" );
}
}
package com.cbf4life.advance2;
/**
* 这个Client就是我们，用我们的视角看待这段历史
*/
public class Client {
public static void main(String[] args) {
//三个观察者产生出来
Observer liSi = new LiSi();
Observer wangSi = new WangSi();
Observer liuSi = new LiuSi();

HanFeiZi hanFeiZi = new HanFeiZi();

hanFeiZi.addObserver(liSi);
hanFeiZi.addObserver(wangSi);
hanFeiZi.addObserver(liuSi);

 

hanFeiZi.haveBreakfast();

}
}
----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
package com.cbf4life.perfect;
import java.util.ArrayList;
import java.util.Observable;

public class HanFeiZi extends Observable{

public void haveBreakfast(){
System.out.println("韩非子:开始吃饭了...");
super.setChanged();
super.notifyObservers("韩非子在吃饭");
}

public void haveFun(){
System.out.println("韩非子:开始娱乐了...");
super.setChanged();
this.notifyObservers("韩非子在娱乐");
}
}

package com.cbf4life.perfect;
import java.util.Observable;
import java.util.Observer;

public class LiSi implements Observer{

public void update(Observable observable,Object obj){
System.out.println("李斯：观察到李斯活动，开始向老板汇报了...");
this.reportToQiShiHuang(obj.toString());
System.out.println("李斯：汇报完毕，秦老板赏给他两个萝卜吃吃...\n");
}

private void reportToQiShiHuang(String reportContext){
System.out.println("李斯：报告，秦老板！韩非子有活动了--->"+reportContext);
}
}

package com.cbf4life.perfect;
import java.util.Observable;
import java.util.Observer;

public class WangSi implements Observer{

public void update(Observable observable,Object obj){
System.out.println("王斯：观察到韩非子活动，自己也开始活动了...");
this.cry(obj.toString());
System.out.println("王斯：真真的哭死了...\n");
}

private void cry(String context){
System.out.println("王斯：因为"+context+"，——所以我悲伤呀！");
}
}

package com.cbf4life.perfect;
import java.util.Observable;
import java.util.Observer;
public class LiuSi implements Observer{

public void update(Observable observable,Object obj){
System.out.println("刘斯：观察到韩非子活动，开始动作了...");
this.happy(obj.toString());
System.out.println("刘斯：真被乐死了\n");
}
private void happy(String context){
System.out.println("刘斯：因为" +context+",——所以我快乐呀！" );
}
}

package com.cbf4life.perfect;
import java.util.Observer;

public class Client {
public static void main(String[] args) {

Observer liSi = new LiSi();
Observer wangSi = new WangSi();
Observer liuSi = new LiuSi();

HanFeiZi hanFeiZi = new HanFeiZi();

hanFeiZi.addObserver(liSi);
hanFeiZi.addObserver(wangSi);
hanFeiZi.addObserver(liuSi);

hanFeiZi.haveBreakfast();
}
}