java接口案例(观察者设计模式)



import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

// Observer Interface
interface Observer {
    void update(String weather);
}

// Subject Interface
interface Subject {
    void addObserver(Observer observer);
    void removeObserver(Observer observer);
    void notifyObservers();
}

// ConcreteSubject Class
class WeatherStation implements Subject {
    private List<Observer> observers = new ArrayList<>();
    private String weather;

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

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

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

    public void setWeather(String newWeather) {
        this.weather = newWeather;
        notifyObservers();
    }
}

// ConcreteObserver Class
class PhoneDisplay implements Observer {
    private String weather;

    @Override
    public void update(String weather) {
        this.weather = weather;
        display();
    }

    private void display() {
        System.out.println("Phone Display: Weather updated - " + weather);
    }
}

// ConcreteObserver Class
class TVDisplay implements Observer {
    private String weather;

    @Override
    public void update(String weather) {
        this.weather = weather;
        try {
            display();
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }

    private void display() throws IOException {
        FileWriter fileWriter = new FileWriter("weather.txt",true);
        fileWriter.write("TV Display: Weather updated - " + weather+"\n");
        fileWriter.close();
//        System.out.println();
    }
}

// Usage Class
public class WeatherApp {
    public static void main(String[] args) {
        WeatherStation weatherStation = new WeatherStation();

        Observer phoneDisplay = new PhoneDisplay();
        Observer tvDisplay = new TVDisplay();

        weatherStation.addObserver(phoneDisplay);
        weatherStation.addObserver(tvDisplay);

        // Simulating weather change
        Scanner scanner = new Scanner(System.in);
        while (true){
            System.out.println("please input temperature now, input enter to exit");
            String info = scanner.nextLine();
            if(info.equals("")){
                break;
            }
            weatherStation.setWeather(info);
        }
        System.out.println("over");
        // Output:
        // Phone Display: Weather updated - Sunny
        // TV Display: Weather updated - Sunny
    }
}

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
### 回答1: 我可以给你一个简单的Java观察者模式案例,请看下面的代码: public class Main { public static void main(String[] args) { // 创建被观察者 Observable observable = new Observable(); // 创建观察者 Observer observer = new Observer(); // 添加观察者 observable.addObserver(observer); // 改变被观察者的状态 observable.setChanged(); // 通知观察者 observable.notifyObservers("Hello Observer!"); } } ### 回答2: 观察者设计模式是一种行为型设计模式,它定义了一种对象之间的一对多依赖关系,使得当一个对象的状态发生变化时,所有依赖它的对象都会收到通知并自动更新。 以下是一个使用Java编写的观察者设计模式的简单案例: 1. 首先,我们创建一个被观察者类(Subject),它内部包含一个状态属性和一个观察者列表。该类提供注册观察者、删除观察者和通知观察者的方法。 ```java import java.util.ArrayList; import java.util.List; public class Subject { private int state; private List<Observer> observers = new ArrayList<>(); public int getState() { return state; } public void setState(int state) { this.state = state; notifyObservers(); } public void attach(Observer observer) { observers.add(observer); } public void detach(Observer observer) { observers.remove(observer); } public void notifyObservers() { for (Observer observer : observers) { observer.update(); } } } ``` 2. 接下来,我们创建一个观察者接口(Observer),它定义了一个update()方法,用于接收被观察者的通知并作出相应的动作。 ```java public interface Observer { void update(); } ``` 3. 然后,我们创建一个具体的观察者类(ConcreteObserver),实现Observer接口的update()方法,用于在接收到被观察者的通知时执行一些操作。 ```java public class ConcreteObserver implements Observer { @Override public void update() { System.out.println("Received notification from subject."); // 执行相应的操作 } } ``` 4. 最后,我们可以在主程序中进行测试。 ```java public class Main { public static void main(String[] args) { Subject subject = new Subject(); Observer observer1 = new ConcreteObserver(); Observer observer2 = new ConcreteObserver(); subject.attach(observer1); subject.attach(observer2); subject.setState(1); } } ``` 以上代码创建了一个Subject对象,并向其注册了两个ConcreteObserver观察者。当调用subject.setState(1)时,观察者们会接收到通知并执行相应的操作。 这个简单的案例展示了观察者设计模式的基本实现方式,实际应用中可以根据需求进行扩展和优化。 ### 回答3: 观察者设计模式是一种常见的软件设计模式,它用于对象之间的一对多依赖关系。在该模式中,一个对象(称为“主题”或“被观察者”)维护了一组观察者对象,并在其状态变化时自动通知观察者。当主题对象发生变化时,所有观察者对象都将得到相应的通知更新自己的状态。 下面以一个简单的案例来说明如何用Java编写一个观察者设计模式的例子: 假设我们有一个主题类Subject和两个观察者类ObserverA和ObserverB。Subject类中有一个状态count和一个观察者集合observers,提供了注册观察者、删除观察者和通知观察者的方法。ObserverA和ObserverB继承自观察者接口Observer,并实现了该接口的update方法,用于接收主题状态的更新。 代码示例如下: ```java import java.util.ArrayList; import java.util.List; interface Observer { void update(int count); } class Subject { private int count; private List<Observer> observers = new ArrayList<>(); public void registerObserver(Observer observer) { observers.add(observer); } public void removeObserver(Observer observer) { observers.remove(observer); } public void notifyObservers() { for (Observer observer : observers) { observer.update(count); } } public void setCount(int count) { this.count = count; notifyObservers(); } } class ObserverA implements Observer { @Override public void update(int count) { System.out.println("ObserverA received update: " + count); } } class ObserverB implements Observer { @Override public void update(int count) { System.out.println("ObserverB received update: " + count); } } public class Main { public static void main(String[] args) { Subject subject = new Subject(); ObserverA observerA = new ObserverA(); ObserverB observerB = new ObserverB(); subject.registerObserver(observerA); subject.registerObserver(observerB); subject.setCount(10); // 输出: // ObserverA received update: 10 // ObserverB received update: 10 subject.removeObserver(observerA); subject.setCount(20); // 输出: // ObserverB received update: 20 } } ``` 在上述示例中,我们创建了一个主题Subject和两个观察者ObserverA和ObserverB。我们首先注册了两个观察者对象,然后通过调用setCount方法来设置Subject的状态并通知所有的观察者对象。在执行setCount方法后,观察者对象的update方法将被调用,更新它们的状态。 通过这个简单的例子,我们可以看到,观察者设计模式能够实现对象之间的松耦合,主题对象和观察者对象之间的关系不是硬编码在一起的,而是通过注册和通知的方式实现动态的绑定。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值