一 android observable ,observer 是如何使用的

在 Android 中，Observable 和 Observer 是用于实现观察者模式的类，主要用于数据变化的通知机制。Android 提供了 Observable 类和 Observer 接口，允许你在数据变化时通知相关的观察者。以下是如何使用它们的基本步骤和示例。

1. 使用 Observable 和 Observer

步骤：

1. 创建一个 Observable 类：

   • 继承 Observable 类，并在数据变化时调用 setChanged() 和 notifyObservers() 方法。

2. 创建一个 Observer 类：

   • 实现 Observer 接口，并重写 update() 方法，以处理来自 Observable 的通知。

3. 注册和注销观察者：

   • 使用 addObserver() 方法注册观察者，使用 deleteObserver() 方法注销观察者。

2. 示例代码

以下是一个简单的示例，演示如何使用 Observable 和 Observer。

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

// 创建一个 Observable 类
class DataModel extends Observable {
    private String data;

    public String getData() {
        return data;
    }

    public void setData(String data) {
        this.data = data;
        setChanged(); // 标记为已改变
        notifyObservers(data); // 通知所有观察者
    }
}

// 创建一个 Observer 类
class DataObserver implements Observer {
    private String name;

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

    @Override
    public void update(Observable o, Object arg) {
        System.out.println(name + " received update: " + arg);
    }
}

// 使用示例
public class Main {
    public static void main(String[] args) {
        DataModel dataModel = new DataModel();

        DataObserver observer1 = new DataObserver("Observer 1");
        DataObserver observer2 = new DataObserver("Observer 2");

        // 注册观察者
        dataModel.addObserver(observer1);
        dataModel.addObserver(observer2);

        // 修改数据，通知观察者
        dataModel.setData("New Data 1");
        dataModel.setData("New Data 2");

        // 注销观察者
        dataModel.deleteObserver(observer1);

        // 修改数据，只有剩下的观察者会收到通知
        dataModel.setData("New Data 3");
    }
}

3. 注意事项

• Observable 和 Observer 是 Java 的标准类，虽然在 Android 中可以使用，但在现代 Android 开发中，推荐使用更强大和灵活的架构组件，如 LiveData 或 RxJava。
• Observable 和 Observer 的使用在多线程环境中需要小心，确保线程安全。
• 在 Android 中，使用 LiveData 和 ViewModel 可以更好地处理 UI 组件的生命周期和数据观察。

4. 现代替代方案

在 Android 开发中，通常推荐使用以下现代替代方案：

• LiveData：与 Android 组件生命周期相结合，适合用于 UI 数据的观察。
• RxJava：提供更强大的异步编程和数据流处理能力。

这些现代工具提供了更好的功能和灵活性，适合于复杂的应用程序开发。

二 Observable 和 Observer 是实现观察者模式（Observer Pattern）的两个核心概念。它们之间的关系如下：

1. Observable

• 定义：Observable 是一个被观察的对象，它维护一个观察者列表。当它的状态发生变化时，它会通知所有注册的观察者。
• 功能：
  • 注册观察者：可以通过 addObserver(Observer o) 方法将观察者添加到列表中。
  • 注销观察者：可以通过 deleteObserver(Observer o) 方法将观察者从列表中移除。
  • 状态变化通知：当状态发生变化时，调用 setChanged() 方法标记状态已改变，然后调用 notifyObservers(Object arg) 方法通知所有观察者。

2. Observer

• 定义：Observer 是一个接口，任何实现该接口的类都可以成为观察者。观察者会在被观察的对象状态变化时接收到通知。
• 功能：
  • 更新方法：实现 update(Observable o, Object arg) 方法，以处理来自 Observable 的通知。这个方法会在 Observable 状态变化时被调用。

3. 关系

• 一对多关系：Observable 和 Observer 之间存在一对多的关系。一个 Observable 可以有多个 Observer，而每个 Observer 只观察一个 Observable。
• 通知机制：当 Observable 的状态发生变化时，它会通知所有注册的 Observer，使得观察者能够及时更新自己的状态或执行相应的操作。
• 解耦：使用观察者模式可以实现对象之间的解耦，Observable 不需要知道具体的 Observer 实现，只需要调用 update 方法。

示例

以下是一个简单的示例，展示了 Observable 和 Observer 的关系：

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

// Observable 类
class WeatherData extends Observable {
    private float temperature;

    public void setTemperature(float temperature) {
        this.temperature = temperature;
        setChanged(); // 标记状态已改变
        notifyObservers(temperature); // 通知观察者
    }
}

// Observer 类
class CurrentConditionsDisplay implements Observer {
    @Override
    public void update(Observable o, Object arg) {
        System.out.println("Current temperature: " + arg + "°C");
    }
}

// 使用示例
public class Main {
    public static void main(String[] args) {
        WeatherData weatherData = new WeatherData();
        CurrentConditionsDisplay display = new CurrentConditionsDisplay();

        // 注册观察者
        weatherData.addObserver(display);

        // 修改数据，通知观察者
        weatherData.setTemperature(25.0f);
        weatherData.setTemperature(30.0f);
    }
}

在这个示例中，WeatherData 是一个 Observable，它维护了一个温度值，并在温度变化时通知所有注册的观察者。CurrentConditionsDisplay 是一个实现了 Observer 接口的类，它在接收到通知时打印当前温度。

三 Observable 和 Observer 谁观察谁

Observable 和 Observer 谁观察谁，确实很多人第一次学都容易搞反。
我来用非常简单直白的方式告诉你：

---

✅ 定义：

角色	解释
Observable	被观察者，即“被盯着看的对象”
Observer	观察者，即“盯着看的人”

---

✅ 谁观察谁？

👉 Observer 观察 Observable！

• Observable 是被观察的。
• Observer 是主动观察的。

就像你在看手机——

• 你是 Observer（观察者）
• 手机是 Observable（被观察者）
  一旦手机（被观察者）有变化（比如收到通知），就会通知你（观察者）。

---

✅ 图解理解

Observable (被观察者) 
         ↓ 通知变化
Observer (观察者)

---

✅ 用 Kotlin 举个超级简单的例子

// 被观察者
val observable = Observable<String>()

// 观察者
val observer = object : Observer<String> {
    override fun onChanged(t: String?) {
        println("观察到变化了！新数据是：$t")
    }
}

// 订阅（注册观察）
observable.addObserver(observer)

// 修改被观察者的状态，通知观察者
observable.notifyObservers("新的状态")

流程就是：

• 观察者（Observer）注册到被观察者（Observable）。
• 当被观察者（Observable）发生变化，主动通知所有 Observer。

---

✅ 你可以这么记住一辈子：

Observer 观察 Observable，Observable 变化了，通知 Observer。

---

✅ 小总结一句话：

术语	含义
Observable	被观察者，变化源
Observer	观察者，变化接收者

---