java的观察者模式

Java里面的观察者模式，是一个很是经典的模式，常常在开发中被用到，掌握了这个思想，我相信对于一些开发，受益是匪浅的；鄙人也是以为比较不错，因此发表一点本身的总结，若是对还处于迷茫的你有稍微的帮助的话，鄙人很高兴；下面就让咱们共同的理解一下：

1、需求：

  在开发的过程当中咱们会遇到比较实际额问题就是好比一个事物某种状态发生了改变，想让其余关心它的事物知道，而不是，其余的事物一直看着它，那么就能够抽出一个基本的思想，就是让关心的事物订阅被关心的事物，而后被关心的事物一旦有了改变就去通知关心的事物，以下图：

咱们能够清楚的看出被观察者要作的事情，就是添加观察者、删除观察者以及状态更新以后要通知观察者作相应的操做，而观察者，就是获得数据；到此的话，彷佛有点眉目了；

2、设计：

知道了思路了，就是须要把思路设计出来；接下来，咱们就本身化抽象为具体，化腐朽为神奇：

1. 被观察者（成为目标对象）：Subject

2. 观察者：（监督者）:Observer

Subject类的实现：

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

/**
 *建立人：UncleMin
 *时间：2017/3/11 0011-下午 6:58
 *描述：Subject:目标对象；注册与通知观察者
 *连接：http://blog.csdn.net/wz1993_0719/article/details/60783657
 */
public class Subject{
    private List<Observer> observers = new ArrayList<>();
    public void addObserver(Observer observer){
    //添加观察者的方法：
        observers.add(observer);
    }
    public void removeObserver(Observer observer){
    //删除观察者
        observers.remove(observer);
    }
    protected void notifyObserves(){
    //通知观察者
        for (Observer observer:observers) {
            observer.updata(this);
        }
    }
}

Observer类的实现：

/**
 *建立人：UncleMin
 *时间：2017/3/11 0011-下午 6:15
 *描述：观察者的接口对象：Observer
 *连接：http://blog.csdn.net/wz1993_0719/article/details/60783657
 */
public interface Observer {
   //更新方法
    public void updata(Subject subject);
}

上面Observable被观察者的基类，为了给具体被观察者继承的，而Observer是接口，里面的方法是刷新数据的；

3、下面就是具体的调用和实现：

import java.util.Observable;

/**
 *建立人：UncleMin
 *时间：2017/3/11 0011-下午 6:59
 *描述：ConcreteSubject:具体的目标对象，负责数据完成以后通知观察者ds
 *连接：http://blog.csdn.net/wz1993_0719/article/details/60783657
 */
public class ConcreteSubject extends Subject {
    private String mContent;
    public String getmContent() {
        return mContent;
    }
    public void setmContent(String mContent) {
        this.mContent = mContent;
        notifyObserves();
    }
}
**
 *建立人：UncleMin
 *时间：2017/3/11 0011-下午 6:57
 *描述：ConcreteObserver：具体的实现观察者对象
 *连接：http://blog.csdn.net/wz1993_0719/article/details/60783657
 */
public class ConcreteObserver implements Observer {
    @Override
    public void updata(Subject subject) {
        String s = ((ConcreteSubject) subject).getmContent();
        Log.e("ob", "updata: "+s);
    }
}

测试调用：

import android.app.Activity;
import android.os.Bundle;
import android.view.View;

/**
 * 建立人：UncleMin
 * 时间：2017/3/11 0011-下午 6:28
 * 描述：
 * 连接：http://blog.csdn.net/wz1993_0719/article/details/60783657
 */
public class ObserverActivity extends Activity {
    private ConcreteSubject subject;
    private ConcreteObserver observer;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_observe);
        subject = new ConcreteSubject();
        observer = new ConcreteObserver();
        subject.addObserver(observer);
    }

    public void onClick(View view) {
        int id = view.getId();
        switch (id){
            case R.id.btn_send:
                subject.setmContent("我是天气晴朗哦，嘻嘻！");
                break;
            case R.id.btn_remove:
                subject.removeObserver(observer);
                break;
        }

    }

    @Override
    protected void onDestroy() {
        super.onDestroy();

    }
}

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:orientation="vertical"
    android:layout_width="match_parent"
    android:layout_height="match_parent">
    <Button
        android:id="@+id/btn_send"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="onClick"
        android:onClick="onClick"
        />

    <Button
        android:id="@+id/btn_remove"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="remove"
        android:onClick="onClick"
        />


</LinearLayout>

上面就是观察者模式的通用的思路与代码，到这里其实回过头来，明白了思想，其实也是很简单的，固然，这么经典的东西，Java的编写人确定不会遗漏的，其实java里面的Util包已经给咱们写好了两个基类，咱们用的时候能够直接的调用就ok了；

4、下面就是Java包下的引用：

被观察者：

package com.example.wz.mystudydemo;

import java.util.Observable;

    /**
     *建立人：UncleMin
     *时间：2017/3/11 0011-下午 6:59
     *描述：ConcreteSubject:具体的目标对象，负责数据完成以后通知观察者ds
     *连接：http://blog.csdn.net/wz1993_0719/article/details/60783657
     */
    public class ConcreteSubject extends Observable {
        private String mContent;
        public String getmContent() {
            return mContent;
        }
        public void setmContent(String mContent) {
            this.mContent = mContent;
            setChanged();
            notifyObservers();
        }
    }

观察者：

import android.util.Log;

import java.util.*;

/**
 *建立人：UncleMin
 *时间：2017/3/11 0011-下午 6:57
 *描述：ConcreteObserver：具体的实现观察者对象
 *连接：http://blog.csdn.net/wz1993_0719/article/details/60783657
 */
public class ConcreteObserver implements java.util.Observer {
    @Override
    public void update(Observable observable, Object data) {
        String s = ((ConcreteSubject) observable).getmContent();
        Log.e("ob", "updata: "+s);
    }
    /*@Override
    public void updata(Subject subject) {
        String s = ((ConcreteSubject) subject).getmContent();
        Log.e("ob", "updata: "+s);
    }*/
}

再观察者模式里面有两种实现方式：推模模型和拉模型；如果感兴趣的童鞋们能够本身去研究一下，毕竟纸上得来终觉浅，绝知此事要躬行

总结：

1.观察者模式的优势：(1)实现了观察者与目标时间的抽象解耦；(2)实现了动态联动；(3)支持广播通讯 2.缺点：引发无所谓的操做；例如一些不必的通知、