# 观察者模式在Java中的实现: 揭秘背后的设计之美-CSDN博客

本文链接：https://blog.csdn.net/weixin_46372265/article/details/140278594

观察者模式在Java中的实现: 揭秘背后的设计之美

大家好,我是城南。 [路漫漫其修远兮，吾将上下而求所]。

前言

在这个信息爆炸的时代，设计模式已经成为软件开发中的一项必备技能。你是否曾经遇到这样的问题：一个对象的状态改变了，但你需要通知许多其他对象？这种场景下，我们需要一种巧妙的解决方案，那就是观察者模式。那么，今天我们来探讨一下观察者模式在Java中的实现，以及它背后的设计哲学。

什么是观察者模式？

观察者模式（Observer Pattern）是一种行为型设计模式。它定义了一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都会收到通知并自动更新。这个模式的核心在于解耦，即将观察者（Observer）和被观察者（Subject）分离开来，使得它们之间的依赖关系最低。

简单来说，观察者模式就像我们平时订阅公众号一样。当你订阅了一个公众号，每当有新的内容发布时，你会收到通知。同样地，在观察者模式中，当被观察者对象（Subject）的状态改变时，它会通知所有注册的观察者对象（Observer）。

观察者模式的结构

观察者模式主要包含以下几个角色：

Subject（被观察者）：状态发生变化时通知观察者的对象。
Observer（观察者）：接收通知并且更新自身状态的对象。
ConcreteSubject（具体被观察者）：实现了Subject接口的具体类。
ConcreteObserver（具体观察者）：实现了Observer接口的具体类。

下面我们通过一个简单的示例来展示观察者模式在Java中的实现。

观察者模式的Java实现

1. 定义Subject接口

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

interface Subject {
    void registerObserver(Observer o);
    void removeObserver(Observer o);
    void notifyObservers();
}

2. 实现ConcreteSubject类

class ConcreteSubject implements Subject {
    private List<Observer> observers;
    private int state;

    public ConcreteSubject() {
        this.observers = new ArrayList<>();
    }

    @Override
    public void registerObserver(Observer o) {
        observers.add(o);
    }

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

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

    public void setState(int state) {
        this.state = state;
        notifyObservers();
    }

    public int getState() {
        return state;
    }
}

3. 定义Observer接口

interface Observer {
    void update(int state);
}

4. 实现ConcreteObserver类

class ConcreteObserver implements Observer {
    private int observerState;

    @Override
    public void update(int state) {
        this.observerState = state;
        display();
    }

    public void display() {
        System.out.println("Observer state updated to: " + observerState);
    }
}

5. 测试观察者模式

public class ObserverPatternDemo {
    public static void main(String[] args) {
        ConcreteSubject subject = new ConcreteSubject();

        ConcreteObserver observer1 = new ConcreteObserver();
        ConcreteObserver observer2 = new ConcreteObserver();

        subject.registerObserver(observer1);
        subject.registerObserver(observer2);

        subject.setState(10);
        subject.setState(20);
    }
}

在上面的示例中，我们定义了一个Subject接口和一个Observer接口，并且实现了它们的具体类。当Subject的状态改变时，它会通知所有注册的Observer，从而使它们的状态同步更新。

观察者模式的优势

解耦：观察者模式通过引入中间层，使得观察者和被观察者之间的依赖关系大大减少。这样可以提高代码的可维护性和可扩展性。
灵活性：观察者模式允许动态添加或移除观察者，系统可以在运行时决定是否需要某些观察者。
响应性：观察者模式使得系统能够对状态变化做出实时响应，这在实时系统中尤为重要。

观察者模式的应用场景

观察者模式在现实世界中有广泛的应用，例如：

事件监听：在GUI框架中，观察者模式常用于事件监听。例如，当用户点击按钮时，所有注册的监听器会被通知并做出响应。
订阅-发布系统：在消息系统中，观察者模式用于实现发布-订阅机制。发布者发布消息时，所有订阅者都会收到通知。
数据绑定：在MVVM（Model-View-ViewModel）模式中，观察者模式用于实现数据绑定。视图模型（ViewModel）中的数据变化时，视图（View）会自动更新。

深入探讨：Java中的Observer和Observable

Java中有一个内置的观察者模式实现，即java.util.Observer和java.util.Observable。不过，由于种种原因，这两个类在Java 9中被标记为过时（deprecated）。尽管如此，了解它们仍然有助于我们更好地理解观察者模式。

使用内置的Observer和Observable

import java.util.Observable;
import java.util.Observer;

class MyObservable extends Observable {
    private int state;

    public void setState(int state) {
        this.state = state;
        setChanged();
        notifyObservers(state);
    }

    public int getState() {
        return state;
    }
}

class MyObserver implements Observer {
    @Override
    public void update(Observable o, Object arg) {
        System.out.println("State changed to: " + arg);
    }
}

public class BuiltInObserverDemo {
    public static void main(String[] args) {
        MyObservable observable = new MyObservable();
        MyObserver observer = new MyObserver();

        observable.addObserver(observer);
        observable.setState(30);
        observable.setState(40);
    }
}