java觀察者
A. 求 java 非同步觀察者模式 的源代碼（完整的），不要同步的，好的給加分
package TestObserver;
import java.util.Iterator;
import java.util.Vector;
/**
*
* @author Seastar
*/
interface Observed {
public void addObserver(Observer o);
public void removeObserver(Observer o);
public void update();
}
interface Observer {
public void takeAction();
}
class Invoker {
private Observer o;
Handler handler;
public Invoker(Observer o) {
new Handler();
this.o = o;
}
private class Handler extends Thread {
public Handler() {
handler = this;
}
@Override
public void run() {
o.takeAction();
}
}
public boolean TestSameObserver(Observer o) {
return o == this.o;
}
public void invoke() {
handler.start();
}
}
class ObservedObject implements Observed {
private Vector<Invoker> observerList = new Vector<Invoker>();
public void addObserver(Observer o) {
observerList.add(new Invoker(o));
}
public void removeObserver(Observer o) {
Iterator<Invoker> it = observerList.iterator();
while (it.hasNext()) {
Invoker i = it.next();
if (i.TestSameObserver(o)) {
observerList.remove(i);
break;
}
}
}
public void update() {
for (Invoker i : observerList) {
i.invoke();
}
}
}
class ObserverA implements Observer {
public void takeAction() {
System.out.println("I am Observer A ,state changed ,so i have to do something");
}
}
class ObserverB implements Observer {
public void takeAction() {
System.out.println("I am Observer B ,i was told to do something");
}
}
class ObserverC implements Observer {
public void takeAction() {
System.out.println("I am Observer C ,I just look ,and do nothing");
}
}
public class Main {
/**
* @param args the command line arguments
*/
public static void main(String[] args) {
ObserverA a = new ObserverA();
ObserverB b = new ObserverB();
ObserverC c = new ObserverC();
ObservedObject oo = new ObservedObject();
oo.addObserver(a);
oo.addObserver(b);
oo.addObserver(c);
for (int i = 0; i < 5; ++i) {
oo.addObserver(new Observer() {
public void takeAction() {
System.out.println("我是山寨觀察者"+"，誰敢攔我");
}
});
}
//sometime oo changed ,so it calls update and informs all observer
oo.update();
}
}
觀察者模式的精髓在於注冊一個觀察者觀測可能隨時變化的對象，對象變化時就會自動通知觀察者，
這樣在被觀測對象影響范圍廣，可能引起多個類的行為改變時很好用，因為無需修改被觀測對象的代碼就可以增加被觀測對象影響的類，這樣的設計模式使得代碼易於管理和維護，並且減少了出錯幾率
至於非同步機制實際是個噱頭，可以有觀測對象來實現非同步，也可以有觀察者自身實現，這個程序實際是觀測對象實現了非同步機制，方法是在觀察者類外包裝了一層invoker類
B. Java的回調函數和觀察者模式的區別
java的回調 叫listener 模式。
無論是listener模式，還是C++裡面的callback模式，本質是一樣的
他們都是觀察者模式的具體實現。
觀察者模式是設計模式中定義的一種思想，而具體到不同的語言環境，使用不同的語法表現出來就會有java的listener objc的 delegate，或者C++的 callback。
C. java繪圖ImageObserver observer，觀察者是什麼意思
public interface ImageObserver
用於在構造 Image 時，接收有關 Image 信息通知的非同步更新介面。
欄位摘要
static int ABORT
imageUpdate 的 infoflags 參數中的此標志指示被非同步跟蹤的圖像在生成完成前即已中止。
static int ALLBITS
imageUpdate 的 infoflags 參數中的此標志指示現在已完成了一幅以前繪制的靜態圖像，並且可以其最終形式再次繪制它。
static int ERROR
imageUpdate 的 infoflags 參數中的此標志指示被非同步跟蹤的圖像遇到了錯誤。
static int FRAMEBITS
imageUpdate 的 infoflags 參數中的此標志指示多幀圖像（以前繪制的）的另一個完整幀現在可以再次繪制。
static int HEIGHT
imageUpdate 的 infoflags 參數中的此標志指示基本圖像的高度現在可用，並且可從 height 參數中獲取此高度到 imageUpdate 回調方法。
static int PROPERTIES
imageUpdate 的 infoflags 參數中的此標志指示該圖像的屬性現在可用。
static int SOMEBITS
imageUpdate 的 infoflags 參數中的此標志指示已提供了繪制圖像縮放變體所需的更多像素。
static int WIDTH
imageUpdate 的 infoflags 參數中的此標志指示基本圖像的寬度現在可用，並且可從 width 參數中獲取此寬度到 imageUpdate 回調方法。
D. JAVA觀察者模式(observer pattern)
importjava.util.ArrayList;
importjava.util.HashMap;
importjava.util.Random;
importjavax.swing.event.ChangeEvent;
importjavax.swing.event.ChangeListener;
{
privateHashMap<String,Stock>hmStocks=newHashMap<String,Stock>();
privateHashMap<String,ArrayList<ChangeListener>>hmCL=newHashMap<String,ArrayList<ChangeListener>>();
publicStockLists()
{
init(100);
newThread(this).start();
}
publicvoidrun()
{
Randomrand=newRandom();
while(true)
{
try
{
Thread.sleep(100);
Stocks=randStock();
s.price=rand.nextFloat();
ArrayList<ChangeListener>alCL=hmCL.get(s.symbol);
if(alCL==null)
{
continue;
}
for(ChangeListenercl:alCL)
{
cl.stateChanged(newChangeEvent(s));
}
}
catch(InterruptedExceptione)
{
e.printStackTrace();
}
}
}
privateStockrandStock()
{
Randomrand=newRandom();
intidx=rand.nextInt(hmStocks.size());
Stringsym=(String)hmStocks.keySet().toArray()[idx];
Stocks=hmStocks.get(sym);
returns;
}
(ChangeListenercl,Stringsym)
{
ArrayList<ChangeListener>al=hmCL.get(sym);
if(al==null)
{
al=newArrayList<ChangeListener>();
hmCL.put(sym,al);
}
returnal.add(cl);
}
privatevoidinit(intcount)
{
Randomrand=newRandom();
for(inti=0;i<count;i++)
{
Stringsym=randSym(rand);
floatp=rand.nextFloat();
Stocks=newStock(sym,p);
hmStocks.put(sym,s);
}
}
privateStringrandSym(Randomrand)
{
char[]ca=newchar[3];
for(inti=0;i<ca.length;i++)
{
ca[i]=(char)('A'+rand.nextInt(26));
}
returnnewString(ca);
}
publicstaticvoidmain(String[]args)
{
StockListssl=newStockLists();
sl.addChangeListener(newInvestor("111"),sl.randStock().symbol);
sl.addChangeListener(newInvestor("222"),sl.randStock().symbol);
sl.addChangeListener(newInvestor("333"),sl.randStock().symbol);
sl.addChangeListener(newInvestor("444"),sl.randStock().symbol);
sl.addChangeListener(newInvestor("555"),sl.randStock().symbol);
sl.addChangeListener(newInvestor("666"),sl.randStock().symbol);
sl.addChangeListener(newInvestor("777"),sl.randStock().symbol);
sl.addChangeListener(newInvestor("888"),sl.randStock().symbol);
sl.addChangeListener(newInvestor("999"),sl.randStock().symbol);
sl.addChangeListener(newInvestor("000"),sl.randStock().symbol);
}
}
classStock
{
publicStringsymbol=null;
publicfloatprice=0.0f;
publicStock(Stringsym,floatp)
{
symbol=sym;
price=p;
}
publicStringtoString()
{
returnsymbol+":"+price;
}
}
{
publicStringname="";
publicInvestor(Stringname)
{
this.name=name;
}
@Override
publicvoidstateChanged(ChangeEvente)
{
Stocks=(Stock)e.getSource();
System.out.println("Hello,"+name+":STOCKCHANGED:"+s);
}
}
E. java23個設計模式有哪些
一共23種設計模式！
引用《軟體秘笈-設計模式那點事》書籍：
按照目的來分，設計模式可以分為創建型模式、結構型模式和行為型模式。
創建型模式用來處理對象的創建過程；結構型模式用來處理類或者對象的組合；行為型模式用來對類或對象怎樣交互和怎樣分配職責進行描述。
創建型模式用來處理對象的創建過程，主要包含以下5種設計模式：
工廠方法模式（Factory
Method
Pattern）
抽象工廠模式（Abstract
Factory
Pattern）
建造者模式（Builder
Pattern）
原型模式（Prototype
Pattern）
單例模式（Singleton
Pattern）
結構型模式用來處理類或者對象的組合，主要包含以下7種設計模式：
適配器模式（Adapter
Pattern）
橋接模式（Bridge
Pattern）
組合模式（Composite
Pattern）
裝飾者模式（Decorator
Pattern）
外觀模式（Facade
Pattern）
享元模式（Flyweight
Pattern）
代理模式（Proxy
Pattern）
行為型模式用來對類或對象怎樣交互和怎樣分配職責進行描述，主要包含以下11種設計模式：
責任鏈模式（Chain
of
Responsibility
Pattern）
命令模式（Command
Pattern）
解釋器模式（Interpreter
Pattern）
迭代器模式（Iterator
Pattern）
中介者模式（Mediator
Pattern）
備忘錄模式（Memento
Pattern）
觀察者模式（Observer
Pattern）
狀態模式（State
Pattern）
策略模式（Strategy
Pattern）
模板方法模式（Template
Method
Pattern）
訪問者模式（Visitor
Pattern）
F. 為什麼rxjava 被觀察者方法叫subscribe
而RxJava作為一個工具庫，使用的就是通用形式的觀察者模式。RxJava的觀察者模式RxJava有四個基本概念：Observable(可觀察者，即被觀察者)、Observer(觀察者)、subscribe(訂閱)、事件。Observable和Observer通過subscribe()方法實
G. java觀察者模式監測多個線程
觀察者設計模式定義了對象間的一種一對多的依賴關系，以便一個對象的狀態發生變化時，所有依賴於它的對象都得到通知並自動刷新。
反之過來，監測多個線程是可以的，
不過需要自己動手設置一番。讓觀察者接受多個被觀察者動態，根據不同線程動態再進行實現。
H. java中常用的設計模式有哪些
1.單例模式（有的書上說叫單態模式其實都一樣）
該模式主要目的是使內存中保持1個對象
2.工廠模式
該模式主要功能是統一提供實例對象的引用。看下面的例子：
public class Factory{
public ClassesDao getClassesDao(){
ClassesDao cd = new ClassesDaoImpl();
return cd;
}
}
interface ClassesDao{
public String getClassesName();
}
class ClassesDaoImpl implements ClassesDao {
public String getClassesName(){
System.out.println("A班");
}
}
class test
{
public static void main(String[] args){
Factory f = new Factory();
f.getClassesDao().getClassesName();
}
}
這個是最簡單的例子了，就是通過工廠方法通過介面獲取對象的引用
3.建造模式
該模式其實就是說，一個對象的組成可能有很多其他的對象一起組成的，比如說，一個對象的實現非常復雜，有很多的屬性，而這些屬性又是其他對象的引用，可能這些對象的引用又包括很多的對象引用。封裝這些復雜性，就可以使用建造模式。
4.門面模式
這個模式個人感覺像是Service層的一個翻版。比如Dao我們定義了很多持久化方法，我們通過Service層將Dao的原子方法組成業務邏輯，再通過方法向上層提供服務。門面模式道理其實是一樣的。
5.策略模式
這個模式是將行為的抽象，即當有幾個類有相似的方法，將其中通用的部分都提取出來，從而使擴展更容易。
I. java中的設計模式都有哪些
Java中的23種設計模式：
Factory（工廠模式）， Builder（建造模式）， Factory Method（工廠方法模式），
Prototype（原始模型模式），Singleton（單例模式）， Facade（門面模式），
Adapter（適配器模式）， Bridge（橋梁模式）， Composite（合成模式），
Decorator（裝飾模式）， Flyweight（享元模式）， Proxy（代理模式），
Command（命令模式）， Interpreter（解釋器模式）， Visitor（訪問者模式），
Iterator（迭代子模式）， Mediator（調停者模式）， Memento（備忘錄模式），
Observer（觀察者模式）， State（狀態模式）， Strategy（策略模式），
Template Method（模板方法模式）， Chain Of Responsibleity（責任鏈模式）