android设计模式-观察者模式

也就是平时的按键监控其实不仅是接口的调用和回调,也是个观察者模式

//平常里的按钮事件监听例子

Button buttonA = (Button)findViewById(R.id.button1);

//注册观察者

buttonA.setOnClickListener(new OnClickListener()

{

//观察者实现

@Override

public void onClick(View view)

{

//这里可以知道要观察的对象的一举一动...

}

});

//拆分后

buttonA ---->要观察的对象//要观察谁谁谁

setOnClickListener() ---->观察者

new OnClickListener() ---->观察者的实现//在实现里可以知道要观察的对象的一举一动

观察者模式定义:定义了对象之间的一对多依赖,当一个对象改变状态时,它的所有依赖者都会收到通知并自动更新。比如按键监听。

两种方法:

使用JDK自带的,实际上也是和第二种方式一样的。

参考:https://www.jianshu.com/p/ec399a25e9d4

记住一个原则,把观察者用list的形式添加到被观察者里面,然后被观察者变化的时候去便利list,调用观察者的方法

1、定义观察者

public class PersonObserver implements Observer {
    static final String TAG = PersonObserver.class.getSimpleName();
    String name;

    public PersonObserver (String name) {
        this.name = name;
    }

    @Override
    public void update(Observable observable, Object o) {
        Log.d(TAG,name + " 接收到通知啦 "+ o); //这里的update其实就可以理解成button的时候点击之后的onclick函数
    }
}

观察者就实现一个接口update方法,当被观察者发送消息的时候,我们就在update里接收

2、定义被观察者

public class AndroidObervable extends Observable {
    static final String TAG = AndroidObervable.class.getSimpleName();

    public void postNewVersion(String version) {
        setChanged(); // 标示内容发生改变
        notifyObservers(version);// 通知所有观察者 //这里面的两个函数是Observable中的,其实就是遍历通知给观察者
    }
}

被观察者继承自Observable,Observable里已经定义好了list,add,delete等方法,很好理解。

3、最后我们来看下怎么用的

        PersonObserver xiaoMing = new PersonObserver("xiaoMing");
        PersonObserver xiaoDong = new PersonObserver("xiaoDong");
        PersonObserver xiaoHong = new PersonObserver("xiaoHong");

       // 添加到集合里。
        AndroidObervable android = new AndroidObervable();
        android.addObserver(xiaoMing);
        android.addObserver(xiaoDong);
        android.addObserver(xiaoHong);
        // 通知
        android.postNewVersion("android O updated!");
        android.postNewVersion("android P updated!");

11-20 10:05:57.004 13623-13623/com.yink.designpattern.designpattern D/PersonObserver: xiaoMing 接收到通知啦 android O updated!
11-20 10:05:57.004 13623-13623/com.yink.designpattern.designpattern D/PersonObserver: xiaoDong 接收到通知啦 android O updated!
11-20 10:05:57.004 13623-13623/com.yink.designpattern.designpattern D/PersonObserver: xiaoHong 接收到通知啦 android O updated!
11-20 10:05:57.004 13623-13623/com.yink.designpattern.designpattern D/PersonObserver: xiaoMing 接收到通知啦 android P updated!
11-20 10:05:57.004 13623-13623/com.yink.designpattern.designpattern D/PersonObserver: xiaoDong 接收到通知啦 android P updated!
11-20 10:05:57.004 13623-13623/com.yink.designpattern.designpattern D/PersonObserver: xiaoHong 接收到通知啦 android P updated!

看输出都通知到了。观察者模式采用JDK原生的方式实现起来很简单。JDK都给我们封装好了。只管添加就好。这个例子适合我们先对观察者模式有一个大概理解,知道这就是观察者模式。

例二

接下来我们自己来实现观察者模式。我们以观察天气变化为例。

1、定义观察者

public abstract class WeatherOberver {

    public void typhoon() {

    }

    public abstract void sun();

    public abstract void rain();
}

这里和例一的差别是,我们用的抽象类,没用接口,他们思想都相似。这里我是为了区分事件,我们也可以用接口写,然后把各种天气用一个变量表示,这里就不详述了。

2、定义被观察者

public class WeatherObervable extends WeatherOberver{
    ArrayList<WeatherOberver> list = new ArrayList<>();

    public void add(WeatherOberver observerListener) {
        list.add(observerListener);
    }

    public void remove(WeatherOberver observerListener) {
        if (list.contains(observerListener)){
            list.remove(observerListener);
        }
    }

    @Override
    public void typhoon() {
        for (WeatherOberver observerListener : list) {
            observerListener.typhoon();
        }
    }

    @Override
    public void sun() {
        for (WeatherOberver observerListener : list) {
            observerListener.sun();
        }
    }

    @Override
    public void rain() {
        for (WeatherOberver observerListener : list) {
            observerListener.rain();
        }
    }
}

被观察者的实现也是简单粗暴。这里就体现了我们文章开始的时候说的观察者模式的核心了。一个list提供add,remove方法,把观察者放到集合里。需要通知的时候遍历通知即可。这下就好理解了吧。

3、最后看看调用。

private WeatherOberver xiaoDong = new WeatherOberver() {
        @Override
        public void typhoon() {
            Log.d("xiaoDong","吹台风,要放假了。哈哈!");
        }

        @Override
        public void sun() {

        }

        @Override
        public void rain() {
            Log.d("xiaoDong","下雨了,带伞");
        }
    };

    private WeatherOberver xiaoMing = new WeatherOberver() {

        @Override
        public void sun() {
            
        }

        @Override
        public void rain() {
            Log.d("xiaoMing","下雨了,带伞");
        }
    };

WeatherObervable weatherObervable = new WeatherObervable();
weatherObervable.add(xiaoMing);
weatherObervable.add(xiaoDong);

weatherObervable.rain();
weatherObervable.typhoon();

这里做做理解:

实际上的观察者模式,用的是android最基本的语法规则罢了。把观察者放入到被观察者里面的list里面。由于被观察者继承的是观察者类。被观察者里面加入观察者对象,然后在被观察者里面用观察者的对象去调用函数(sun、rain),由于是观察者是抽象类,所以是需要其继承的子类去实现的。即会调用到子类当中的实现里面。就是button的onclick方法了

这里看起来没什么,但实际上,如果有很多人去观察了,那就比较方便了,直接通过add添加观察者即可,然后每个观察者关注的函数不一样的,当然可以全部通知:

weatherObervable.rain();

weatherObervable.typhoon();

xxxxxx

但是有些人关注下雨、有些人关注台风。那就只实现对应的抽象函数类OBservice即可了

11-20 11:16:21.284 15580-15580/com.yink.designpattern.designpattern D/xiaoMing: 下雨了,带伞
11-20 11:16:21.284 15580-15580/com.yink.designpattern.designpattern D/xiaoDong: 下雨了,带伞
11-20 11:16:21.284 15580-15580/com.yink.designpattern.designpattern D/xiaoDong: 吹台风,要放假了。哈哈!

因为观察者我用的抽象类,除了天晴和下雨是必须继承的方法,刮台风可继承可不继承。所以我们可以更方便的观察我们需要观察的对象。小东在广东,吹台风他们公司就放假。所以他只关心哪天吹台风。小明比较讲究健康,关注下雨,下雨就带伞。

观察者模式小结

观察者模式就是将观察者和被观察者彻底隔离,实现解耦,只依赖于我们定义的抽象。观察者模式运用十分广泛,比如我们的ListView运用了观察者模式和Adapter是的Listview的可扩展性,灵活性非常强。还有比较出名的开源库EventBus也是用了观察者模式的思想实现解耦。

作者:Yink_Liu

链接:https://www.jianshu.com/p/ec399a25e9d4

来源:简书

著作权归作者所有。商业转载请联系作者获得授权,非商业转载请注明出处。

相关推荐
闲人一枚(学习中)2 分钟前
设计模式-创建型-抽象工厂模式
设计模式·抽象工厂模式
闲暇部落30 分钟前
‌Kotlin中的?.和!!主要区别
android·开发语言·kotlin
小白不太白9502 小时前
设计模式之 观察者模式
观察者模式·设计模式
诸神黄昏EX3 小时前
Android 分区相关介绍
android
大白要努力!3 小时前
android 使用SQLiteOpenHelper 如何优化数据库的性能
android·数据库·oracle
小白不太白9504 小时前
设计模式之 责任链模式
python·设计模式·责任链模式
Estar.Lee4 小时前
时间操作[取当前北京时间]免费API接口教程
android·网络·后端·网络协议·tcp/ip
Winston Wood4 小时前
Perfetto学习大全
android·性能优化·perfetto
吾与谁归in4 小时前
【C#设计模式(13)——代理模式(Proxy Pattern)】
设计模式·c#·代理模式
吾与谁归in4 小时前
【C#设计模式(14)——责任链模式( Chain-of-responsibility Pattern)】
设计模式·c#·责任链模式