JAVA观察者模式详细介绍及应用

合集下载

java最常用的六种设计模式及举例

java最常用的六种设计模式及举例

java最常用的六种设计模式及举例设计模式是在软件开发过程中经验总结的一种编码和设计方式,它们可以帮助我们更好地组织代码,提高代码的可维护性和可复用性。

下面是 Java 中最常用的六种设计模式及其举例:1. 单例模式:单例模式确保一个类只有一个实例,并提供一个全局访问点。

典型的例子是 `ng.Runtime` 类,在整个 JVM 中只有一个运行时实例。

2. 工厂模式:工厂模式通过一个工厂类来创建其他类的对象,将对象的创建和使用分离,降低了代码的耦合度。

比如,`java.util.Calendar` 类使用了工厂模式来创建 `Calendar` 对象,其中的 `getInstance()` 方法返回一个 `Calendar` 实例。

3. 观察者模式:观察者模式定义了对象之间的一对多的依赖关系,当一个对象状态发生改变时,其相关依赖对象会收到通知并自动更新。

一个典型的例子是使用 `java.util.Observable` 类和 `java.util.Observer`接口进行监听和通知。

4. 装饰者模式:装饰者模式通过动态地将新功能附加到对象上,为对象提供了灵活的扩展方式,不需要修改原始对象的结构。

比如,`java.io` 包中的各种装饰者类可以用来扩展输入输出功能。

5. 策略模式:策略模式定义了一组算法,并将每个算法封装到可互换的对象中,使得算法的变化不会影响到使用算法的客户端。

一个常见的例子是使用 `parator` 接口来实现不同的比较策略。

6. 适配器模式:适配器模式将一个类的接口转换成客户端所期望的另一个接口,使得原本不兼容的类可以一起工作。

比如,`java.util.Arrays` 类中的 `asList()` 方法返回的是一个适配器,可以将数组转换成 List。

通过学习这些设计模式,我们可以更好地组织和设计代码,提高代码的可读性和可维护性。

在实际的开发中,我们可以针对具体的需求选择合适的设计模式,并根据需要进行一定的修改和定制。

java最常用的六种设计模式及举例

java最常用的六种设计模式及举例

java最常用的六种设计模式及举例
1. 单例模式(Singleton Pattern):保证一个类只有一个实例,并提供一个全局访问点。

例如,数据库连接池的设计使用了单例模式。

2. 工厂模式(Factory Pattern):通过使用工厂方法来创建对象,而不是直接调用构造函数,从而实现封装和解耦的目的。

例如,Java中的Calendar类的getInstance()方法返回一个Calendar对象。

3. 观察者模式(Observer Pattern):定义对象间的一种一对多的依赖关系,当一个对象的状态改变时,所有依赖于它的对象都会自动接收到通知并更新。

例如,Java中的事件处理机制,使用了观察者模式。

4. 装饰者模式(Decorator Pattern):动态地给一个对象添加一些额外的职责,同时又不改变其结构。

例如,Java IO中的InputStream类是一个抽象类,而以其为基础的FileInputStream 类和BufferedInputStream类则是具体的装饰者。

5. 适配器模式(Adapter Pattern):将一个类的接口转换成客户希望的另外一个接口。

例如,Java中的Collections类中的方法Arrays.asList()可以将数组转换为List类型。

6. 策略模式(Strategy Pattern):封装一系列的算法,使得它们可以互相替换,而不影响使用它们的客户端。

例如,Java中
的Comparator接口和Comparable接口,用于定义排序算法的策略。

观察者模式的应用场景

观察者模式的应用场景

观察者模式的应用场景观察者模式是一种设计模式,用于实现对象之间的一对多依赖关系。

在该模式中,一个对象(subject)维护了一个观察者列表,当subject的状态发生变化时,它会自动通知所有观察者,使它们能够做出相应的响应。

观察者模式可以帮助我们实现松耦合的设计,提高代码的复用性和可维护性。

下面我们将介绍观察者模式的几个常见应用场景。

一、图形界面组件观察者模式在图形用户界面(GUI)的设计中被广泛应用。

例如,在一个窗口中,可以有多个按钮,当按钮被点击时,窗口会触发相应的事件。

这些按钮就是观察者,窗口是被观察者。

当按钮被点击时,窗口会通知所有的按钮,并且每个按钮都可以根据需要进行响应,例如执行一段特定的代码。

通过观察者模式,可以实现图形界面组件之间的解耦,使得它们可以独立地进行开发和维护。

二、消息订阅与发布观察者模式也可以用于消息订阅与发布的场景。

在这种场景下,可以有多个消息的订阅者(观察者),当有新的消息发布时,订阅者会收到通知并进行相应的处理。

这种模式可以应用于各种场景,例如新闻订阅、实时数据监控等。

通过观察者模式,发布者和订阅者之间的耦合度得到了降低,方便了系统的扩展和维护。

三、事件处理在事件驱动的程序设计中,观察者模式也经常被用于事件的处理。

事件可以是用户的操作,例如鼠标点击、键盘输入等,也可以是系统的通知,例如网络连接成功、文件加载完成等。

当事件发生时,被观察者会通知所有的观察者,并且每个观察者可以根据自身的需要做出相应的处理。

这种模式使得事件的处理变得灵活而可扩展,方便了程序的开发和维护。

四、数据监控与同步观察者模式还可以用于数据监控与同步的场景。

例如,在一个分布式系统中,可以有多个节点,每个节点都有自己的状态。

当任何一个节点的状态发生变化时,需要通知其他的节点进行同步。

这时,可以使用观察者模式,将每个节点作为观察者,当任何一个节点的状态发生变化时,它会通知其他的节点进行相应的更新操作。

Java设计模式常用设计模式及其应用场景

Java设计模式常用设计模式及其应用场景

Java设计模式常用设计模式及其应用场景设计模式是软件工程中常用的一种解决问题的方案,它提供了一套被广泛接受和验证的解决方案,用于解决在软件设计过程中遇到的各种问题。

Java作为一种广泛应用的编程语言,有许多常用的设计模式可以应用到Java开发中。

本文将介绍几种常用的Java设计模式以及它们的应用场景。

一、单例模式单例模式是一种在整个应用程序中只允许创建一个实例的设计模式。

它主要解决的问题是对资源的共享访问以及避免重复创建对象。

在Java中,单例模式的应用场景非常多,比如用于创建数据库连接池、线程池等资源池。

使用单例模式可以保证这些资源的唯一性,避免资源的浪费。

二、工厂模式工厂模式是一种通过创建工厂类来实例化对象的设计模式。

它主要解决的问题是创建对象的过程复杂,需要通过工厂类来封装这个复杂的过程。

在Java中,工厂模式常用于创建对象时需要根据条件来判断具体需要创建哪种类型的对象的情况。

比如,根据用户的输入来创建不同类型的图形对象,可以使用工厂模式。

三、观察者模式观察者模式是一种对象间的一对多依赖关系,当一个对象的状态发生变化时,它的所有依赖对象都会收到通知并自动更新。

在Java中,观察者模式被广泛应用于事件监听和消息传递。

比如,一个网站上的用户注册功能,当用户成功注册后,可以通过观察者模式通知其他相关的模块进行相应的操作。

四、策略模式策略模式是一种将算法封装起来并使其可以互相替换的设计模式。

它主要解决的问题是为同一种问题提供多种解决方案,并且使这些解决方案可以相互替换,互不影响。

在Java中,策略模式可以用于实现不同的排序算法、不同的计算方式等。

比如,一个商场的折扣活动可以采用策略模式,根据不同的折扣策略计算折扣后的价格。

五、装饰者模式装饰者模式是一种通过为对象添加新的功能来扩展其功能的设计模式,它不改变对象的结构。

在Java中,装饰者模式常用于对已有的类进行功能扩展或者改造。

比如,对一个已有的文件读写类进行包装,增加加密、压缩等额外功能,而不改变原有类的结构和接口。

Observer模式在Google Guava中的应用

Observer模式在Google Guava中的应用

Observer模式在Google Guava中的应用观察者模式是一种设计模式,它允许一个对象(主题,或者被观察者)维护一组依赖于它的对象(观察者),并自动将任何状态改变通知给它们。

这种模式的优点包括松散耦合,易于扩展,方便维护等。

而Google Guava是一个开源的Java库,它提供了许多实用的工具类和函数式编程模型,其中也包括了观察者模式的实现。

本文将介绍Observer模式在Google Guava中的应用以及相关实现细节,主要包括以下方面:1. 什么是Observer模式?2. Observer模式的应用场景3. 包括Google Guava在内Java中的Observer模式4. Guava中的观察者模式的实现5. Guava EventBus的应用举例## 1. 什么是Observer模式?简单来说,观察者模式指的是当一个对象的状态发生改变时,依赖于它的对象会被自动通知并更新。

这种模式中,观察者对象会注册到主题对象中,主题对象会维护一个观察者列表,当主题对象发生改变时(如改变其状态或数据),主题对象会自动通知它的观察者,观察者们会接收到通知后进行相应的操作。

在Observer模式中,主题对象和观察者对象之间是松散耦合的,主题对象并不知道哪些对象正在观察它,观察者对象也并不知道主题对象具体会如何改变。

这种解耦合的设计使得程序更加容易扩展和维护。

## 2. Observer模式的应用场景Observer模式的应用场景很广,比如:1. GUI事件模型:在GUI中,按钮、滚动条等组件就是典型的主题对象,当用户触发某个事件时,这些组件会自动通知它们的观察者,如监听器、回调等。

2. 订单状态更新:在电商系统中,一个订单状态的改变(如支付、发货、收货)会影响多个相关的对象,如仓库库存、财务账户等。

这些对象就可以作为观察者,并在订单状态改变时接收到通知并更新相关信息。

3. WebSocket消息:在WebSocket中,当服务器端有消息需要推送给客户端时,客户端就可以作为观察者,实时接收到消息并进行相应的处理。

系统设计常见的设计模式及其实际应用案例

系统设计常见的设计模式及其实际应用案例

系统设计常见的设计模式及其实际应用案例在软件开发领域,设计模式是一组被广泛应用于解决常见问题的可重复利用的解决方案。

设计模式可以提高代码的可读性、可维护性和可扩展性,使系统更加灵活和可靠。

本文将介绍一些常见的系统设计模式,并提供相应的实际应用案例。

一、单例模式单例模式是一种创建型模式,它保证一个类只有一个实例,并提供一个全局访问点。

单例模式常被用于数据库连接、日志记录器等资源共享的场景。

实际应用案例:Java中的Runtime类就是一个典型的单例模式。

通过调用`Runtime.getRuntime()`方法,可以获取到全局唯一的Runtime实例,从而实现对系统运行时环境的访问。

二、工厂模式工厂模式是一种创建型模式,它定义了一个用于创建对象的接口,但具体的对象创建逻辑由具体的工厂类来实现。

工厂模式能够将对象的创建与使用分离,降低了耦合性。

实际应用案例:在Java中,Calendar类就是通过工厂模式来创建日期对象的。

通过调用`Calendar.getInstance()`方法,可以根据当前系统的时区和语言环境,返回一个具体实现的Calendar对象。

三、观察者模式观察者模式是一种行为型模式,它定义了一种一对多的依赖关系,使得当一个对象状态发生变化时,其依赖对象能够自动收到通知并进行相应的更新。

实际应用案例:Android中的广播机制就是观察者模式的实际应用。

当一个广播消息被发送时,所有注册了相应广播接收器的组件都能够接收到并做出响应。

四、策略模式策略模式是一种行为型模式,它定义了一系列可相互替换的算法,并将每个算法封装在独立的类中。

通过切换不同的策略对象,可以在运行时改变系统的行为。

实际应用案例:在电商系统中,用户下单时可以选择不同的支付方式,比如支付宝、微信、银行卡等。

这些不同的支付方式就可以使用策略模式来实现。

五、装饰者模式装饰者模式是一种结构型模式,它允许动态地为对象添加额外的功能,同时又不改变其原有的结构。

观察者设计模式的应用

观察者设计模式的应用

观察者设计模式的应用观察者设计模式是一种常用的软件设计模式,它用于在对象之间建立一种一对多的依赖关系,当一个对象的状态发生改变时,其相关依赖对象会自动得到通知并更新。

这种模式能够实现对象之间的解耦,提高代码的可复用性和可扩展性。

在观察者设计模式中,通常包含两个角色:被观察者(Subject)和观察者(Observer)。

被观察者是一个抽象类或接口,定义了添加、删除和通知观察者的方法。

观察者则是一个接口或抽象类,定义了接收通知并进行相应操作的方法。

具体的被观察者和观察者类可以根据具体需求进行扩展。

观察者设计模式的应用场景非常广泛。

下面通过几个实际示例来说明其应用。

1. 股票市场示例:假设有一个股票市场系统,其中包括多个股票交易者作为观察者,股市行情作为被观察者。

当股市行情发生变化时,被观察者会通知所有观察者进行相应的交易操作。

这种情况下,观察者设计模式可以很好地实现股票交易者与股市行情之间的解耦,使得交易者可以根据自己的需求进行相应的操作。

2. 消息推送系统示例:假设有一个消息推送系统,其中包括多个用户作为观察者,消息发布者作为被观察者。

当有新的消息发布时,被观察者会通知所有观察者进行消息接收和处理。

这种情况下,观察者设计模式可以很好地实现消息发布者与用户之间的解耦,使得用户可以根据自己的需求接收和处理感兴趣的消息。

3. 游戏中的任务系统示例:在游戏中,通常会有多种任务需要完成,玩家可以根据自己的兴趣选择不同的任务进行完成。

这种情况下,任务系统可以作为被观察者,玩家可以作为观察者。

当任务状态发生变化时,被观察者会通知所有观察者进行相应的操作,如更新任务进度、显示任务奖励等。

观察者设计模式可以很好地实现任务系统与玩家之间的解耦,使得玩家可以根据自己的兴趣进行任务的选择和完成。

观察者设计模式的优点在于可以实现对象之间的解耦,降低系统的耦合度。

被观察者只需要知道观察者的接口,而不需要知道具体的观察者实现。

java 面向对象的常用设计模式

java 面向对象的常用设计模式

java 面向对象的常用设计模式java 面向对象的常用设计模式有:1、观察者模式观察者模式又称为发布-订阅模式,定义了对象之间一对多依赖关系,当目标对象(被观察者)的状态发生改变时,它的所有依赖者(观察者)都会收到通知。

2、抽象工厂模式抽象工厂模式主要用于创建相关对象的家族。

当一个产品族中需要被设计在一起工作时,通过抽象工厂模式,能够保证客户端始终只使用同一个产品族中的对象;并且通过隔离具体类的生成,使得客户端不需要明确指定具体生成类;所有的具体工厂都实现了抽象工厂中定义的公共接口,因此只需要改变具体工厂的实例,就可以在某种程度上改变整个软件系统的行为。

3、单例设计模式单例设计模式可以确保系统中某个类只有一个实例,该类自行实例化并向整个系统提供这个实例的公共访问点,除了该公共访问点,不能通过其他途径访问该实例。

4、策略模式将类中经常改变或者可能改变的部分提取为作为一个抽象策略接口类,然后在类中包含这个对象的实例,这样类实例在运行时就可以随意调用实现了这个接口的类的行为。

比如定义一系列的算法,把每一个算法封装起来,并且使它们可相互替换,使得算法可独立于使用它的客户而变化,这就是策略模式。

5、适配器模式适配器模式主要用于将一个类或者接口转化成客户端希望的格式,使得原本不兼容的类可以在一起工作,将目标类和适配者类解耦;同时也符合“开闭原则”,可以在不修改原代码的基础上增加新的适配器类;将具体的实现封装在适配者类中,对于客户端类来说是透明的,而且提高了适配者的复用性,但是缺点在于更换适配器的实现过程比较复杂。

6、命令模式命令模式的本质是将请求封装成对象,将发出命令与执行命令的责任分开,命令的发送者和接收者完全解耦,发送者只需知道如何发送命令,不需要关心命令是如何实现的,甚至是否执行成功都不需要理会。

命令模式的关键在于引入了抽象命令接口,发送者针对抽象命令接口编程,只有实现了抽象命令接口的具体命令才能与接收者相关联。

设计模式——观察者模式

设计模式——观察者模式
}
2. 定义两个观察者,警察A 警察 B
public class PoliceA implements Observer { /**
* 产生反应 * * @param o 源、即被观察者 * @param arg event事件 */ @Override public void update(Observable o, Object arg) {
} } }
3. 测试
public static void main(String[] args) { BadMan badMan = new BadMan(); badMan.addObserver(new PoliceA()); badMan.addObserver(new PoliceB()); badMan.playAction(); badMan.runAction();
}
3. 定义枚举事件类型
public enum Event { //玩 PLAY(1), //逃跑 RUN(2);
Integer index; /** * 构造 * * @param index */ Event(Integer index) {
this.index = index; }
public Integer getIndex() { return this.index;
public interface Observable {
/** * 注册/添加观察者 * * @param observer 观察者 */ public void addObserver(Observer observer);
/** * 移动观察者 * * @param observer 观察者 */ public void removeObserver(Observer observer);

观察者(Observer)模式

观察者(Observer)模式

C o nc re te S ub je c t p ric e : flo a t C o nc re te S ub je c t() g etN a m e () g etP ric e () s e tN a m e () s e tP ric e ()
N a m e O b s e rve r N a m e O b s e rve r() up d a te () o p na m e ()
< <Inter fac e >> O b s er ve r ( fro m util) up da te()
使用java.util.Observer
T e s tO b s er ve rs m a in() O b s e rva b le () a d d O b s e rve r() d e le te O b s e rve r() no ti fyO b s e rve rs () no ti fyO b s e rve rs () d e le te O b s e rve rs () s e tC ha ng e d () c le a rC ha ng e d () ha s C ha ng e d () c o untO b s e rve rs () O b s e rva b le (fro m util) < < Inte rfa c e > > O b s e rve r (fro m uti l) up d a te ()
两个Concrete Observer的具体实现 public class DigitObserver implements Observer { public void update(NumberGenerator generator) { System.out.println("DigitObserver:" + generator.getNumber()); try { Thread.sleep(100); } catch (InterruptedException e) { } }} public class GraphObserver implements Observer { public void update(NumberGenerator generator) { System.out.print("GraphObserver:"); int count = generator.getNumber(); for (int i = 0; i < count; i++) { System.out.print("*"); } System.out.println(""); try { Thread.sleep(100); } catch (InterruptedException e) { } }}

《观察者模式》课件

《观察者模式》课件
观察者通常具有更新状态的方法,该 方法在接收到主题的通知时被调用。
注册与注销
注册
观察者通过调用主题的注册方法将自己注册到主题中,以便在主题状态发生变 化时接收通知。
注销
观察者可以通过调用主题的注销方法将自己从主题中注销,以停止接收通知。
通知机制
当主题的状态发生变化时,主题会调用其通知方法,将当前 状态传递给所有注册的观察者。
02
观察者模式的核心概念
主题(Subject)
01
主题负责维护一个或多个观察者 对象的引用,当主题的状态发生 变化时,通知所有注册的观察者 。
02
主题通常具有注册和注销观察者 的方法,以及一个用于通知所有 注册观察者的方法。
观察者(Observer)
观察者负责实现更新操作,当主题的 状态发生变化时,观察者会收到通知 并执行相应的更新操作。
C#中的观察者模式实现
• void Update(int data);
C#中的观察者模式实现
01
}
02
public class Publisher {
03
private int _data;
C#中的观察者模式实现
private List<IObserver> _observers = new List<IObserver>();
在事件驱动架构中,观察者模式可以用于监听特定事件的发生,并触发相应的处 理流程。当事件发生时,系统会自动调用相关处理函数或执行相关操作,实现事 件处理和流程的自动化,提高系统的响应速度和灵活性。
06
总结与展望
观察者模式的总结
观察者模式的主要优点在于能够实现发布/订阅模型 ,使得多个观察者可以同时监听一个主题,提高了系 统的可扩展性和可维护性。

观察者模式应用场景

观察者模式应用场景

观察者模式应用场景
观察者模式是行为型设计模式的一种,它可以被用来在两个对象之间
创建一种观察者的关系,当一方的状态发生变化时,另一方会受到通知。

观察者模式能够帮助开发人员在不同的对象之间创建一种有效的
关系,开发人员可以轻松实现这一点,而不需要修改任何已有的类。

应用场景可以分为以下几种:
1、消息服务器系统:在这种场景中,消息服务器作为主题,当消息服
务器上的消息状态发生变化时,订阅者将收到通知。

例如,某个社交
网站的用户可以订阅另一个用户的更新,当另一个用户发布新消息时,订阅者将收到通知。

2、社交媒体平台:在这种场景中,一些社交媒体平台如微博或推特也
采用了观察者模式,当某位社交媒体用户发表新消息时,所有关注她/
他的账号都能收到通知。

3、邮件系统:当用户发送新邮件时,该用户的所有订阅者都能收到新
邮件的通知。

4、图形界面应用程序:在某些图形界面应用程序中,当状态发生变化时,所有已注册的控件都能收到通知。

5、游戏:游戏也可以使用观察者模式,例如,当游戏角色的位置发生
变化时,所有观察者(例如地图)都能收到通知,从而更新图形显示。

此外,观察者模式还可以用于实现团队协作,例如在团队项目中,当
项目状态发生变化时,所有团队成员都能收到通知,从而提高工作效率。

总的来看,观察者模式的应用场景非常广泛,它可以在消息服务器系统、社交媒体平台、邮件系统、图形界面应用程序以及游戏等场景中得到应用。

它可以帮助开发人员在不同的对象之间创建一种有效的关系,从而更加有效地开发出高质量的软件。

数据校验逻辑 java设计模式

数据校验逻辑 java设计模式

数据校验逻辑通常用于验证用户输入的数据是否符合特定的规则或标准。

在Java中,可以使用设计模式来提高代码的可维护性和可复用性。

以下是一些常见的设计模式,可以在数据校验逻辑中应用:
1. 策略模式(Strategy Pattern):策略模式允许根据不同的验证规则动态切换算法。

可以
将不同的验证规则封装为不同的策略类,然后在运行时根据需要选择合适的策略进行数据验证。

2. 访问者模式(Visitor Pattern):访问者模式可以将算法操作与对象结构分离,使得添加
新的验证操作变得容易。

通过定义一个访问者接口,可以添加新的验证逻辑而无需修改已有的类结构。

3. 观察者模式(Observer Pattern):观察者模式允许一个对象(被观察者)自动通知其依
赖对象(观察者)任何状态变更。

在数据校验逻辑中,可以将验证结果作为被观察者的状态变更通知给观察者,以便进行后续处理。

4. 模板方法模式(Template Method Pattern):模板方法模式允许定义一个操作中的算法
骨架,将某些步骤延迟到子类中实现。

在数据校验逻辑中,可以定义一个模板方法,规定数据验证的基本流程,然后由子类实现具体的验证逻辑。

这些设计模式可以帮助您更好地组织代码,提高代码的可维护性和可扩展性。

根据具体的需求和场景,可以选择适合的设计模式来设计数据校验逻辑。

Java中常用的设计模式介绍与应用场景

Java中常用的设计模式介绍与应用场景

Java中常用的设计模式介绍与应用场景设计模式是软件开发中常用的一种解决问题的方法论,它提供了一套经过验证的解决方案,可以帮助开发人员更好地组织和管理代码。

在Java开发中,有许多常用的设计模式,每种设计模式都有自己的特点和适用场景。

本文将介绍几种常用的设计模式以及它们的应用场景。

1. 单例模式单例模式是一种创建型设计模式,它确保一个类只有一个实例,并提供一个全局访问点。

在Java中,单例模式可以通过私有化构造方法、提供一个静态方法获取实例来实现。

单例模式适用于需要全局唯一实例的场景,比如数据库连接池、线程池等。

2. 工厂模式工厂模式是一种创建型设计模式,它提供了一个统一的接口来创建对象,而不需要暴露对象的创建逻辑。

在Java中,工厂模式可以通过一个工厂类来创建对象。

工厂模式适用于需要根据不同的条件创建不同类型对象的场景,比如数据库驱动管理器根据不同的数据库类型创建不同的数据库连接对象。

3. 观察者模式观察者模式是一种行为型设计模式,它定义了一种一对多的依赖关系,当一个对象的状态发生变化时,它的所有依赖对象都会收到通知并自动更新。

在Java中,观察者模式可以通过使用Java提供的Observer和Observable接口来实现。

观察者模式适用于需要实现对象之间的解耦和事件通知的场景,比如GUI界面中的事件处理。

4. 适配器模式适配器模式是一种结构型设计模式,它将一个类的接口转换成客户端所期望的另一个接口。

适配器模式可以解决接口不兼容的问题。

在Java中,适配器模式可以通过继承或者组合来实现。

适配器模式适用于需要将一个类的接口转换成另一个类的接口的场景,比如将一个第三方库的接口适配成自己的接口。

5. 策略模式策略模式是一种行为型设计模式,它定义了一系列算法,并将每个算法封装起来,使它们可以互相替换。

在Java中,策略模式可以通过使用接口和多态来实现。

策略模式适用于需要在运行时根据不同的条件选择不同的算法的场景,比如排序算法。

设计模式之观察者模式(Observer)详解及代码示例

设计模式之观察者模式(Observer)详解及代码示例

设计模式之观察者模式(Observer)详解及代码⽰例⼀、模式的定义与特点 观察者(Observer)模式的定义:观察者模式⼜被称为发布-订阅/模型-视图模式,属于⾏为型设计模式的⼀种,是⼀个在项⽬中经常使⽤的模式。

指多个对象间存在⼀对多的依赖关系,当⼀个对象的状态发⽣改变时,所有依赖于它的对象都得到通知并被⾃动更新。

⼆、观察者模式优缺点 观察者模式是⼀种对象⾏为型模式,其主要优点如下:降低了⽬标与观察者之间的耦合关系,两者之间是抽象耦合关系。

⽬标与观察者之间建⽴了⼀套触发机制。

它的主要缺点如下:⽬标与观察者之间的依赖关系并没有完全解除,⽽且有可能出现循环引⽤。

当观察者对象很多时,通知的发布会花费很多时间,影响程序的效率。

三、观察者模式的实现 实现观察者模式时要注意具体⽬标对象和具体观察者对象之间不能直接调⽤,否则将使两者之间紧密耦合起来,这违反了⾯向对象的设计原则。

观察者模式的主要⾓⾊如下。

抽象主题(Subject)⾓⾊:也叫抽象⽬标类,它提供了⼀个⽤于保存观察者对象的聚集类和增加、删除观察者对象的⽅法,以及通知所有观察者的抽象⽅法。

具体主题(Concrete Subject)⾓⾊:也叫具体⽬标类,它实现抽象⽬标中的通知⽅法,当具体主题的内部状态发⽣改变时,通知所有注册过的观察者对象。

抽象观察者(Observer)⾓⾊:它是⼀个抽象类或接⼝,它包含了⼀个更新⾃⼰的抽象⽅法,当接到具体主题的更改通知时被调⽤。

具体观察者(Concrete Observer)⾓⾊:实现抽象观察者中定义的抽象⽅法,以便在得到⽬标的更改通知时更新⾃⾝的状态。

观察者模式的结构图如图所⽰: 代码如下:public class ObserverPattern{public static void main(String[] args){Subject subject=new ConcreteSubject();Observer obs1=new ConcreteObserver1();Observer obs2=new ConcreteObserver2();subject.add(obs1);subject.add(obs2);subject.notifyObserver();}}//抽象⽬标abstract class Subject{protected List<Observer> observers=new ArrayList<Observer>();//增加观察者⽅法public void add(Observer observer){observers.add(observer);}//删除观察者⽅法public void remove(Observer observer){observers.remove(observer);}public abstract void notifyObserver(); //通知观察者⽅法}//具体⽬标class ConcreteSubject extends Subject{public void notifyObserver(){System.out.println("具体⽬标发⽣改变...");System.out.println("--------------");for(Object obs:observers){((Observer)obs).response();}}}//抽象观察者interface Observer{void response(); //反应}//具体观察者1class ConcreteObserver1 implements Observer{public void response(){System.out.println("具体观察者1作出反应!");}}//具体观察者1class ConcreteObserver2 implements Observer{public void response(){System.out.println("具体观察者2作出反应!");}} 测试结果为:具体⽬标发⽣改变...--------------具体观察者1作出反应!具体观察者2作出反应!四、观察者模式的应⽤实例 接下来再看⼀个关于上下课打铃,⽼师同学上下课的⽰例:public class BellEventTest{public static void main(String[] args){BellEventSource bell=new BellEventSource(); //铃(事件源)bell.addPersonListener(new TeachEventListener()); //注册监听器(⽼师) bell.addPersonListener(new StuEventListener()); //注册监听器(学⽣)bell.ring(true); //打上课铃声System.out.println("------------");bell.ring(false); //打下课铃声}}//铃声事件类:⽤于封装事件源及⼀些与事件相关的参数// EventObject: The root class from which all event state objects shall be derived. class RingEvent extends EventObject{private static final long serialVersionUID=1L;private boolean sound; //true表⽰上课铃声,false表⽰下课铃声public RingEvent(Object source,boolean sound){super(source);this.sound=sound;}public void setSound(boolean sound){this.sound=sound;}public boolean getSound(){return this.sound;}}//⽬标类:事件源,铃class BellEventSource{private List<BellEventListener> listener; //监听器容器public BellEventSource(){listener=new ArrayList<BellEventListener>();}//给事件源绑定监听器public void addPersonListener(BellEventListener ren){listener.add(ren);}//事件触发器:敲钟,当铃声sound的值发⽣变化时,触发事件。

Java中的设计模式及其应用示例

Java中的设计模式及其应用示例

Java中的设计模式及其应用示例设计模式是软件开发中常用的解决问题的方法论,它可以提供一套经过验证的解决方案,帮助开发人员在面对各种情况时更加灵活和高效地进行代码编写。

在Java中,有许多常见的设计模式,本文将介绍一些常用的设计模式,并提供相应的应用示例。

一、单例模式(Singleton Pattern)单例模式是一种保证一个类只会被实例化一次的设计模式。

在Java 中,单例模式通常使用一个私有的构造方法,一个私有的静态变量,以及一个公有的静态方法来实现。

示例代码:```javapublic class Singleton {private static Singleton instance;private Singleton() { }public static Singleton getInstance() {if (instance == null) {instance = new Singleton();}return instance;}}```二、工厂模式(Factory Pattern)工厂模式是一种创建对象的设计模式,它通过定义一个创建对象的工厂类来封装对象实例化的过程。

在Java中,工厂模式通常使用一个工厂类和一个抽象的产品类来实现。

示例代码:```javapublic abstract class Shape {public abstract void draw();}public class Circle extends Shape {@Overridepublic void draw() {System.out.println("Circle");}}public class Square extends Shape {@Overridepublic void draw() {System.out.println("Square");}}public class ShapeFactory {public Shape getShape(String shapeType) {if (shapeType == null) {return null;}if (shapeType.equalsIgnoreCase("CIRCLE")) {return new Circle();} else if (shapeType.equalsIgnoreCase("SQUARE")) { return new Square();}return null;}}```三、观察者模式(Observer Pattern)观察者模式是一种对象间一对多的依赖关系,当一个对象状态发生改变时,它的所有依赖对象都会收到通知并自动更新。

观察者模式例子

观察者模式例子

观察者模式例子观察者模式是一种设计模式,它允许对象实例之间进行松耦合的通信。

在这种模式中,一个对象(称为主题或可观察对象)维护一组观察者。

当主题状态发生变化时,它会通知所有观察者。

观察者模式可以帮助我们构建可扩展的代码,因为它允许我们添加新的观察者对象,而无需修改已有的代码。

在这篇文章中,我们将介绍一个简单的例子来说明如何使用观察者模式。

假设我们正在编写一个天气应用程序。

我们的应用程序需要能够在温度、湿度和气压发生变化时向用户发送通知。

我们可以使用观察者模式来实现这个功能。

首先,我们需要定义主题接口和观察者接口。

主题接口应该有三个方法:注册观察者、移除观察者和通知观察者。

观察者接口应该有一个方法,用于接收主题发来的通知。

代码如下所示:```public interface Subject {public void registerObserver(Observer o);public void removeObserver(Observer o);public void notifyObservers();}public interface Observer {public void update(float temperature, float humidity, float pressure);}```下一步,我们需要实现主题和观察者。

我们的天气应用程序只有一个主题(天气数据),但是可以有多个观察者(例如,手机应用、网站、电视等)。

我们需要定义一个具体的主题类来实现Subject接口,并在其中实现注册观察者、移除观察者和通知观察者的方法。

```import java.util.ArrayList;public class WeatherData implements Subject {private ArrayList<Observer> observers;private float temperature;private float humidity;private float pressure;public WeatherData() {observers = new ArrayList<Observer>();}public void registerObserver(Observer o) {observers.add(o);}public void removeObserver(Observer o) {int i = observers.indexOf(o);if (i >= 0) {observers.remove(i);}}public void notifyObservers() {for (int i = 0; i < observers.size(); i++) {Observer observer = (Observer)observers.get(i); observer.update(temperature, humidity, pressure); }}public void measurementsChanged() {notifyObservers();}public void setMeasurements(float temperature, float humidity, float pressure) {this.temperature = temperature;this.humidity = humidity;this.pressure = pressure;measurementsChanged();}}```我们还需要创建一个具体的观察者类,例如,用于显示天气数据的手机应用。

rjava subscribe方法 解读

rjava subscribe方法 解读

Java是一种广泛使用的编程语言,其类库中提供了丰富的API供开发人员使用。

在Java的类库中,有一个叫做Subscribe的方法,它是在观察者模式中非常重要的一部分。

观察者模式是一种对象行为型设计模式,用于一对多的依赖关系的处理。

在这篇文章中,我们将对Java 中Subscribe方法及其在观察者模式中的应用进行解读。

一、Subscribe方法的定义1. Subscribe方法是在Guava EventBus中定义的,它用于注册事件订阅者。

在EventBus中,事件订阅者可以通过Subscribe方法来声明自己对哪些事件感兴趣,并为这些事件注册相应的处理方法。

二、Subscribe方法的用法2. 通过使用@Subscribe注解,可以将一个普通的方法变成一个事件处理方法。

当事件发生时,EventBus会自动调用被@Subscribe注解的方法,并将事件作为参数传入。

3. 示例代码如下:```java@Subscribepublic void handleEvent(Event event) {//处理事件的逻辑}```在上述代码中,handleEvent方法通过@Subscribe注解声明自己对Event事件感兴趣,并定义了处理逻辑。

三、Subscribe方法的原理4. Subscribe方法的核心原理是利用反射来实现事件订阅。

当使用@Subscribe注解的方法被注册到EventBus中时,EventBus会使用反射来获取其方法签名,并将其存储在内部的事件处理器列表中。

5. 当事件发生时,EventBus会遍历事件处理器列表,找到与事件类型匹配的处理方法,并调用该方法来处理事件。

四、Subscribe方法在观察者模式中的应用6. 观察者模式是一种常用的设计模式,用于处理一对多的依赖关系。

在观察者模式中,Subject(主题)维护一组观察者,当主题发生变化时,会通知所有观察者。

7. 在Java中,Subscribe方法可以很好地支持观察者模式的实现。

Java中使用Observer接口和Observable类实践Observer观察者模式

Java中使用Observer接口和Observable类实践Observer观察者模式

Java中使⽤Observer接⼝和Observable类实践Observer观察者模式在Java中通过Observable类和Observer接⼝实现了观察者模式。

实现Observer接⼝的对象是观察者,继承Observable的对象是被观察者。

1. 实现观察者模式实现观察者模式⾮常简单,[1]创建被观察者类,它继承⾃java.util.Observable类;[2]创建观察者类,它实现java.util.Observer接⼝;[3]对于被观察者类,添加它的观察者:void addObserver(Observer o)addObserver()⽅法把观察者对象添加到观察者对象列表中。

当被观察事件发⽣时,执⾏:setChanged();notifyObservers();setChanged()⽅法⽤来设置⼀个内部标志位注明数据发⽣了变化;notifyObservers()⽅法会去调⽤观察者对象列表中所有的Observer的update()⽅法,通知它们数据发⽣了变化。

只有在setChange()被调⽤后,notifyObservers()才会去调⽤update()。

[4]对于观察者类,实现Observer接⼝的唯⼀⽅法updatevoid update(Observable o, Object arg)形参Object arg,对应⼀个由notifyObservers(Object arg);传递来的参数,当执⾏的是notifyObservers();时,arg为null。

下⾯给出⼀个简单的⽰例:package designpattern_observer;import java.util.Observable;public class MyButtonObserable extends Observable {private String clickMode;public String getClickMode() {return clickMode;}public void setClickMode(String clickMode) {this.clickMode = clickMode;this.setChanged();this.notifyObservers(clickMode);}}package designpattern_observer;import java.util.Observable;import java.util.Observer;public class MyTextBoxAbserver implements Observer {@Overridepublic void update(Observable o, Object arg) {if (arg.toString().equals("double clicked")) {System.out.println("你对按钮执⾏了双击操作.");}}}Test类:package designpattern_observer;public class ObserverTest {public static void main(String[] args) {MyButtonObserable button = new MyButtonObserable();MyTextBoxAbserver textbox = new MyTextBoxAbserver();button.addObserver(textbox);button.setClickMode("double clicked");}}执⾏⼊⼝函数,调⽤ button.setClickMode("double clicked"),则触发MyTextBoxAbserver 对象的update⽅法,打印输出:你对按钮执⾏了双击操作.。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
public String getBuyerId() { return buyerId; } public void setBuyerId(String buyerId) { this.buyerId = buyerId; } public String getEmail() { return email; } public void setEmail(String email) { this.email = email; } //该方法会被“被观察者的父类”既 Observable 调用 public void update(Observable o, Object arg) { //这里做具体发电子邮件的操作 Book b = (Book)arg; System.out.println("给顾客的发电子邮件:"+b.getName()+"降价了,目前价格为:"+b.getPrice()); } }
}
下面是观察者对象,表示顾客的电子邮件,它实现了 Observer 接口。 import java.util.Observable; import java.util.Observer; public class BuyerEmail implements Observer {
private String buyerId = ""; private String email = "";
BuyerEmail be = new BuyerEmail(); be.setBuyerId("001"); be.setEmail("dobodo@");
//增加观察者,在实际应用中就是那些人对该书做了关注 b1.addObserver(bm); b1.addObserver(be);
public String getBuyerId() { return buyerId; } public void setBuyerId(String buyerId) { this.buyerId = buyerId; } public String getMobileNo() { return mobileNo; } public void setMobileNo(String mobileNo) { this.mobileNo = mobileNo; } public void update(Observable o, Object arg) {
public double getPrice() { return price; } public void setPrice(double price) { this.price = price; } //当书的价格修改时调用该方法 public void modifyPrice(Book b) { //调用父类的方法,改变被观察者的状态 setChanged(); //通知客户该书已降价 notifyObservers(b); }
下面我们再看一下观察者的接口 java.util.Observer
package java.util; public interface Observer {
void upபைடு நூலகம்ate(Observable o, Object arg); }
接口中就只有一个方法,update,方法中有两个参数,Observable 和一个 object, 第一个参数就是被观察的对象,而第二个参数就得看业务需求了,需要什么就传进去什 么。我们自己的观察者类必须实现这个方法,这样在被观察者调用 notifyObservers 操 作时被观察者所持有的所有观察者都会执行 update 操作了.
public void notifyObservers(Object arg) { Object[] arrLocal; synchronized (this) { if (!changed) return; arrLocal = obs.toArray(); clearChanged(); } for (int i = arrLocal.length-1; i>=0; i--) ((Observer)arrLocal[i]).update(this, arg); }
public synchronized void deleteObservers() { obs.removeAllElements(); }
protected synchronized void setChanged() { changed = true; }
protected synchronized void clearChanged() { changed = false; }
//创建被观察者时就创建一个它持有的观察者列表,注意,这个列表是需要同步的。 public Observable() { obs = new Vector(); } /** * 添加观察者到观察者列表中去 */ public synchronized void addObserver(Observer o) { if (o == null) throw new NullPointerException(); if (!obs.contains(o)) { obs.addElement(o); } } /** * 删除一个观察者 */
一、 概述
Java 的设计模式很多,观察者模式被称为是模式中的皇后,而且 Java jdk 也对它 做了实现,可见该设计模式的重要位置。在图形化设计的软件中,为了实现视图和事件 处理的分离,大多都采用了 Observer 模式,比如 Java 的 Swing,Flex 的 ActionScript 等。在现实的应用系统中也有好多应用,比如像当当网、京东商城一类的电子商务网站, 如果你对某件商品比较关注,可以放到收藏架,那么当该商品降价时,系统给您发送手 机短信或邮件。这就是观察者模式的一个典型应用,商品是被观察者,有的叫主体;关 注该商品的客户就是观察者。下面的一个事例将模拟这个应用。
b1.modifyPrice(b1); } }
输出: 给顾客的发电子邮件:<<Java 设计模式>>降价了,目前价格为:45.0 给顾客的发手机短信:<<Java 设计模式>>降价了,目前价格为:45.0
不知道上面的例子你看懂了没有,观察者模式实际上没什么高深的东西,就是运用 了 java 的继承和接口,在被观察者的抽象类里设置一个状态标志,通过该标志判断是 否通知观察者对象。在学习该模式的同时,我们更应该学习 java 的继承和接口的灵活 应用,其实所有的设计模式都是继承、接口、多态的灵活应用。
GoF 说道:Observer 模式的意图是“定义对象间的一种一对多的依赖关系,当一个 对象的状态发生改变时,所有依赖于它的对象都得到通知并被自动更新”。从这段话里 我们可以得到两个信息,如下:
1, 观察者(具体执行操作的对象,有多个) 2, 被观察者(顾名思义是被观察的对象,如果该对象发生某些变化则通知观察者
public static void main(String args[]) { Book b1 = new Book(); b1.setName("<<Java 设计模式>>"); b1.setPrice(45.00);//假设原价是 60,现在是降价促销
//下面的观察者在实际的应用中可以从数据库或文件中读取 BuyerMobileMessage bm = new BuyerMobileMessage(); bm.setBuyerId("001"); bm.setMobileNo("13810500085");
执行对应的操)
二、 jdk 中观察者模式解析
在 java 的 util 包中实现了该设计模式的框架,大部分应用都可以直接用它,当然了 你也可以自己实现它,实际上就是一个被观察者的抽象类和一个观察者接口。我们先看 一下 jdk 是如何实现的。被观察者的抽象类 java.util.Observable
package java.util; public class Observable { private boolean changed = false; private Vector obs;
public synchronized void deleteObserver(Observer o) { obs.removeElement(o); } public void notifyObservers() { notifyObservers(null); } /**
* 通知操作,即被观察者发生变化,通知对应的观察者进行事先设定的操作,这个方法接受一个参数,这个 参数一直传到观察者里,以供观察者使用 */
下面是另一个观察者对象,表示顾客的手机,同样需要继承 Observer 接口 import java.util.Observable; import java.util.Observer; public class BuyerMobileMessage implements Observer {
private String buyerId = ""; private String mobileNo = "";
三、观察者模式应用
下面是一个 book 对象,它是一个被观察者,所以要继承 Observable。
import java.util.Observable; public class Book extends Observable {
private String name = ""; private double price = 0.0; public String getName() { return name; } public void setName(String name) { = name; }
相关文档
最新文档