美文网首页
设计模式——观察者模式

设计模式——观察者模式

作者: Qiansion齐木楠雄 | 来源:发表于2023-06-06 23:13 被阅读0次

在日常生活中，观察者模式与我们息息相关，就比如爱打游戏的我在操控虚拟角色时，这个角色有hp和mp，在游戏中会有一些对应的面板来展示hp和mp，这个时候其实就是利用了观察者模式，具体是怎么实现的呢？请往下看。
就拿我最先接触到的游戏的传奇来说，一般的，在游戏中，展示人物hp和mp有多个地方


image.png

假设游戏角色被怪物只因打了一下，此时三个地方需要发生变化，角色上方血条，圆盘血条，和数字血条。那我们如何设计呢？
不考虑其他因素，最简单的设计就是当人物掉血时，改变三个地方，代码如下：、

class Role {
    private String name;
    private Integer hp;
    private Integer mp;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getHp() {
        return hp;
    }

    public void setHp(Integer hp) {
        this.hp = hp;
        // 改变人物血量hp
        System.out.println("血条更新hp为："+hp);
        System.out.println("球型更新hp为："+hp);
        System.out.println("面板更新hp为："+hp);
    }

    public Integer getMp() {
        return mp;
    }

    public void setMp(Integer mp) {
        this.mp = mp;
    }
}

class Monster {
    public void attact(Role r){
        r.setHp(r.getHp()-10);
    }
}

public class Test {
    public static void main(String[] args) {
        Role role = new Role();
        role.setName("qiansion");
        role.setHp(100);
        role.setMp(100);
        Monster monster = new Monster();
        monster.attact(role);
    }
}

输出如下：
血条更新hp为：100
球型更新hp为：100
面板更新hp为：100
血条更新hp为：90
球型更新hp为：90
面板更新hp为：90
看似没有什么问题，但是现在变化来了。产品经理需要再添加一个显示血量的地方
那么就需要在以前的代码中，继续新添加代码，这样不好

  1. 不符合开闭原则

  2. 就是上面代码本身耦合性就太高


    image.png

    鉴于以上问题，我们需要重新设计一下整个模型，在之前的代码中，面板，球型，血条显示都是在人物的类中，现在可以将他们抽取出来。等人物hp发生了变化，然后通知各个组件改变相应的数据。而两个类之间传递数据只有两种模式就是 pull 和 push，在本例中，明显push更为方便（因为pull需要各个组件不停的询问人物血条是否变化，内耗过大且实时性较差），当人物血条发生变化，人物主动的push数据到其他组件。而其他组件就等着人物来push，所以我们可以称这些组件为“观察者”

现在，我们可以着手重新设计Role类了，首先思考Role血量发生变化，他需要通知到各个观察者们，那么Role类就必须知道观察者都有哪些，所以需要一个集合去存放这些观察者们，相应的，也需要一些操作观察者的方法，当然最重要的还是通知方法。

观察者们除了关注人物血条的变化，还得接受数据(人物当前血量)，面板，球型，血条都需要接收这个数据，所以可以抽出一个接受数据的接口，让三个组件去实现。

综上，代码如下

class Role {
    private String name;
    private Integer hp;
    private Integer mp;
    private List<Observer> observers = new ArrayList<Observer>();

    public void addObserver(Observer obj){
        observers.add(obj);
    }

    public void removeObserver(Object obj){
        observers.remove(obj);
    }

    public void notifyObservers(){
        for (Observer observer : observers) {
            observer.update(hp);
        }
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getHp() {
        return hp;
    }

    public void setHp(Integer hp) {
        this.hp = hp;
        notifyObservers();
    }

    public Integer getMp() {
        return mp;
    }

    public void setMp(Integer mp) {
        this.mp = mp;
    }
}

interface Observer{
    // 需要一个方法，来接受主体发来的新数据
    void update(int hp);
}

class Panel implements Observer{

    @Override
    public void update(int hp) {
        System.out.println("面板血条更改为："+ hp);
    }
}

class BallPanel implements Observer{

    @Override
    public void update(int hp) {
        System.out.println("球形血条更改为："+ hp);
    }
}

class HeadPanel implements Observer{

    @Override
    public void update(int hp) {
        System.out.println("头部血条更改为："+ hp);
    }
}

class Monster {
    public void attact(Role r){
        r.setHp(r.getHp()-10);
    }
}

public class Test {
    public static void main(String[] args) {
        Role role = new Role();
        role.setName("qiansion");
        role.setHp(100);
        role.setMp(100);
        Panel panel = new Panel();
        BallPanel ballPanel = new BallPanel();
        HeadPanel headPanel = new HeadPanel();
        role.addObserver(panel);
        role.addObserver(ballPanel);
        role.addObserver(headPanel);
        Monster monster = new Monster();
        monster.attact(role);
    }
}

输出如下：
面板血条更改为：90
球形血条更改为：90
头部血条更改为：90
跟之前的代码相比，明显耦合度降低了，符合了单一职责。产品经理如果需要新添加一个展示血条的地方，那么可以新建一个类实现Observer接口，并将该类添加到role的观察者列表中。
现在仍然存在一个缺点：
目前主体Role只会把自己的hp广播给所有的观察者，那么如果想也把mp一起广播呢？势必要违反开闭原则！！而且游戏业务经常变化，导致Role类的属性越来越多，难道每次多一个属性，都要修改Observer的update 方法吗？

显然，上面的方法过于简漏，在Observer的update方法里直接把Role对象传进去即可解决，组件想展示什么就能够展示什么

class Role {
    private String name;
    private Integer hp;
    private Integer mp;
    private List<Observer> observers = new ArrayList<Observer>();

    public void addObserver(Observer obj){
        observers.add(obj);
    }

    public void removeObserver(Object obj){
        observers.remove(obj);
    }

    public void notifyObservers(){
        for (Observer observer : observers) {
            observer.update(this);
        }
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getHp() {
        return hp;
    }

    public void setHp(Integer hp) {
        this.hp = hp;
        notifyObservers();
    }

    public Integer getMp() {
        return mp;
    }

    public void setMp(Integer mp) {
        this.mp = mp;
    }

    @Override
    public String toString() {
        return "Role{" +
                "name='" + name + '\'' +
                ", hp=" + hp +
                ", mp=" + mp +
                '}';
    }
}

interface Observer{
    // 需要一个方法，来接受主体发来的新数据
    void update(Role r);
}

class Panel implements Observer{

    @Override
    public void update(Role r) {
        System.out.println("面板血条更改为："+ r);
    }
}

class BallPanel implements Observer{

    @Override
    public void update(Role r) {
        System.out.println("球形血条更改为："+ r);
    }
}

class HeadPanel implements Observer{

    @Override
    public void update(Role r) {
        System.out.println("头部血条更改为："+ r);
    }
}

class Monster {
    public void attact(Role r){
        r.setHp(r.getHp()-10);
    }
}

public class Test {
    public static void main(String[] args) {
        Role role = new Role();
        role.setName("qiansion");
        role.setHp(100);
        role.setMp(100);
        Panel panel = new Panel();
        BallPanel ballPanel = new BallPanel();
        HeadPanel headPanel = new HeadPanel();
        role.addObserver(panel);
        role.addObserver(ballPanel);
        role.addObserver(headPanel);
        Monster monster = new Monster();
        monster.attact(role);
    }
}

输出如下：
面板血条更改为：Role{name='qiansion', hp=90, mp=100}
球形血条更改为：Role{name='qiansion', hp=90, mp=100}
头部血条更改为：Role{name='qiansion', hp=90, mp=100}
目前每当主体Role的状态发生变化，就算主体有很多个属性，也不会影响代码
修改之后也带来一些问题，作为一个接口，Observer接口中的update方法，居然出现了具体类名！如此，Observer就只能观察Role这个类了，观察不了别的类的对象了，不容易拓展。

继续修改

class Role {
    private String name;
    private Integer hp;
    private Integer mp;
    private List<Observer> observers = new ArrayList<Observer>();

    public void addObserver(Observer obj){
        observers.add(obj);
    }

    public void removeObserver(Object obj){
        observers.remove(obj);
    }

    public void notifyObservers(){
        for (Observer observer : observers) {
            observer.update();
        }
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getHp() {
        return hp;
    }

    public void setHp(Integer hp) {
        this.hp = hp;
        notifyObservers();
    }

    public Integer getMp() {
        return mp;
    }

    public void setMp(Integer mp) {
        this.mp = mp;
    }

    @Override
    public String toString() {
        return "Role{" +
                "name='" + name + '\'' +
                ", hp=" + hp +
                ", mp=" + mp +
                '}';
    }
}

interface Observer{
    // 需要一个方法，来接受主体发来的新数据
    void update();
}

class Panel implements Observer{
    private Role r;
    public Panel(Role r){
        this.r = r;
    }
    @Override
    public void update() {
        System.out.println("面板血条更改为："+ r);
    }
}

class BallPanel implements Observer{
    private Role r;
    public BallPanel(Role r){
        this.r = r;
    }
    @Override
    public void update() {
        System.out.println("球形血条更改为："+ r);
    }
}

class HeadPanel implements Observer{
    private Role r;
    public HeadPanel(Role r){
        this.r = r;
    }
    @Override
    public void update() {
        System.out.println("头部血条更改为："+ r);
    }
}

class Monster {
    public void attact(Role r){
        r.setHp(r.getHp()-10);
    }
}

public class Test {
    public static void main(String[] args) {
        Role role = new Role();
        role.setName("qiansion");
        role.setHp(100);
        role.setMp(100);
        Panel panel = new Panel(role);
        BallPanel ballPanel = new BallPanel(role);
        HeadPanel headPanel = new HeadPanel(role);
        role.addObserver(panel);
        role.addObserver(ballPanel);
        role.addObserver(headPanel);
        Monster monster = new Monster();
        monster.attact(role);
    }
}

输出如下：
面板血条更改为：Role{name='qiansion', hp=90, mp=100}
球形血条更改为：Role{name='qiansion', hp=90, mp=100}
头部血条更改为：Role{name='qiansion', hp=90, mp=100}
修改后，主体不再主动推送数据，从push的方式修改为 push + pull的方式，主体只是通知观察者“我变了”，观察者收到消息，就自己去看主体哪儿变了，巧妙之处就在于此，因为这种推+拉的模式，主体中有观察者，观察者中有主体。再以上代码中还可以做一些抽象，Role类中的addObserver和removeObserver等都可以抽象为接口，这就是最完整的观察者模式

interface Subject {
    void addObserver(Observer observer);
    void removeObserver(Observer observer);
    void notifyObservers();
}

class Role implements Subject{
    private String name;
    private Integer hp;
    private Integer mp;
    private List<Observer> observers = new ArrayList<Observer>();

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

    @Override
    public void removeObserver(Observer observer){
        observers.remove(observer);
    }

    @Override
    public void notifyObservers(){
        for (Observer observer : observers) {
            observer.update();
        }
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getHp() {
        return hp;
    }

    public void setHp(Integer hp) {
        this.hp = hp;
        notifyObservers();
    }

    public Integer getMp() {
        return mp;
    }

    public void setMp(Integer mp) {
        this.mp = mp;
    }

    @Override
    public String toString() {
        return "Role{" +
                "name='" + name + '\'' +
                ", hp=" + hp +
                ", mp=" + mp +
                '}';
    }
}

interface Observer{
    // 需要一个方法，来接受主体发来的新数据
    void update();
}

class Panel implements Observer{
    private Role r;
    public Panel(Role r){
        this.r = r;
        r.addObserver(this);
    }
    @Override
    public void update() {
        System.out.println("面板血条更改为："+ r);
    }
}

class BallPanel implements Observer{
    private Role r;
    public BallPanel(Role r){
        this.r = r;
        r.addObserver(this);
    }
    @Override
    public void update() {
        System.out.println("球形血条更改为："+ r);
    }
}

class HeadPanel implements Observer{
    private Role r;
    public HeadPanel(Role r){
        this.r = r;
        r.addObserver(this);
    }
    @Override
    public void update() {
        System.out.println("头部血条更改为："+ r);
    }
}

class Monster {
    public void attact(Role r){
        r.setHp(r.getHp()-10);
    }
}

public class Test {
    public static void main(String[] args) {
        Role role = new Role();
        role.setName("qiansion");
        role.setHp(100);
        role.setMp(100);
        Panel panel = new Panel(role);
        BallPanel ballPanel = new BallPanel(role);
        HeadPanel headPanel = new HeadPanel(role);
        Monster monster = new Monster();
        monster.attact(role);
    }
}

相关文章

  • 观察者设计模式

    每周学点Java设计模式__观察者设计模式 本次继续更新java23中设计模式之一——观察者模式。 观察者模式（有...

  • RxJava基础—观察者模式

    设计模式-观察者模式 观察者模式：观察者模式（有时又被称为发布（publish ）-订阅（Subscribe）模式...

  • 设计模式02-观察者者设计模式

    [toc] 设计模式02-观察者者设计模式 主要来源Head First设计模式（书）观察者设计模式是JDK中使用...

  • 11.9设计模式-观察者模式-详解

    设计模式-观察者模式 观察者模式详解 观察者模式在android中的实际运用 1.观察者模式详解 2.观察者模式在...

  • RxJava设计模式与原理

    标准观察者设计模式 RxJava是一种特殊的观察者模式，首先我们先来看标准的观察者设计模式。在标准观察者模式中，存...

  • 设计模式

    常用的设计模式有，单例设计模式、观察者设计模式、工厂设计模式、装饰设计模式、代理设计模式,模板设计模式等等。 单例...

  • Guava源码分析——EventBus

    EventBus的设计理念是基于观察者模式的，可以参考设计模式(1)—观察者模式先来了解该设计模式。 1、程序示例...

  • 设计模式之观察者模式

    设计模式之观察者模式 本篇是设计模式系列博客的第四篇，本篇主要学习设计模式中的第二个行为型模式---观察者模式。 ...

  • PHP设计模式之观察者模式

    PHP设计模式之观察者模式

  • Android中涉及的模式

    我的Java设计模式-建造者模式 我的Java设计模式-观察者模式 重学设计模式之单例模式

网友评论

      本文标题：设计模式——观察者模式

      本文链接：https://www.haomeiwen.com/subject/zqfftdtx.html

      延伸阅读

      深度阅读

      • 您也可以注册成为美文阅读网的作者，发表您的原创作品、分享您的心情！

      栏目导航

      热点阅读

      关于我们|服务条款|联系我们|设计模式——观察者模式|投稿指南|网站地图|RSS订阅|排版工具|手机版

      提供经典美文摘抄,优美散文欣赏,现代诗歌精选,短篇小说,心情随笔,表白情书范文,故事会在线阅读欣赏

      Copyright © 2014-2023 Haomeiwen.com All Rights Reserved. 好美文阅读网 版权所有

      备案信息：桂公网安备 45052102000051号 · 桂ICP备13007215号-3

      本站所收录作品、热点评论等信息部分来源互联网，目的只是为了系统归纳学习和传递资讯

      所有作品版权归原创作者所有，与本站立场无关，如不慎侵犯了你的权益，请联系我们告知，我们将做删除处理！