Java观察者设计模式 代码

### 回答1：
Java 中的观察者模式是一种设计模式，它提供了一种方法，使得一个或多个对象可以监听另一个对象的状态改变。当被监听的对象的状态改变时，所有的监听者都会收到通知。

Java 中实现观察者模式通常需要使用两个接口：Observer 和 Observable。Observer 接口代表观察者，它定义了更新方法，在被监听的对象的状态改变时会调用此方法。Observable 接口代表被监听的对象，它维护了一个观察者列表，并定义了添加、删除和通知观察者的方法。

以下是一个简单的 Java 代码示例，演示了如何使用观察者模式：

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

// 被监听的对象
class ObservableObject extends Observable {
  private int value;

  public void setValue(int value) {
    this.value = value;
    // 标记此对象已经发生了改变
    setChanged();
    // 通知所有的观察者
    notifyObservers();
  }
}

// 观察者
class ObserverObject implements Observer {
  private ObservableObject observable;

  public ObserverObject(ObservableObject observable) {
    this.observable = observable;
    // 将自己添加到被监听的对象的观察者列表中
    observable.addObserver(this);
  }

  @Override
  public void update(Observable o, Object arg) {
    // 当被监听的对象发生改变时，此方法会被调用
    System.out.println("ObservableObject has changed: "  

### 回答2：
Java观察者设计模式是一种行为设计模式，它定义了一种一对多的依赖关系，让多个观察者对象同时监听一个主题对象，当主题对象的状态发生变化时，会通知所有观察者对象进行更新。这种设计模式可以实现低耦合、高内聚的代码结构。

在Java中实现观察者设计模式需要以下几个核心角色：
1. 主题对象（Subject）：负责维护观察者对象的列表，提供增加、删除和通知观察者的方法。
2. 观察者对象（Observer）：定义了接收主题对象通知的更新方法。
3. 具体主题对象（ConcreteSubject）：是主题对象的具体实现，维护观察者对象列表，并在状态发生变化时通知观察者。
4. 具体观察者对象（ConcreteObserver）：实现观察者接口，接收主题对象的通知并进行相应的处理。

下面是一个简单的Java观察者设计模式的代码示例：

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

// 主题接口
interface Subject {
void addObserver(Observer observer);
void removeObserver(Observer observer);
void notifyObservers();
}

// 观察者接口
interface Observer {
void update();
}

// 具体主题类
class ConcreteSubject implements Subject {
private List<Observer> observers = new ArrayList<>();

@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();
}
}
}

// 具体观察者类
class ConcreteObserver implements Observer {
@Override
public void update() {
System.out.println("接收到通知，进行相应的更新操作");
}
}

// 测试类
public class ObserverPatternExample {
public static void main(String[] args) {
ConcreteSubject subject = new ConcreteSubject();
ConcreteObserver observer1 = new ConcreteObserver();
ConcreteObserver observer2 = new ConcreteObserver();

subject.addObserver(observer1);
subject.addObserver(observer2);

subject.notifyObservers();
}
}

以上代码中，ConcreteSubject实现了Subject接口的方法，并维护了一个观察者对象的列表。ConcreteObserver实现了Observer接口的方法，具体的更新操作在update方法中定义。在测试类中，我们创建了一个具体主题对象和两个具体观察者对象，并通过addObserver方法将观察者对象添加到主题对象的观察者列表中。当调用主题对象的notifyObservers方法时，所有观察者对象会接收到通知并执行相应的更新操作。

这样，通过观察者设计模式，可以实现对象之间的解耦，提高代码的复用性和扩展性。  

### 回答3：
观察者设计模式是一种行为设计模式，用于实现对象之间的松耦合关系。在Java中，观察者设计模式主要由以下几个角色组成：

1. Subject（主题）：也称为被观察者，它是被观察的对象。Subject类通常包含一个或多个观察者对象，并提供方法来添加或删除观察者。当主题的状态发生变化时，它会通知所有观察者。

2. Observer（观察者）：观察者接口定义了观察者对象的更新接口。观察者对象需要实现该接口，以便主题对象能够通知它们的变化。

3. ConcreteSubject（具体主题）：具体主题是主题类的子类，它维护了一个观察者对象的列表，并实现了抽象主题中声明的方法。具体主题类通常是业务逻辑的核心。

4. ConcreteObserver（具体观察者）：具体观察者是观察者接口的实现类。它通过订阅主题来接收主题的通知，并在收到通知时更新自身状态。

下面是一个简单的Java观察者设计模式的示例代码：

// 主题接口
public interface Subject {
void addObserver(Observer observer);
void removeObserver(Observer observer);
void notifyObservers();
}

// 具体主题类
public class ConcreteSubject implements Subject {
private List<Observer> observers = new ArrayList<>();
private int state;

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

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

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

public void setState(int state) {
this.state = state;
notifyObservers();
}
}

// 观察者接口
public interface Observer {
void update();
}

// 具体观察者类
public class ConcreteObserver implements Observer {
private int state;

public void update() {
// 更新观察者状态
state = // 更新的逻辑
}
}

// 测试代码
public class TestObserverPattern {
public static void main(String[] args) {
Subject subject = new ConcreteSubject();
Observer observer1 = new ConcreteObserver();
Observer observer2 = new ConcreteObserver();

subject.addObserver(observer1);
subject.addObserver(observer2);

// 改变主题状态
((ConcreteSubject) subject).setState(1);
}
}

以上是一个简单的Java观察者设计模式的示例代码。在该代码中，ConcreteSubject类作为主题，具体Observer类作为观察者。当主题的状态发生变化时，它会通知所有的观察者进行相应的更新操作。