Lecture 14 The Observer Pattern

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

class TicketSeller {
    // 维护一个观察者的列表，谁订阅了就放进来
    private List<TicketNotificationSubscriber> subscribers = new ArrayList<>();

    /**
     * 订阅（注册）方法，任何实现了TicketNotificationSubscriber的人都能订阅通知
     */
    public void signUpForNotifications(TicketNotificationSubscriber subscriber) {
        this.subscribers.add(subscriber);
    }

    /**
     * 主题所发送的事件，例如宣布某个演唱会有新票了
     */
    public void announceNewConcert(String concertName) {
        System.out.println("【TicketSeller】宣布演唱会 " + concertName + " 可以购票了！");
        // 遍历所有订阅者，逐一通知
        for (TicketNotificationSubscriber sub : this.subscribers) {
            sub.ticketsAvailableFor(concertName);
        }
    }

    /**
     * 购买门票的逻辑，这里简单演示一下，真实情况下可能有很多业务校验
     */
    public void purchaseTicketFor(String concertName) {
        System.out.println("【TicketSeller】购买了演唱会 " + concertName + " 的门票。");
    }
}

class Person implements TicketNotificationSubscriber {
    // 这个人只关心哪个演唱会
    private String interestedConcert;
    // 保存一个对TicketSeller的引用，为了后续去调用purchaseTicketFor
    private TicketSeller seller;

    /**
     * 让这个人开始订阅某个演唱会的票务通知
     */
    public void tryToBuyTicketsFor(String concertName, TicketSeller seller) {
        this.interestedConcert = concertName;
        this.seller = seller;
        // 告诉卖票的人：我要订阅你们的“新演唱会消息”
        seller.signUpForNotifications(this);
    }

    /**
     * 真正收到通知时，会被TicketSeller调用
     */
    @Override
    public void ticketsAvailableFor(String concertName) {
        System.out.println("【Person】收到通知：演唱会 " + concertName + " 票来了！");
        // 如果是我感兴趣的那个演唱会，就立刻去买票
        if (concertName.equals(this.interestedConcert)) {
            System.out.println("【Person】正是我想看的演唱会！赶紧买票！");
            seller.purchaseTicketFor(concertName);
        } else {
            System.out.println("【Person】但这场演唱会我不感兴趣。");
        }
    }
}

public class ObserverPatternDemo {
    public static void main(String[] args) {
        // 1. 创建主题（卖票方）
        TicketSeller ticketSeller = new TicketSeller();

        // 2. 创建几个观察者
        Person alice = new Person();
        Person bob = new Person();

        // 3. 分别让alice和bob订阅自己感兴趣的演唱会
        alice.tryToBuyTicketsFor("周杰伦演唱会", ticketSeller);
        bob.tryToBuyTicketsFor("林俊杰演唱会", ticketSeller);

        // 4. 卖票方宣布演唱会开始，看看谁会收到通知并且行动
        System.out.println("\n=== 第一次宣布：周杰伦演唱会 ===");
        ticketSeller.announceNewConcert("周杰伦演唱会");

        System.out.println("\n=== 第二次宣布：林俊杰演唱会 ===");
        ticketSeller.announceNewConcert("林俊杰演唱会");
    }
}

=== 第一次宣布：周杰伦演唱会 ===
【TicketSeller】宣布演唱会 周杰伦演唱会 可以购票了！
【Person】收到通知：演唱会 周杰伦演唱会 票来了！
【Person】正是我想看的演唱会！赶紧买票！
【TicketSeller】购买了演唱会 周杰伦演唱会 的门票。
【Person】收到通知：演唱会 周杰伦演唱会 票来了！
【Person】但这场演唱会我不感兴趣。

=== 第二次宣布：林俊杰演唱会 ===
【TicketSeller】宣布演唱会 林俊杰演唱会 可以购票了！
【Person】收到通知：演唱会 林俊杰演唱会 票来了！
【Person】但这场演唱会我不感兴趣。
【Person】收到通知：演唱会 林俊杰演唱会 票来了！
【Person】正是我想看的演唱会！赶紧买票！
【TicketSeller】购买了演唱会 林俊杰演唱会 的门票。

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

/**
 * 演示入口类：包含 main() 方法。
 * 这里命名为 public class ObserverPatternDemo，其他类用包级可见（不加 public）即可。
 */
public class ObserverPatternDemo {
    public static void main(String[] args) {
        // 1. 创建主题（卖票方）
        TicketSeller ticketSeller = new TicketSeller();

        // 2. 创建几个观察者
        Person alice = new Person();
        Person bob = new Person();

        // 3. 分别让alice和bob订阅自己感兴趣的演唱会
        alice.tryToBuyTicketsFor("周杰伦演唱会", ticketSeller);
        bob.tryToBuyTicketsFor("林俊杰演唱会", ticketSeller);

        // 4. 卖票方宣布演唱会开始，看看谁会收到通知并且行动
        System.out.println("\n=== 第一次宣布：周杰伦演唱会 ===");
        ticketSeller.announceNewConcert("周杰伦演唱会");

        System.out.println("\n=== 第二次宣布：林俊杰演唱会 ===");
        ticketSeller.announceNewConcert("林俊杰演唱会");
    }
}

/**
 * 观察者接口: 所有想要“订阅演唱会通知”的类，都要实现这个接口。
 */
interface TicketNotificationSubscriber {
    void ticketsAvailableFor(String concertName);
}

/**
 * 主题（Subject）：卖票方。
 * 维护一个观察者列表，宣布新演唱会时通知所有观察者。
 */
class TicketSeller {
    // 维护一个观察者列表
    private List<TicketNotificationSubscriber> subscribers = new ArrayList<>();

    /**
     * 订阅/注册方法，让任何实现了 TicketNotificationSubscriber 的对象加进来
     */
    public void signUpForNotifications(TicketNotificationSubscriber subscriber) {
        this.subscribers.add(subscriber);
    }

    /**
     * 模拟宣布新的演唱会来临，并通知所有订阅者
     */
    public void announceNewConcert(String concertName) {
        System.out.println("【TicketSeller】宣布演唱会 " + concertName + " 可以购票了！");
        for (TicketNotificationSubscriber sub : subscribers) {
            sub.ticketsAvailableFor(concertName);
        }
    }

    /**
     * 简化的购票方法，这里仅做打印演示
     */
    public void purchaseTicketFor(String concertName) {
        System.out.println("【TicketSeller】购买了演唱会 " + concertName + " 的门票。");
    }
}

/**
 * 具体的观察者：实现了 TicketNotificationSubscriber 接口。
 * 表示一个想买票的人。
 */
class Person implements TicketNotificationSubscriber {
    private String interestedConcert;  // 只关注这个演唱会
    private TicketSeller seller;       // 持有 TicketSeller 引用以便购票

    /**
     * 让这个人开始订阅并关注某个演唱会的门票通知
     */
    public void tryToBuyTicketsFor(String concertName, TicketSeller seller) {
        this.interestedConcert = concertName;
        this.seller = seller;
        // 注册到卖票方的“订阅”列表中
        seller.signUpForNotifications(this);
    }

    /**
     * 收到票务通知的回调方法
     */
    @Override
    public void ticketsAvailableFor(String concertName) {
        System.out.println("【Person】收到通知：演唱会 " + concertName + " 票来了！");
        if (concertName.equals(this.interestedConcert)) {
            System.out.println("【Person】正是我想看的演唱会！赶紧买票！");
            seller.purchaseTicketFor(concertName);
        } else {
            System.out.println("【Person】但这场演唱会我不感兴趣。");
        }
    }
}

// ======================
// 文件名: ObserverPatternDemo.java
// ======================

import java.util.ArrayList; // 引入 ArrayList，用于保存订阅者列表
import java.util.List;      // 引入 List 接口，用于抽象列表类型

/**
 * 主类：包含 main 方法，是程序的入口
 * 由于这个类是 public，所以文件名必须与类名相同（ObserverPatternDemo.java）
 */
public class ObserverPatternDemo {
    /**
     * main方法：Java 程序入口，执行演示逻辑
     */
    public static void main(String[] args) {
        // 1. 创建主题（卖票方）
        TicketSeller ticketSeller = new TicketSeller(); 
        // 这里我们实例化了一个 TicketSeller 对象，它将作为“事件发布者”（Subject）

        // 2. 创建几个观察者
        Person alice = new Person(); 
        // 实例化第一个观察者（对周杰伦感兴趣的用户）
        Person bob = new Person();   
        // 实例化第二个观察者（对林俊杰感兴趣的用户）

        // 3. 分别让 alice 和 bob 订阅自己感兴趣的演唱会
        alice.tryToBuyTicketsFor("周杰伦演唱会", ticketSeller);
        // alice 想要周杰伦演唱会门票，于是告诉 ticketSeller “我订阅这场演唱会”
        bob.tryToBuyTicketsFor("林俊杰演唱会", ticketSeller);
        // bob 想要林俊杰演唱会门票，也向 ticketSeller 订阅

        // 4. 卖票方宣布演唱会开始，看看谁会收到通知并且行动
        System.out.println("\n=== 第一次宣布：周杰伦演唱会 ===");
        ticketSeller.announceNewConcert("周杰伦演唱会");
        // announceNewConcert 会通知所有已订阅的观察者
        // alice 感兴趣，会执行购买；bob 也会收到通知但不感兴趣，所以不会购买

        System.out.println("\n=== 第二次宣布：林俊杰演唱会 ===");
        ticketSeller.announceNewConcert("林俊杰演唱会");
        // 同理，这次 bob 会购买，alice 只会收到消息但不执行购买
    }
}

/**
 * 观察者接口：任何想收到“门票可用”通知的类，都必须实现此接口。
 * 其中只有一个方法：ticketsAvailableFor(String concertName)
 * 用于在某个演唱会可以购票时获得回调通知。
 */
interface TicketNotificationSubscriber {
    /**
     * 回调方法：当名为 concertName 的演唱会可购票时触发
     * @param concertName 演唱会的名称
     */
    void ticketsAvailableFor(String concertName);
}

/**
 * 主题(Subject)：卖票方 TicketSeller
 * - 维护一个“订阅者”列表(subscribers)，
 * - 当有新的演唱会消息时(announceNewConcert)，循环调用每个订阅者的回调方法。
 */
class TicketSeller {
    // 用于存放所有已订阅的观察者(实现了 TicketNotificationSubscriber 接口的对象)
    private List<TicketNotificationSubscriber> subscribers = new ArrayList<>();

    /**
     * 订阅方法：让任何实现了 TicketNotificationSubscriber 的对象加进来
     * @param subscriber 传入的订阅者对象
     */
    public void signUpForNotifications(TicketNotificationSubscriber subscriber) {
        this.subscribers.add(subscriber);
        // 将订阅者加入列表，以后有新演唱会时会通知他们
    }

    /**
     * 模拟宣布新的演唱会来临，并通知所有订阅者
     * @param concertName 演唱会名字
     */
    public void announceNewConcert(String concertName) {
        System.out.println("【TicketSeller】宣布演唱会 " + concertName + " 可以购票了！");
        // 广播给每一个订阅者
        for (TicketNotificationSubscriber sub : subscribers) {
            sub.ticketsAvailableFor(concertName);
        }
    }

    /**
     * 简化的购票方法，这里仅做打印演示
     * @param concertName 演唱会名字
     */
    public void purchaseTicketFor(String concertName) {
        System.out.println("【TicketSeller】购买了演唱会 " + concertName + " 的门票。");
        // 实际业务中，可能会在这里进行扣款、票务记录、发送电子票等操作
    }
}

/**
 * 具体观察者(Concrete Observer)：一个“想买演唱会票的人”。
 * 实现了 TicketNotificationSubscriber 接口，就可以订阅演唱会通知。
 */
class Person implements TicketNotificationSubscriber {
    private String interestedConcert; // 保存感兴趣的演唱会名称
    private TicketSeller seller;      // 用来操作买票、以及由谁发送通知

    /**
     * 让这个人开始订阅并关注某个演唱会的门票通知
     * @param concertName 感兴趣的演唱会名称
     * @param seller 需要向哪个卖票方订阅
     */
    public void tryToBuyTicketsFor(String concertName, TicketSeller seller) {
        this.interestedConcert = concertName; // 记录下自己想看的演唱会
        this.seller = seller;                 // 记录要向哪个 TicketSeller 订阅
        seller.signUpForNotifications(this);  // 将自己(this)注册到卖票方的订阅列表
    }

    /**
     * 收到票务通知的回调方法
     * @param concertName 哪个演唱会来了票
     */
    @Override
    public void ticketsAvailableFor(String concertName) {
        // 每当 TicketSeller.broadcast 时，就会调用这个方法
        System.out.println("【Person】收到通知：演唱会 " + concertName + " 票来了！");
        // 如果和自己的 interestedConcert 匹配，才去买
        if (concertName.equals(this.interestedConcert)) {
            System.out.println("【Person】正是我想看的演唱会！赶紧买票！");
            seller.purchaseTicketFor(concertName);
        } else {
            System.out.println("【Person】但这场演唱会我不感兴趣。");
        }
    }
}