设计模式之观察者模式

最新推荐文章于 2024-07-27 18:05:15 发布

深夜演说家

最新推荐文章于 2024-07-27 18:05:15 发布

阅读量512

点赞数 13

文章标签：设计模式观察者模式

本文链接：https://blog.csdn.net/qq_36153047/article/details/140227709

版权

观察者模式

定义：（观察者--观察目标）对象之前的一对多的依赖关系，是的每当一个对象状态发生改变的时候，其他相关依赖对象都可以收到通知并且更新。（也可以叫发布-订阅）模式。

1.代码案例

在等红绿灯中，多辆汽车在等待红灯变绿，当红灯变绿是，所有等待的汽车都开始启动。

红灯变绿→发送通知信息→汽车做出响应

ControlCenter 充当抽象目标类

package com.company.Demo.observer;

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

public abstract class ControlCenter {

    // 汽车
    protected List<Observer> play = new ArrayList<>();

    // 加入排队汽车
    public void join(Observer obs) {
        System.out.println(obs.getCarName() + "进入排队!");
        play.add(obs);
    }

    public abstract void notifyObserver();

}

TrafficLightControlCenter 具体指挥部类,充当具体红路灯目标类

package com.company.Demo.observer;

import java.util.concurrent.TimeUnit;

public class TrafficLightControlCenter extends ControlCenter {
    Integer time;
    public TrafficLightControlCenter(Integer time) {
        this.time=time;
        System.out.printf("--------红灯时间%s秒---------%n", time);
    }

    @Override
    public void notifyObserver() {
        for (Observer observer : play) {
            while (true) {
                if (time <= 0) {
                    observer.start();
                    break;
                } else {
                    System.out.printf("---------红灯倒计时%s---------%n", time);
                    try {
                        // 模拟倒计时
                        TimeUnit.SECONDS.sleep(1);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                }
                time--;
            }
        }
    }
}

Observer 抽象观察者

package com.company.Demo.observer;

public interface Observer {

    String getCarName();

    // 发动汽车
    void start();

    // 根据红绿灯变化通知
    void detecting(ControlCenter acc);
}

Car 具体实现观察者类

package com.company.Demo.observer;

public class Car implements Observer {

    private String name;


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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String getCarName() {
        return getName();
    }

    @Override
    public void start() {
        System.out.println(this.name + "发动汽车");
    }


    @Override
    public void detecting(ControlCenter acc) {
        acc.notifyObserver();
    }
}

测试类

package com.company.Demo.observer;
public class Main {

    public static void main(String[] args) {
        ControlCenter ally=new TrafficLightControlCenter(5);

        Observer obs=new Car("大众cc");
        ally.join(obs);

        Observer obs2=new Car("宝马M3");
        ally.join(obs2);

        Observer obs3=new Car("桑塔纳");
        ally.join(obs3);

        // 状态通知
        obs.detecting(ally);

    }
}

结果;

--------红灯时间5秒---------

大众cc进入排队!

宝马M3进入排队!

桑塔纳进入排队!

---------红灯倒计时5---------

---------红灯倒计时4---------

---------红灯倒计时3---------

---------红灯倒计时2---------

---------红灯倒计时1---------

大众cc发动汽车

宝马M3发动汽车

桑塔纳发动汽车

car.detecting() → ControlCenter.notifyObserver() → car.start()

2.JDK 对观察者模式的支持

public interface Observer {
    /**
     * This method is called whenever the observed object is changed. An
     * application calls an <tt>Observable</tt> object's
     * <code>notifyObservers</code> method to have all the object's
     * observers notified of the change.
     *
     * @param   o     the observable object.
     * @param   arg   an argument passed to the <code>notifyObservers</code>
     *                 method.
     */
    void update(Observable o, Object arg);
}

public class Observable {....}

使用JDK自带实现观察者模式

Car 是观察者

package com.company.Demo.observer.jdk;

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

public class Car implements Observer {

    private String name;


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

    
    public void start() {
        System.out.println(this.name + "发动汽车");
    }

    @Override
    public void update(Observable o, Object arg) {
        start();
    }
}

TrafficLightControlCenter 是被观察者

package com.company.Demo.observer.jdk;

import java.util.Observable;

public class TrafficLightControlCenter extends Observable {

        public void end(){
            System.out.println("------红灯结束-----");
            super.setChanged();
            super.notifyObservers();
        }

}

验证：

package com.company.Demo.observer;

import com.company.Demo.observer.jdk.Car;
import com.company.Demo.observer.jdk.TrafficLightControlCenter;

public class Main {

    public static void main(String[] args) {

        Car car=new Car("大众cc");
        TrafficLightControlCenter call=new TrafficLightControlCenter();
        call.addObserver(car);

        call.end();
    }
}