观察者模式（Observer Pattern）一种行为型设计模式。它定义了对象之间的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都会得到通知并自动更新。
主题（Subject） ：又称为被观察者（Observable），是观察者模式的核心对象。它负责维护一个观察者列表，用于记录所有依赖于它的观察者对象。当主题对象的状态发生改变时，它会通知所有观察者对象。观察者（Observer） ：又称为观察者（Observer），是依赖于主题对象的参与者。观察者对象需要实现一个特定的接口（如 update() 方法），以便在主题对象状态发生改变时接收通知并作出相应的处理。具体主题（ConcreteSubject） ：是主题类的实现类，负责存储具体的业务逻辑和状态信息。当具体主题对象的状态发生改变时，它会调用某个方法（如 notifyObservers()）来通知所有观察者对象。具体观察者（ConcreteObserver） ：是观察者接口的实现类，负责实现具体的响应逻辑。当接收到主题对象的通知时，具体观察者对象会根据自己的需求对通知进行处理。
在这个案例中，有一组新闻订阅者（观察者），希望接收特定新闻（被观察对象）的更新。当新闻发布时，所有订阅了该新闻的订阅者都会收到通知。
import java. util. ArrayList ;
import java. util. List ;
interface NewsObserver {
void update ( String newsTitle, String newsContent) ;
}
class NewsPublisher {
private List < NewsObserver > ;
public NewsPublisher ( ) {
observers = new ArrayList < > ( ) ;
}
public void registerObserver ( NewsObserver observer) {
observers. add ( observer) ;
}
public void removeObserver ( NewsObserver observer) {
observers. remove ( observer) ;
}
public void publishNews ( String newsTitle, String newsContent) {
System . out. println ( "Publishing news: " + newsTitle) ;
for ( NewsObserver observer : observers) {
observer. update ( newsTitle, newsContent) ;
}
}
}
class EmailSubscriber implements NewsObserver {
@Override
public void update ( String newsTitle, String newsContent) {
System . out. println ( "EmailSubscriber received news: " + newsTitle + "\nContent: " + newsContent) ;
}
}
class MobileAppSubscriber implements NewsObserver {
@Override
public void update ( String newsTitle, String newsContent) {
System . out. println ( "MobileAppSubscriber received news: " + newsTitle) ;
}
}
class WebPageSubscriber implements NewsObserver {
@Override
public void update ( String newsTitle, String newsContent) {
System . out. println ( "WebPageSubscriber received news: " + newsTitle + "\nContent: " + newsContent) ;
}
}
public class NewsSystem {
public static void main ( String [ ] args) {
NewsPublisher newsPublisher = new NewsPublisher ( ) ;
NewsObserver emailSubscriber = new EmailSubscriber ( ) ;
NewsObserver mobileAppSubscriber = new MobileAppSubscriber ( ) ;
NewsObserver webPageSubscriber = new WebPageSubscriber ( ) ;
newsPublisher. registerObserver ( emailSubscriber) ;
newsPublisher. registerObserver ( mobileAppSubscriber) ;
newsPublisher. registerObserver ( webPageSubscriber) ;
newsPublisher. publishNews ( "Breaking News" , "An earthquake hit the city!" ) ;
}
}
Publishing news: Breaking News
EmailSubscriber received news: Breaking News
Content : An earthquake hit the city!
MobileAppSubscriber received news: Breaking News
WebPageSubscriber received news: Breaking News
Content : An earthquake hit the city!
以上是新闻推送的案例，如果需要，你可以添加更多的订阅者类型，或者实现更复杂的逻辑，比如基于新闻类别的订阅、延迟推送等。
这个示例展示了观察者模式在新闻推送场景中的基本应用。在实际应用中，你可能还需要考虑线程安全、错误处理、性能优化等方面的问题。
在游戏开发中，玩家受到攻击时触发观察者模式通常涉及更复杂的逻辑，包括攻击者、受害者、伤害计算、效果展示等多个方面。下面是一个演示了玩家受到攻击时使用观察者模式的案例。
import java. util. ArrayList ;
import java. util. List ;
interface Observer {
void update ( String message) ;
}
interface Subject {
void registerObserver ( Observer o) ;
void removeObserver ( Observer o) ;
void notifyObservers ( String message) ;
}
class Player implements Subject {
private List < Observer > ;
private int healthPoints;
public Player ( int initialHealth) {
this . observers = new ArrayList < > ( ) ;
this . healthPoints = initialHealth;
}
@Override
public void registerObserver ( Observer o) {
observers. add ( o) ;
}
@Override
public void removeObserver ( Observer o) {
observers. remove ( o) ;
}
@Override
public void notifyObservers ( String message) {
for ( Observer observer : observers) {
observer. update ( message) ;
}
}
public void takeDamage ( int damage) {
healthPoints -= damage;
if ( healthPoints < 0 ) {
healthPoints = 0 ;
}
notifyObservers ( "Player took " + damage + " damage. Remaining health: " + healthPoints) ;
}
public int getHealthPoints ( ) {
return healthPoints;
}
public boolean isAlive ( ) {
return healthPoints > 0 ;
}
}
class HUDDisplay implements Observer {
@Override
public void update ( String message) {
System . out. println ( "HUD: " + message) ;
}
}
class GameLog implements Observer {
@Override
public void update ( String message) {
System . out. println ( "Log: " + message) ;
}
}
class Enemy {
private String name;
private int attackPower;
public Enemy ( String name, int attackPower) {
this . name = name;
this . attackPower = attackPower;
}
public void attack ( Player target) {
int damage = this . attackPower;
target. takeDamage ( damage) ;
System . out. println ( this . name + " attacked the player!" ) ;
}
}
public class GameTest {
public static void main ( String [ ] args) {
Player player = new Player ( 100 ) ;
HUDDisplay hudDisplay = new HUDDisplay ( ) ;
GameLog gameLog = new GameLog ( ) ;
player. registerObserver ( hudDisplay) ;
player. registerObserver ( gameLog) ;
Enemy enemy = new Enemy ( "Goblin" , 20 ) ;
enemy. attack ( player) ;
if ( player. isAlive ( ) ) {
System . out. println ( "Player is still alive with " + player. getHealthPoints ( ) + " health points." ) ;
} else {
System . out. println ( "Player has been defeated!" ) ;
}
}
}
HUD : Player took 20 damage. Remaining: 80
Log : Player took 20 damage. Remaining: 80
Goblin attacked the player!
Player is still alive with 80 health points.
在这个例子中，Player 类在受到攻击时调用takeDamage 方法，并通知所有注册的观察者。HUDDisplay 和 GameLog 作为观察者，分别负责在HUD界面和游戏日志中显示玩家受到攻击的信息。Enemy类负责执行攻击行为。
运行这段代码时，你将看到HUD界面和游戏日志中显示了玩家受到攻击的信息，同时还会检查玩家是否存活并显示相应的信息。
这个案例展示了在游戏开发中，如何使用观察者模式来处理玩家受到攻击的事件，并允许不同的组件（如HUD显示、游戏日志等）订阅并响应这些事件。通过解耦，我们可以更容易地扩展游戏的功能，比如添加新的观察者来响应攻击事件，比如播放音效、显示特效等。
主要作用
实现对象间的异步通信，允许一个对象在状态改变时通知多个依赖对象，而无需知道具体的观察者是谁，从而解耦系统并提高可扩展性。
优点
降低耦合性 ：它通过定义对象之间的一对多依赖关系，使得一个对象的状态变化能够通知多个对象，而无需这些对象之间直接交互，从而降低了系统各部分之间的耦合度。增强可扩展性 ：新的观察者可以很容易地添加到系统中，只要它们遵循主题接口，就可以随时订阅或取消订阅主题的状态更新，这使得系统更加灵活和可扩展。支持广播通信 ：在需要广播通信的场景中，观察者模式提供了一种有效的机制，允许主题对象向所有注册的观察者发送通知，而不必知道具体的观察者是谁。动态交互 ：观察者和被观察者之间的交互是动态的，可以在运行时添加或移除观察者，这种灵活性对于实现动态数据绑定和实时事件处理非常有用。实现简单 ：观察者模式的结构相对简单，易于理解和实现，因此在许多实际应用中得到了广泛的使用。适用于多种场景 ：观察者模式适用于多种应用场景，如GUI事件处理、实时数据传输等，它提供了一种标准化的方法来处理状态变化和通知的问题。 缺点
增加系统复杂性 ：虽然观察者模式降低了对象之间的耦合，但同时也增加了系统的复杂性。每个主题对象都需要维护一个观察者列表，并在状态变化时通知所有观察者，这需要额外的代码和资源开销。循环依赖 ：如果在观察者和被观察对象之间存在循环依赖，即一个观察者同时也是另一个观察者的被观察对象，那么当状态变化发生时，它们之间可能会触发循环调用，这不仅会导致通知的无限循环，还可能导致系统崩溃。通知成本 ：当被观察对象的状态发生变化时，它需要通知所有注册的观察者。如果被观察者的数量很多，或者通知过程较为复杂，那么通知的发布可能会消耗大量的时间和资源，导致程序的效率降低。内存开销 ：每个观察者都需要在被观察者中注册，因此如果被观察者有大量的观察者，那么就需要消耗大量的内存来存储这些观察者。通知顺序无法保证 ：在有多个观察者的情况下，无法保证通知的顺序。如果观察者的执行顺序很重要，可能需要额外的逻辑来控制。
消息通知系统 ：如邮件系统、聊天室、新闻推送等，当有新消息或事件产生时，需要实时通知所有关注该消息或事件的观察者。观察者模式可以确保消息的及时传递和处理。分布式系统 ：在分布式系统中，不同节点之间的状态变化需要实时同步。观察者模式可以帮助实现节点之间的状态监测和通知机制，确保系统的一致性和可靠性。状态监控 ：在监控系统中，例如服务器负载监控，当某个指标超过预设阈值时，需要通知管理员或其他系统进行响应。观察者模式可以用来实现这种监控和通知机制。跨模块通信 ：在一个复杂的系统中，不同的模块或组件可能需要在某些事件发生时互相通信。通过观察者模式，一个模块可以作为观察者订阅另一个模块的事件，而不需要知道具体的实现细节。用户界面与交互 ：在图形用户界面（GUI）应用程序中，当某个元素（如按钮、文本框等）的状态发生变化时，可能需要通知其他相关元素进行更新。观察者模式可以确保这些元素之间的动态同步，提高用户体验。游戏开发 ：在游戏中，观察者模式可以用于处理各种事件，如玩家输入、碰撞检测、角色状态变化等。它可以帮助实现游戏逻辑的解耦和灵活扩展。
java.util.Observable 和 java.util.Observer类
java.util.Observable
这是一个抽象类，用于表示被观察的对象，也就是主题（Subject）。当Observable对象的状态发生变化时，它需要通知所有注册的观察者。为了实现这一点，Observable类提供了addObserver方法来注册观察者，deleteObserver方法来移除观察者，以及notifyObservers方法来通知所有观察者对象状态的变化。
java.util.Observe
这是一个接口，用于定义观察者的行为。实现这个接口的类需要定义update方法，该方法将在被观察者状态变化时被调用。这样，观察者就可以接收到通知并执行相应的操作。
保持低耦合 ：确保主题对象（Subject）和观察者对象（Observer）之间的耦合度尽可能低。主题应该只知道观察者实现了某个接口，而不需要知道观察者的具体类或其实现细节。避免直接调用 ：具体目标对象和具体观察者对象之间不应该直接调用对方的方法，这会导致两者之间的紧密耦合，违反面向对象的设计原则。单一职责原则 ：每个对象应该专注于问题域中的一个离散抽象，即一个对象只做一件事情。这有助于提高代码的重用性和维护性。扩展性 ：观察者模式支持对系统进行扩展，可以在不修改现有代码的情况下添加新的观察者类型。新观察者只需实现相应的接口即可注册到主题对象中。注册与注销机制 ：主题应该提供注册和注销观察者的接口，以便在运行时动态地添加或移除观察者。线程安全 ：如果在多线程环境中使用观察者模式，需要考虑同步问题，以防止并发修改导致的数据不一致。通知顺序 ：如果有多个观察者，需要确定通知观察者的顺序，这可能会影响程序的行为。性能考虑 ：在有大量观察者的情况下，通知所有观察者可能会耗费较多时间，需要考虑优化通知机制的性能。避免循环依赖 ：应避免出现观察者和主题之间的循环依赖，这会导致系统难以维护和理解。
