java观察者模式

2. Java的回调函数和观察者模式的区别

java的回调 叫listener 模式。
无论是listener模式，还是C++里面的callback模式，本质是一样的
他们都是观察者模式的具体实现。

观察者模式是设计模式中定义的一种思想，而具体到不同的语言环境，使用不同的语法表现出来就会有java的listener objc的 delegate，或者C++的 callback。

3. 如何使用Java8实现观察者模式

1、 对一个对象状态的更新，需要其他对象同步更新，而且其他对象的数量动态可变。
2、 对象仅需要将自己的更新通知给其他对象而不需要知道其他对象的细节。
观察者模式的优点：
1、 Subject和Observer之间是松偶合的，分别可以各自独立改变。
2、 Subject在发送广播通知的时候，无须指定具体的Observer，Observer可以自己决定是否要订阅Subject的通知。
3、 遵守大部分GRASP原则和常用设计原则，高内聚、低偶合。

4. java observer模式 怎么设计

在JDK(Java Development Kit)类库中，开发人员使用了大量设计模式，正因为如此，我们可以在不修改JDK源码的前提下开发出自己的应用软件，研究JDK类库中的模式实例也不失为学习如何使用设计模式的一个好方式。

创建型模式：
(1) 抽象工厂模式(Abstract Factory)
• Java.util.Calendar#getInstance()
• java.util.Arrays#asList()
• java.util.ResourceBundle#getBundle()
• java.NET.URL#openConnection()
• java.sql.DriverManager#getConnection()
• java.sql.Connection#createStatement()
• java.sql.Statement#executeQuery()
• java.text.NumberFormat#getInstance()
• java.lang.management.ManagementFactory (所有getXXX()方法)
• java.nio.charset.Charset#forName()
• javax.xml.parsers.DocumentBuilderFactory#newInstance()
• javax.xml.transform.TransformerFactory#newInstance()
• javax.xml.xpath.XPathFactory#newInstance()

(2) 建造者模式(Builder)
• java.lang.StringBuilder#append()
• java.lang.StringBuffer#append()
• java.nio.ByteBuffer#put() (CharBuffer, ShortBuffer, IntBuffer,LongBuffer, FloatBuffer 和DoubleBuffer与之类似)
• javax.swing.GroupLayout.Group#addComponent()
• java.sql.PreparedStatement
• java.lang.Appendable的所有实现类
(3) 工厂方法模式(Factory Method)
• java.lang.Object#toString() (在其子类中可以覆盖该方法)
• java.lang.Class#newInstance()
• java.lang.Integer#valueOf(String) (Boolean, Byte, Character,Short, Long, Float 和 Double与之类似)
• java.lang.Class#forName()
• java.lang.reflect.Array#newInstance()
• java.lang.reflect.Constructor#newInstance()
(4) 原型模式(Prototype)
• java.lang.Object#clone() (支持浅克隆的类必须实现java.lang.Cloneable接口)
(5) 单例模式 (Singleton)
• java.lang.Runtime#getRuntime()
• java.awt.Desktop#getDesktop()

结构型模式：
(1) 适配器模式(Adapter)
•java.util.Arrays#asList()
•javax.swing.JTable(TableModel)
•java.io.InputStreamReader(InputStream)
•java.io.OutputStreamWriter(OutputStream)
•javax.xml.bind.annotation.adapters.XmlAdapter#marshal()
•javax.xml.bind.annotation.adapters.XmlAdapter#unmarshal()

(2) 桥接模式(Bridge)
• AWT (提供了抽象层映射于实际的操作系统)
•JDBC

(3) 组合模式(Composite)
•javax.swing.JComponent#add(Component)
•java.awt.Container#add(Component)
•java.util.Map#putAll(Map)
•java.util.List#addAll(Collection)
•java.util.Set#addAll(Collection)

(4) 装饰模式(Decorator)
•java.io.BufferedInputStream(InputStream)
•java.io.DataInputStream(InputStream)
•java.io.BufferedOutputStream(OutputStream)
•java.util.zip.ZipOutputStream(OutputStream)
•java.util.Collections#checked[List|Map|Set|SortedSet|SortedMap]()

(5) 外观模式(Facade)
•java.lang.Class
•javax.faces.webapp.FacesServlet

(6) 享元模式(Flyweight)
•java.lang.Integer#valueOf(int)
•java.lang.Boolean#valueOf(boolean)
• java.lang.Byte#valueOf(byte)
•java.lang.Character#valueOf(char)
(7) 代理模式(Proxy)
• java.lang.reflect.Proxy
•java.rmi.*

行为型模式：
(1) 职责链模式(Chain of Responsibility)
•java.util.logging.Logger#log()
•javax.servlet.Filter#doFilter()

(2) 命令模式(Command)
• java.lang.Runnable
• javax.swing.Action
(3) 解释器模式(Interpreter)
• java.util.Pattern
• java.text.Normalizer
• java.text.Format
• javax.el.ELResolver
(4) 迭代器模式(Iterator)
• java.util.Iterator
• java.util.Enumeration
(5) 中介者模式(Mediator)
• java.util.Timer (所有scheleXXX()方法)
• java.util.concurrent.Executor#execute()
• java.util.concurrent.ExecutorService (invokeXXX()和submit()方法)
• java.util.concurrent.ScheledExecutorService (所有scheleXXX()方法)
•java.lang.reflect.Method#invoke()
(6) 备忘录模式(Memento)
•java.util.Date
•java.io.Serializable
•javax.faces.component.StateHolder
(7) 观察者模式(Observer)
•java.util.Observer/java.util.Observable
•java.util.EventListener (所有子类)
•javax.servlet.http.HttpSessionBindingListener
•javax.servlet.http.HttpSessionAttributeListener
•javax.faces.event.PhaseListener
(8) 状态模式(State)
•java.util.Iterator
•javax.faces.lifecycle.LifeCycle#execute()
(9) 策略模式(Strategy)
• java.util.Comparator#compare()
• javax.servlet.http.HttpServlet
• javax.servlet.Filter#doFilter()

(10) 模板方法模式(Template Method)
•java.io.InputStream, java.io.OutputStream, java.io.Reader和java.io.Writer的所有非抽象方法
•java.util.AbstractList, java.util.AbstractSet和java.util.AbstractMap的所有非抽象方法
•javax.servlet.http.HttpServlet#doXXX()

(11) 访问者模式(Visitor)
•javax.lang.model.element.AnnotationValue和AnnotationValueVisitor
•javax.lang.model.element.Element和ElementVisitor
•javax.lang.model.type.TypeMirror和TypeVisitor

5. Java常用的几种设计模式

下面给你介绍5种设计模式：

1.单例设计模式

所谓单例设计模式简单说就是无论程序如何运行，采用单例设计模式的类（Singleton类）永远只会有一个实例化对象产生。具体实现步骤如下：

(1) 将采用单例设计模式的类的构造方法私有化（采用private修饰）。

(2) 在其内部产生该类的实例化对象，并将其封装成private static类型。

(3) 定义一个静态方法返回该类的实例。

2.工厂设计模式

程序在接口和子类之间加入了一个过渡端，通过此过渡端可以动态取得实现了共同接口的子类实例化对象。

3.代理设计模式

指由一个代理主题来操作真实主题，真实主题执行具体的业务操作，而代理主题负责其他相关业务的处理。比如生活中的通过代理访问网络，客户通过网络代理连接网络（具体业务），由代理服务器完成用户权限和访问限制等与上网相关的其他操作（相关业务）。

4.观察者设计模式

所谓观察者模式，举个例子现在许多购房者都密切观察者房价的变化，当房价变化时，所有购房者都能观察到，以上的购房者属于观察者，这便是观察者模式。

java中可以借助Observable类和Observer接口轻松实现以上功能。当然此种模式的实现也不仅仅局限于采用这两个类。

5.适配器模式

如果一个类要实现一个具有很多抽象方法的接口，但是本身只需要实现接口中的部分方法便可以达成目的，所以此时就需要一个中间的过渡类，但此过渡类又不希望直接使用，所以将此类定义为抽象类最为合适，再让以后的子类直接继承该抽象类便可选择性的覆写所需要的方法，而此抽象类便是适配器类。

6. java中什么叫"观察者设计模式"

才开始学习Java没有多久，看过了不少基础类的书籍，正尝试着做一些基础性的项目来整合零散的知识点。偶然之下在网上查资料时看到别人文章里提及"观察者设计模式"，突然很诧异，没有听说过这种模式呢~故而在网上搜集了一些资料又在图书馆找了一下相关书籍来学习。突然觉得也来学学他人，做做笔记吧~例如:现在很多的购房者都在关注房子的价格变化，每当房子价格变化时，所有 购房者都可以观察得到，实际上以上的购房者都属于观察者，他们都在关注着房子的价格。。其实这就叫观察者设计模式。由java.util包中提供的Observable类和Observer接口便可以轻松实现观察者模式，需要被观察的类必须继承Observable类。Observable类的常用方法有：public void addObserver(Observer o) ; public void deleteObserver(Observero); public void update(Observable o,Object arg);protected void setChanged(); //被观察者状态发生改变public void notifyObservers(Object arg) //通知所有观察者状态已改变对观察者模式的第一感觉是，实现此模式应该可以大大简化代码，使相关功能的代码块语义更清晰. 具体还得在以后应用中慢慢体悟下附一个观察者模式的实现：package org.lxh.demoll.obserdemo;import java.util.Observable;
import java.util.Observer;
class House extends Observable{
private float price;
public House(float price){
this.price = price;
}
public void setPrice(float price){
super.setChanged();
super.notifyObservers(price);
this.price=price;
}
public String toString(){
return "房子价格为：" + this.price;
}
}
class HousePriceObserver implements Observer{
private String name;
public HousePriceObserver(String name){
this.name = name;
}
public void update(Observable obj,Object arg){
if(arg instanceof Float){
System.out.println(this.name+"观察到价格是否更改为：");
System.out.println(((Float) arg).floatValue());
}
}
}
public class ObserDemo01{
public static void main(String[] args){
House h = new House(1000000);
HousePriceObserver hpo1 = new HousePriceObserver("购房者A");
HousePriceObserver hpo2 = new HousePriceObserver("购房者B");
HousePriceObserver hpo3 = new HousePriceObserver("购房者C");
h.addObserver(hpo1);
h.addObserver(hpo2);
h.addObserver(hpo3);
System.out.println(h);
h.setPrice(666666);
System.out.println(h);
}
}

7. java 观察者模式，求一个详细解释。

我觉得你别想的太复杂。

观察者模式需要有一个主题，还有一个或多个观察者。

在主题类中有一个观察者的集合。

当调用主题类的某些方法时，自动循环这个集合，调用观察者的方法。

举个例子：

{
	privateList<Observer>list;
	
	CountSubject(){
		list=newArrayList<Observer>();
	}
	
	@Override
	publicvoidcount(intnum){
		for(inti=0;i<num;i++){
			System.out.println(this.getClass().getName()+"-->"+i);
			this.notifyObserver(i);
		}
	}

	publicvoidaddObserver(Observerobs){
		this.list.add(obs);
	}
	publicbooleanremoveObserver(Observerobs){
		returnthis.list.remove(obs);
	}
	publicvoidremoveAllObservers(){
		this.list.clear();
	}
	
	publicvoidnotifyObserver(inti){
		for(inta=0;a<list.size();a++){
			Observero=list.get(a);
			o.update(i);
		}
	}
}

在客户端调用时，先要初始化一个或多个观察者，然后添加到主题对象。

然后调用主题对象的方法。在主题对象的方法中会自动调用观察者的方法。

8. java web项目中什么时候会用到观察者模式，请举个例子，谢谢。

最普遍的是订阅功能吧，简单的是一些第三方的支付接入或者其他功能接入，他们都暴露一个订阅功能，你可以选择订阅，然后你就作为观察者，每次第三方有更新和通知的时候，所有订阅的人，都能收到更新通知了。
我们有学习小组也 希望一起学习进步 Java框架平台研发 378 437 335 java三大特性 封装、继承、多态

9. 如何使用 Java8 实现观察者模式

你说的场景是符合这个模式的：观察者模式的应用场景：1、对一个对象状态的更新，需要其他对象同步更新，而且其他对象的数量动态可变。2、对象仅需要将自己的更新通知给其他对象而不需要知道其他对象的细节。观察者模式的优点：1、Subject和Observer之间是松偶合的，分别可以各自独立改变。2、Subject在发送广播通知的时候，无须指定具体的Observer，Observer可以自己决定是否要订阅Subject的通知。3、遵守大部分GRASP原则和常用设计原则，高内聚、低偶合。

10. java设计模式 观察者模式 代码

第一个
public interface RandomNumberListener {//接口
public void numberChanged(double d);
}

第二个
public class Consol implements RandomNumberListener{

@Override
public void numberChanged(double d) {
System.out.println(d);
}

}

第三个
public class SwingWindow
extends JFrame
implements RandomNumberListener{//观察者
private JLabel label = new JLabel();
public SwingWindow(){
this.getContentPane().add( label);
this.setSize(300,200);
this.setVisible(true);
}

@Override
public void numberChanged(double d) {
label.setText(String.valueOf(d));
}

}

第四个
public class RandomNumber {//业务
private double r;
private List<RandomNumberListener> listeners = new ArrayList<RandomNumberListener>();

//添加所有观察者
public void addRandomNumberListener(RandomNumberListener lis){
listeners.add(lis);
}

public void random(){
r = Math.random();
//数据发生改变，通知所有的观察者
for (RandomNumberListener lis : listeners) {
lis.numberChanged(r);
}
}
}

第五个
public class Test {
public static void main(String[] args) throws InterruptedException{
RandomNumber rn = new RandomNumber();

SwingWindow sw = new SwingWindow();
Consol c = new Consol();

rn.addRandomNumberListener(sw);
rn.addRandomNumberListener(c);

while(true){
rn.random();
Thread.sleep(new Random().nextInt(3000)+1000L);
}
}

}