设计模式Java版：14观察者模式（行为型）

定义

观察者模式（Observer Pattern）是一种行为型设计模式，它定义了对象之间的一对多依赖关系，使得当一个对象的状态发生变化时，所有依赖它的对象都能够得到通知并自动更新。

观察者模式的核心是将一个对象（称为主题或可观察者）与其他对象（称为观察者）进行解耦。主题维护了一个观察者列表，并提供了方法用于添加、移除和通知观察者。当主题的状态发生变化时，它会遍历观察者列表，调用每个观察者的更新方法，从而实现对观察者的通知。

观察者模式的主要参与者包括以下几个角色：

1. Subject（主题）：它是可观察者对象的接口或抽象类，定义了添加、删除和通知观察者的方法。
2. ConcreteSubject（具体主题）：它是具体的可观察者对象，实现了Subject定义的方法。它维护着观察者列表，并在状态发生变化时通知观察者。
3. Observer（观察者）：它定义了接收通知并进行更新的方法。
4. ConcreteObserver（具体观察者）：它是具体的观察者对象，实现了Observer定义的方法。当接收到主题的通知时，它执行相应的操作。

观察者模式的优点包括：

• 解耦性：主题和观察者之间是松耦合的，它们可以独立演化而互不影响。
• 可扩展性：可以动态添加和删除观察者，无需修改主题或观察者的代码。
• 可重用性：可以重用主题和观察者在不同的场景中。

观察者模式在实际开发中广泛应用，例如事件处理、消息订阅、GUI界面更新等。它能够帮助我们实现对象间的松耦合，并提供一种灵活的方式来实现发布-订阅机制。

示例一：

首先，定义观察者接口（Observer）：

public interface Observer {
    void update(String message);
}

然后，定义具体的观察者类（ConcreteObserver）：

public class ConcreteObserver implements Observer {
    private String name;

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

    @Override
    public void update(String message) {
        System.out.println(name + " received message: " + message);
    }
}

接下来，定义主题接口（Subject）：

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

然后，实现具体的主题类（ConcreteSubject）：

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

public class ConcreteSubject implements Subject {
    private List<Observer> observers = new ArrayList<>();

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

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

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

    public void doSomething() {
        // 主题发生变化，发送通知给所有观察者
        notifyObservers("Something happened!");
    }
}

最后，测试观察者模式的代码：

public class Main {
    public static void main(String[] args) {
        ConcreteSubject subject = new ConcreteSubject();
        Observer observer1 = new ConcreteObserver("Observer 1");
        Observer observer2 = new ConcreteObserver("Observer 2");

        // 将观察者添加到主题中
        subject.addObserver(observer1);
        subject.addObserver(observer2);

        // 主题发生变化，通知观察者
        subject.doSomething();

        // 移除一个观察者
        subject.removeObserver(observer1);

        // 主题再次发生变化，通知观察者
        subject.doSomething();
    }
}

输出结果：

Observer 1 received message: Something happened!
Observer 2 received message: Something happened!
Observer 2 received message: Something happened!

在上面的例子中，ConcreteSubject是具体的主题类，ConcreteObserver是具体的观察者类。当主题发生变化时，它会通知所有观察者，并调用观察者的update方法进行更新。可以通过添加和移除观察者来动态管理观察者列表。

示例二：电子商务平台的通知功能

生活中常见的观察者模式的例子是电子商务平台的通知功能。假设有一个电子商务平台，用户可以订阅感兴趣的商品或店铺，并在商品或店铺有新的促销、上新等信息时接收到通知。

首先，定义观察者接口（Observer）：

public interface Observer {
    void update(String message);
}

然后，定义具体的观察者类（User）：

public class User implements Observer {
    private String name;

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

    @Override
    public void update(String message) {
        System.out.println(name + " received notification: " + message);
    }
}

接下来，定义主题接口（Subject）：

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

然后，实现具体的主题类（ECommercePlatform）：

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

public class ECommercePlatform implements Subject {
    private List<Observer> observers = new ArrayList<>();

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

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

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

    public void sendNotification(String message) {
        // 通知所有观察者
        notifyObservers(message);
    }
}

最后，测试观察者模式的代码：

public class Main {
    public static void main(String[] args) {
        ECommercePlatform platform = new ECommercePlatform();
        Observer user1 = new User("User 1");
        Observer user2 = new User("User 2");

        // 将用户添加为观察者
        platform.addObserver(user1);
        platform.addObserver(user2);

        // 发送通知
        platform.sendNotification("New promotion: 20% off on selected items!");

        // 移除一个观察者
        platform.removeObserver(user1);

        // 再次发送通知
        platform.sendNotification("New product just launched!");

    }
}

输出结果：

User 1 received notification: New promotion: 20% off on selected items!
User 2 received notification: New promotion: 20% off on selected items!
User 2 received notification: New product just launched!

在上面的例子中，ECommercePlatform是具体的主题类，User是具体的观察者类。当平台发送通知时，所有订阅了通知的用户（观察者）会收到相应的通知。可以通过添加和移除观察者来管理用户的订阅关系。