观察者模式（案例：十进制转二进制、八进制、十六进制)

观察者模式（案例：十进制转二进制、八进制、十六进制)

​ 观察者模式是一种常用的设计模式，属于行为型模式。它允许一个对象（称为“主题”或“被观察者”）维持一系列依赖于它的对象（称为“观察者”），当主题的状态发生变化时，会自动通知所有观察者对象，使它们能够自动更新自己。

观察者模式的组成：

1. Subject（主题） - 维护一组观察者，提供用于增加和删除观察者的方法。
2. Observer（观察者） - 所有潜在的更新对象必须实现的接口。
3. BinaryObserver（具体观察者，二进制） - 当接收到主题变化的通知时，执行相应的动作。
4. OctalObserver（具体观察者，八进制） - 当接收到主题变化的通知时，执行相应的动作。
5. HexObserver （具体观察者，十六进制） - 当接收到主题变化的通知时，执行相应的动作。

使用场景：

• 当一个对象的改变需要同时改变其他对象，而且它不知道具体有哪些对象需要改变时。
• 当一个抽象模型有两个方面，其中一个方面依赖于另一个方面。将这两者封装在独立的对象中以使它们可以各自独立地改变和复用。

主题：

//待观察的主题：  状态
//一旦主题中的状态发生变化， 就要通知所有观察者，你们要运行(   进制转换   )
public class Subject {

    //2 所有的转换器  观察的状态是state
    private int state;  //此属性可以是一个复杂的对象

    private List<Observer> observers = new ArrayList<>();  //观察者（进制转换器）的集合

    //1 将转换器保存到  转换器集合
    public void register(Observer Observer){
        //将观察者保存到集合中 （ 将观察者注册到主题中来  ）
        observers.add(Observer);
    }
    //3 状态一发生变化
    public void setState(int state){
        //状态变化
        this.state = state;
        //通知观察者状态变了 ，请运算
        //4  循环所有的转换器（观察者） ，调用转换器的转换方法 update() 输出对应的进制的值
        for (int i=0;i<observers.size();i++){
            Observer observer = observers.get(i); //提取每个转换器（观察者）
            observer.update(); //调用每个转换器（观察者）的转换方法
        }
    }
    public int getState() {
        return state;
    }
}

观察者：

public abstract class Observer {

    protected Subject subject;  //待观察的主题

    public abstract void update(); //  转换方法

}

具体观察者：

//二进制的转换器 （二进制的观察者）
public class BinaryObserver extends Observer{
    public BinaryObserver(Subject subject) {
        super.subject=subject;  //当前二进制的观察者观察了谁 （主题）
        subject.register( this  );//主题中也要知道谁 （观察者/转换器） 观察了自己
    }
    @Override
    public void update() {
        //转换开始 取出Subject中的state，转为二进制
        int state = super.subject.getState(); //先取出变化后的状态
        String str = Integer.toBinaryString(state);
        System.out.println(  "原始值："+state+"转成二进制的结果为："+str  );
    }
}

//八进制的转换器 （八进制的观察者）
public class OctalObserver extends Observer{
    public OctalObserver(Subject subject) {
        super.subject=subject;  //当前八进制的观察者观察了谁 （主题）
        subject.register( this  );//主题中也要知道谁 （观察者/转换器） 观察了自己
    }
    @Override
    public void update() {
        //转换开始 取出Subject中的state，转为八进制
        int state = super.subject.getState(); //先取出变化后的状态
        String str = Integer.toOctalString( state );
        System.out.println(  "原始值："+state+"转成八进制的结果为："+str  );
    }
}

//十六进制的转换器 （十六进制的观察者）
public class HexObserver extends Observer {
    public HexObserver(Subject subject) {
        super.subject = subject;
        subject.register(this);
    }
    public void update() {
        int state = super.subject.getState();
        String str = Integer.toHexString(state);
        System.out.println("原始值：" + state + "转成十六进制的结果为：" + str);
    }
}

客户端使用

public class App {
    public static void main(String[] args) {
        //1 带观察者的主题
        Subject subject = new Subject();

        //2 创建一些观察者（转换器） 并注册这些观察者到主题中
        new OctalObserver(  subject  );//八进制
        new BinaryObserver(  subject  );//二进制
        new HexObserver( subject ); //十六进制

        System.out.println("更改状态值：");
        subject.setState(  10  );
    }
}

运行结果