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

}