观察者模式(ObserverPattern)

package service;

/**
 * @author SHshuo
 * @data 2021/10/16--19:30
 * 观察者抽象类
 */
public interface Observer {
//    更新状态
    void update();
}

package service;

/**
 * @author SHshuo
 * @data 2021/10/16--19:29
 * 通知者接口
 * 这里依赖了观察者的接口，后续会去掉。
 * 将移动到客户端用事务处理器进行添加删除观察者，并携带对应的被通知的内容
 *
 * 通知会用到循环遍历，后续会修改成委托给事件处理器EventHandler
 * 因为一个委托可以搭载多个方法
 */
public interface Subject {
//    添加观察者
    void attach(Observer observer);
//    删除观察者
    void detach(Observer observer);
//    通知观察者
    void subjectNotify();
//    通知者的状态
    String subjectState();
}

package service.Impl.ConcreteObserver;

import service.Observer;
import service.Subject;

/**
 * @author SHshuo
 * @data 2021/10/16--19:44
 * 买股票的观察者
 */
public class StockObserver implements Observer {

    private String name;
    private Subject subject;

    public StockObserver(String name, Subject subject){
        this.name = name;
        this.subject = subject;
    }


    @Override
    public void update() {
        System.out.println(subject.subjectState() + name + "股票关闭，继续工作" );
    }
}

package service.Impl.ConcreteSubject;

import service.Observer;
import service.Subject;

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

/**
 * @author SHshuo
 * @data 2021/10/16--19:33
 * 前台秘书通知
 */
public class SecretarySubject implements Subject {

    //    存放观察者
    List<Observer> list = new ArrayList<>();

    //    老板的状态
    private String subjectState;

    public void setSubjectState(String subjectState) {
        this.subjectState = subjectState;
    }

    public String getSubjectState() {
        return subjectState;
    }

    @Override
    public String subjectState() {
        return subjectState;
    }

    @Override
    public void attach(Observer observer) {
        list.add(observer);
    }

    @Override
    public void detach(Observer observer) {
        list.remove(observer);
    }

    //    循环遍历通知观察者
    @Override
    public void subjectNotify() {
        for(Observer o : list){
            o.update();
        }
    }
}

package controller;

import service.Impl.ConcreteObserver.NBAObserver;
import service.Impl.ConcreteObserver.StockObserver;
import service.Impl.ConcreteSubject.BossSubject;
import service.Impl.ConcreteSubject.SecretarySubject;

/**
 * @author SHshuo
 * @data 2021/10/16--15:07
 * 模板方法模式
 */
public class Client {
    public static void main(String[] args) {

//        通知者
        SecretarySubject subject = new SecretarySubject();

//        观察者
        NBAObserver nbaObserver = new NBAObserver("hshuo", subject);
        StockObserver stockObserver = new StockObserver("lvmozhu", subject);

//        添加观察者
        subject.attach(nbaObserver);
        subject.attach(stockObserver);

//        通知观察者
        subject.setSubjectState("老板回来了");
        subject.subjectNotify();


    }
}

UML类图

1. 就是一种引用方法的类型。一旦为委托分配了方法，委托将与该方法具有完全相同的行为。委托方法的使用可以像其他任何方法一样，具体的参数和返回值。委托可以看作是对函数的抽象，是函数的类，委托实例将代表一个具体的函数。
2. 一个委托可以搭载多个方法，所有的方法被依次唤起。更重要的是可以使得委托对象所搭载的方法并不需要属于同一类。
3. 委托对象所搭载的所有方法必须具有相同的原形和形式，也就是是拥有相同的参数列表和返回值类型。