一、設計模式的起源
最早提出“設計模式”概念的是建筑設計大師亞力山大Alexander。在1970年他的《建筑的永恒之道》里描述了投計模式的發現，因為它已經存在了千百年之久，而現代才被通過大量的研究而被發現。
在《建筑的永恒之道》里這樣描述：模式是一條由三個部分組成的通用規則：它表示了一個特定環境、一類問題和一個解決方案之間的關系。每一個模式描述了一個不斷重復發生的問題，以及該問題解決方案的核心設計。
在他的另一本書《建筑模式語言》中提到了現在已經定義了253種模式。比如：
說明城市主要的結構：亞文化區的鑲嵌、分散的工作點、城市的魅力、地方交通區
住宅團組：戶型混合、公共性的程度、住宅團組、聯排式住宅、丘狀住宅、老人天地室內環境和室外環境、陰和陽總是一氣呵成
針對住宅：夫妻的領域、兒童的領域、朝東的臥室、農家的廚房、私家的沿街露臺、個人居室、起居空間的序列、多床臥室、浴室、大儲藏室
針對辦公室、車間和公共建筑物：靈活辦公空間、共同進餐、共同小組、賓至如歸、等候場所、小會議室、半私密辦公室
盡管亞力山大的著作是針對建筑領域的，但他的觀點實際上適用于所有的工程設計領域，其中也包括軟件設計領域。“軟件設計模式”，這個術語是在1990年代由Erich Gamma等人從建筑設計領域引入到計算機科學中來的。目前主要有23種。
二、軟件設計模式的分類
創建對象時，不再由我們直接實例化對象；而是根據特定場景，由程序來確定創建對象的方式，從而保證更大的性能、更好的架構優勢。創建型模式主要有簡單工廠模式（并不是23種設計模式之一）、工廠方法、抽象工廠模式、單例模式、生成器模式和原型模式。
用于幫助將多個對象組織成更大的結構。結構型模式主要有適配器模式adapter、橋接模式bridge、組合器模式component、裝飾器模式decorator、門面模式、亨元模式flyweight和代理模式proxy。
用于幫助系統間各對象的通信，以及如何控制復雜系統中流程。行為型模式主要有命令模式command、解釋器模式、迭代器模式、中介者模式、備忘錄模式、觀察者模式、狀態模式state、策略模式、模板模式和訪問者模式。
三、常見設計模式介紹
3.1.單例模式(singleton)
有些時候，允許自由創建某個類的實例沒有意義，還可能造成系統性能下降。如果一個類始終只能創建一個實例，則這個類被稱為單例類，這種模式就被稱為單例模式。
一般建議單例模式的方法命名為：getInstance()，這個方法的返回類型肯定是單例類的類型了。getInstance方法可以有參數，這些參數可能是創建類實例所需要的參數，當然，大多數情況下是不需要的
publicclassSingleton {
publicstaticvoidmain(String[] args)
{
//創建Singleton對象不能通過構造器，只能通過getInstance方法
Singleton s1 = Singleton.getInstance();
Singleton s2 = Singleton.getInstance();
//將輸出true
System.out.println(s1 == s2);
}
//使用一個變量來緩存曾經創建的實例
privatestaticSingletoninstance;
//將構造器使用private修飾，隱藏該構造器
privateSingleton(){
System.out.println("Singleton被構造！");
}
//提供一個靜態方法，用于返回Singleton實例
//該方法可以加入自定義的控制，保證只產生一個Singleton對象
publicstaticSingleton getInstance()
{
//如果instance為null，表明還不曾創建Singleton對象
//如果instance不為null，則表明已經創建了Singleton對象，將不會執行該方法
if(instance==null)
{
//創建一個Singleton對象，并將其緩存起來
instance=newSingleton();
}
returninstance;
}
}
單例模式主要有如下兩個優勢：
1)減少創建Java實例所帶來的系統開銷
2)便于系統跟蹤單個Java實例的生命周期、實例狀態等。
3.2.簡單工廠(StaticFactory Method)
簡單工廠模式是由一個工廠對象決定創建出哪一種產品類的實例。簡單工廠模式是工廠模式家族中最簡單實用的模式，可以理解為是不同工廠模式的一個特殊實現。
A實例調用B實例的方法，稱為A依賴于B。如果使用new關鍵字來創建一個B實例（硬編碼耦合），然后調用B實例的方法。一旦系統需要重構：需要使用C類來代替B類時，程序不得不改寫A類代碼。而用工廠模式則不需要關心B對象的實現、創建過程。
Output，接口
publicinterfaceOutput
{
//接口里定義的屬性只能是常量
intMAX_CACHE_LINE= 50;
//接口里定義的只能是public的抽象實例方法
voidout();
voidgetData(String msg);
}
Printer，Output的一個實現
//讓Printer類實現Output
publicclassPrinterimplementsOutput
{
privateString[]printData=newString[MAX_CACHE_LINE];
//用以記錄當前需打印的作業數
privateintdataNum= 0;
publicvoidout()
{
//只要還有作業，繼續打印
while(dataNum> 0)
{
System.out.println("打印機打印："+printData[0]);
//把作業隊列整體前移一位，并將剩下的作業數減1
System.arraycopy(printData, 1,printData, 0, --dataNum);
}
}
publicvoidgetData(String msg)
{
if(dataNum>=MAX_CACHE_LINE)
{
System.out.println("輸出隊列已滿，添加失敗");
}
else
{
//把打印數據添加到隊列里，已保存數據的數量加1。
printData[dataNum++] = msg;
}
}
}
BetterPrinter，Output的一個實現
publicclassBetterPrinterimplementsOutput
{
privateString[]printData=newString[MAX_CACHE_LINE* 2];
//用以記錄當前需打印的作業數
privateintdataNum= 0;
publicvoidout()
{
//只要還有作業，繼續打印
while(dataNum> 0)
{
System.out.println("高速打印機正在打印："+printData[0]);
//把作業隊列整體前移一位，并將剩下的作業數減1
System.arraycopy(printData, 1,printData, 0, --dataNum);
}
}
publicvoidgetData(String msg)
{
if(dataNum>=MAX_CACHE_LINE* 2)
{
System.out.println("輸出隊列已滿，添加失敗");
}
else
{
//把打印數據添加到隊列里，已保存數據的數量加1。
printData[dataNum++] = msg;
}
}
}
OutputFactory，簡單工廠類
publicOutput getPrinterOutput(String type) {
if(type.equalsIgnoreCase("better")) {
returnnewBetterPrinter();
}else{
returnnewPrinter();
}
}
Computer
publicclassComputer
{
privateOutputout;
publicComputer(Output out)
{
this.out= out;
}
//定義一個模擬獲取字符串輸入的方法
publicvoidkeyIn(String msg)
{
out.getData(msg);
}
//定義一個模擬打印的方法
publicvoidprint()
{
out.out();
}
publicstaticvoidmain(String[] args)
{
//創建OutputFactory
OutputFactory of =newOutputFactory();
//將Output對象傳入，創建Computer對象
Computer c =newComputer(of.getPrinterOutput("normal"));
c.keyIn("建筑永恒之道");
c.keyIn("建筑模式語言");
c.print();
c =newComputer(of.getPrinterOutput("better"));
c.keyIn("建筑永恒之道");
c.keyIn("建筑模式語言");
c.print();
}
使用簡單工廠模式的優勢：讓對象的調用者和對象創建過程分離，當對象調用者需要對象時，直接向工廠請求即可。從而避免了對象的調用者與對象的實現類以硬編碼方式耦合，以提高系統的可維護性、可擴展性。工廠模式也有一個小小的缺陷：當產品修改時，工廠類也要做相應的修改。
3.3.工廠方法(Factory Method)和抽象工廠(Abstract Factory)
如果我們不想在工廠類中進行邏輯判斷，程序可以為不同產品類提供不同的工廠，不同的工廠類和產不同的產品。
當使用工廠方法設計模式時，對象調用者需要與具體的工廠類耦合，如：
//工廠類的定義1
publicclassBetterPrinterFactory
implementsOutputFactory
{
publicOutput getOutput()
{
//該工廠只負責產生BetterPrinter對象
returnnewBetterPrinter();
}
}
//工廠類的定義2
publicclassPrinterFactory
implementsOutputFactory
{
publicOutput getOutput()
{
//該工廠只負責產生Printer對象
returnnewPrinter();
}
}
//工廠類的調用
//OutputFactory of = new BetterPrinterFactory();
OutputFactory of =newPrinterFactory();
Computerc =newComputer(of.getOutput());
使用簡單工廠類，需要在工廠類里做邏輯判斷。而工廠類雖然不用在工廠類做判斷。但是帶來了另一種耦合：客戶端代碼與不同的工廠類耦合。
為了解決客戶端代碼與不同工廠類耦合的問題。在工廠類的基礎上再增加一個工廠類，該工廠類不制造具體的被調用對象，而是制造不同工廠對象。如：
//抽象工廠類的定義，在工廠類的基礎上再建一個工廠類
publicclassOutputFactoryFactory
{
//僅定義一個方法用于返回輸出設備。
publicstaticOutputFactory getOutputFactory(
String type)
{
if(type.equalsIgnoreCase("better"))
{
returnnewBetterPrinterFactory();
}
else
{
returnnewPrinterFactory();
}
}
}
//抽象工廠類的調用
OutputFactory of = OutputFactoryFactory.getOutputFactory("better");
Computer c =newComputer(of.getOutput());
3.4.代理模式(Proxy)
代理模式是一種應用非常廣泛的設計模式，當客戶端代碼需要調用某個對象時，客戶端實際上不關心是否準確得到該對象，它只要一個能提供該功能的對象即可，此時我們就可返回該對象的代理（Proxy）。
代理就是一個Java對象代表另一個Java對象來采取行動。如：
publicclassImageProxyimplementsImage
{
//組合一個image實例，作為被代理的對象
privateImageimage;
//使用抽象實體來初始化代理對象
publicImageProxy(Image image)
{
this.image= image;
}
/**
*重寫Image接口的show()方法
*該方法用于控制對被代理對象的訪問，
*并根據需要負責創建和刪除被代理對象
*/
publicvoidshow()
{
//只有當真正需要調用image的show方法時才創建被代理對象
if(image==null)
{
image=newBigImage();
}
image.show();
}
}
調用時，先不創建：
Image image = new ImageProxy(null);
hibernate默認啟用延遲加載，當系統加載A實體時，A實體關聯的B實體并未被加載出來，A實體所關聯的B實體全部是代理對象——只有等到A實體真正需要訪問B實體時，系統才會去數據庫里抓取B實體所對應的記錄。
借助于Java提供的Proxy和InvocationHandler，可以實現在運行時生成動態代理的功能，而動態代理對象就可以作為目標對象使用，而且增強了目標對象的功能。如：
Panther
publicinterfacePanther
{
//info方法聲明
publicvoidinfo();
//run方法聲明
publicvoidrun();
}
GunPanther
publicclassGunPantherimplementsPanther
{
//info方法實現，僅僅打印一個字符串
publicvoidinfo()
{
System.out.println("我是一只獵豹！");
}
//run方法實現，僅僅打印一個字符串
publicvoidrun()
{
System.out.println("我奔跑迅速");
}
}
MyProxyFactory，創建代理對象
publicclassMyProxyFactory
{
//為指定target生成動態代理對象
publicstaticObject getProxy(Object target)
throwsException
{
//創建一個MyInvokationHandler對象
MyInvokationHandler handler =
newMyInvokationHandler();
//為MyInvokationHandler設置target對象
handler.setTarget(target);
//創建、并返回一個動態代理
returnProxy.newProxyInstance(target.getClass().getClassLoader()
, target.getClass().getInterfaces(), handler);
}
}
MyInvokationHandler，增強代理的功能
publicclassMyInvokationHandlerimplementsInvocationHandler
{
//需要被代理的對象
privateObjecttarget;
publicvoidsetTarget(Object target)
{
this.target= target;
}
//執行動態代理對象的所有方法時，都會被替換成執行如下的invoke方法
publicObject invoke(Object proxy, Method method, Object[] args)
throwsException
{
TxUtil tx =newTxUtil();
//執行TxUtil對象中的beginTx。
tx.beginTx();
//以target作為主調來執行method方法
Object result = method.invoke(target, args);
//執行TxUtil對象中的endTx。
tx.endTx();
returnresult;
}
}
TxUtil
publicclassTxUtil
{
//第一個攔截器方法:模擬事務開始
publicvoidbeginTx()
{
System.out.println("=====模擬開始事務=====");
}
//第二個攔截器方法:模擬事務結束
publicvoidendTx()
{
System.out.println("=====模擬結束事務=====");
}
}
publicstaticvoidmain(String[] args)
throwsException
{
//創建一個原始的GunDog對象，作為target
Panther target =newGunPanther();
//以指定的target來創建動態代理
Panther panther = (Panther)MyProxyFactory.getProxy(target);
//調用代理對象的info()和run()方法
panther.info();
panther.run();
}
spring所創建的AOP代理就是這種動態代理。但是Spring AOP更靈活。
3.5.命令模式(Command)
某個方法需要完成某一個功能，完成這個功能的大部分步驟已經確定了，但可能有少量具體步驟無法確定，必須等到執行該方法時才可以確定。（在某些編程語言如Ruby、Perl里，允許傳入一個代碼塊作為參數。但Jara暫時還不支持代碼塊作為參數）。在Java中，傳入該方法的是一個對象，該對象通常是某個接口的匿名實現類的實例，該接口通常被稱為命令接口，這種設計方式也被稱為命令模式。
如：
Command
publicinterfaceCommand
{
//接口里定義的process方法用于封裝“處理行為”
voidprocess(int[] target);
}
ProcessArray
publicclassProcessArray
{
//定義一個each()方法，用于處理數組，
publicvoideach(int[] target , Commandcmd)
{
cmd.process(target);
}
}
TestCommand
publicclassTestCommand
{
publicstaticvoidmain(String[] args)
{
ProcessArray pa =newProcessArray();
int[] target = {3, -4, 6, 4};
//第一次處理數組，具體處理行為取決于Command對象
pa.each(target ,newCommand()
{
//重寫process()方法，決定具體的處理行為
publicvoidprocess(int[]
target)
{
for(inttmp : target )
{
System.out.println("迭代輸出目標數組的元素:"+ tmp);
}
}
});
System.out.println("------------------");
//第二次處理數組，具體處理行為取決于Command對象
pa.each(target ,newCommand()
{
//重寫process方法，決定具體的處理行為
publicvoidprocess(int[]
target)
{
intsum = 0;
for(inttmp : target )
{
sum += tmp;
}
System.out.println("數組元素的總和是:"+ sum);
}
});
}
}
HibernateTemplate使用了executeXxx()方法彌補了HibernateTemplate的不足，該方法需要接受一個HibernateCallback接口，該接口的代碼如下：
public interface HibernateCallback
{
Object doInHibernate(Session session);
}
策略模式用于封裝系列的算法，這些算法通常被封裝在一個被稱為Context的類中，客戶端程序可以自由選擇其中一種算法，或讓Context為客戶端選擇一種最佳算法——使用策略模式的優勢是為了支持算法的自由切換。
DiscountStrategy，折扣方法接口
publicinterfaceDiscountStrategy
{
//定義一個用于計算打折價的方法
doublegetDiscount(doubleoriginPrice);
}
OldDiscount，舊書打折算法
publicclassOldDiscountimplementsDiscountStrategy {
//重寫getDiscount()方法，提供舊書打折算法
publicdoublegetDiscount(doubleoriginPrice) {
System.out.println("使用舊書折扣...");
returnoriginPrice * 0.7;
}
}
VipDiscount，VIP打折算法
//實現DiscountStrategy接口，實現對VIP打折的算法
publicclassVipDiscountimplementsDiscountStrategy {
//重寫getDiscount()方法，提供VIP打折算法
publicdoublegetDiscount(doubleoriginPrice) {
System.out.println("使用VIP折扣...");
returnoriginPrice * 0.5;
}
}
策略定義
publicclassDiscountContext
{
//組合一個DiscountStrategy對象
privateDiscountStrategystrategy;
//構造器，傳入一個DiscountStrategy對象
publicDiscountContext(DiscountStrategy strategy)
{
this.strategy= strategy;
}
//根據實際所使用的DiscountStrategy對象得到折扣價
publicdoublegetDiscountPrice(doubleprice)
{
//如果strategy為null，系統自動選擇OldDiscount類
if(strategy==null)
{
strategy=newOldDiscount();
}
returnthis.strategy.getDiscount(price);
}
//提供切換算法的方法
publicvoidsetDiscount(DiscountStrategy strategy)
{
this.strategy= strategy;
}
}
測試
publicstaticvoidmain(String[] args)
{
//客戶端沒有選擇打折策略類
DiscountContext dc =newDiscountContext(null);
doubleprice1 = 79;
//使用默認的打折策略
System.out.println("79元的書默認打折后的價格是："
+ dc.getDiscountPrice(price1));
//客戶端選擇合適的VIP打折策略
dc.setDiscount(newVipDiscount());
doubleprice2 = 89;
//使用VIP打折得到打折價格
System.out.println("89元的書對VIP用戶的價格是："
+ dc.getDiscountPrice(price2));
}
使用策略模式可以讓客戶端代碼在不同的打折策略之間切換，但也有一個小小的遺憾：客戶端代碼需要和不同的策略耦合。為了彌補這個不足，我們可以考慮使用配置文件來指定DiscountContext使用哪種打折策略——這就徹底分離客戶端代碼和具體打折策略類。
隨著系統的不斷改進和開發，它們會變得越來越復雜，系統會生成大量的類，這使得程序流程更難被理解。門面模式可為這些類提供一個簡化的接口，從而簡化訪問這些類的復雜性。
門面模式（Facade）也被稱為正面模式、外觀模式，這種模式用于將一組復雜的類包裝到一個簡單的外部接口中。
原來的方式
//依次創建三個部門實例
Payment pay =newPaymentImpl();
Cook cook =newCookImpl();
Waiter waiter =newWaiterImpl();
//依次調用三個部門實例的方法來實現用餐功能
String food = pay.pay();
food = cook.cook(food);
waiter.serve(food);
門面模式
publicclassFacade {
//定義被Facade封裝的三個部門
Paymentpay;
Cookcook;
Waiterwaiter;
//構造器
publicFacade() {
this.pay=newPaymentImpl();
this.cook=newCookImpl();
this.waiter=newWaiterImpl();
}
publicvoidserveFood() {
//依次調用三個部門的方法，封裝成一個serveFood()方法
String food =pay.pay();
food =cook.cook(food);
waiter.serve(food);
}
}
門面模式調用
Facade f =newFacade();
f.serveFood();
由于實際的需要，某個類具有兩個以上的維度變化，如果只是使用繼承將無法實現這種需要，或者使得設計變得相當臃腫。而橋接模式的做法是把變化部分抽象出來，使變化部分與主類分離開來，從而將多個的變化徹底分離。最后提供一個管理類來組合不同維度上的變化，通過這種組合來滿足業務的需要。
Peppery口味風格接口：
publicinterfacePeppery
{
String style();
}
口味之一
publicclassPepperySytleimplementsPeppery
{
//實現"辣味"風格的方法
publicString style()
{
return"辣味很重，很過癮...";
}
}
口味之二
publicclassPlainStyleimplementsPeppery
{
//實現"不辣"風格的方法
publicString style()
{
return"味道清淡，很養胃...";
}
}
口味的橋梁
publicabstractclassAbstractNoodle
{
//組合一個Peppery變量，用于將該維度的變化獨立出來
protectedPepperystyle;
//每份Noodle必須組合一個Peppery對象
publicAbstractNoodle(Peppery style)
{
this.style= style;
}
publicabstractvoideat();
}
材料之一，繼承口味
publicclassPorkyNoodleextendsAbstractNoodle
{
publicPorkyNoodle(Peppery style)
{
super(style);
}
//實現eat()抽象方法
publicvoideat()
{
System.out.println("這是一碗稍嫌油膩的豬肉面條。"
+super.style.style());
}
}
材料之二，繼承口味
publicclassBeefMoodleextendsAbstractNoodle
{
publicBeefMoodle(Peppery style)
{
super(style);
}
//實現eat()抽象方法
publicvoideat()
{
System.out.println("這是一碗美味的牛肉面條。"
+super.style.style());
}
}
主程序
publicclassTest
{
publicstaticvoidmain(String[] args)
{
//下面將得到“辣味”的牛肉面
AbstractNoodle noodle1 =newBeefMoodle(
newPepperySytle());
noodle1.eat();
//下面將得到“不辣”的牛肉面
AbstractNoodle noodle2 =newBeefMoodle(
newPlainStyle());
noodle2.eat();
//下面將得到“辣味”的豬肉面
AbstractNoodle noodle3 =newPorkyNoodle(
newPepperySytle());
noodle3.eat();
//下面將得到“不辣”的豬肉面
AbstractNoodle noodle4 =newPorkyNoodle(
newPlainStyle());
noodle4.eat();
}
}
JavaEE應用中常見的DAO模式正是橋接模式的應用。
實際上，一個設計優良的項目，本身就是設計模式最好的教科書，例如Spring框架，當你深入閱讀其源代碼時，你會發現這個框架處處充滿了設計模式的應用場景。
http://www.cnblogs.com/liuling/archive/2013/04/20/observer.html
觀察者模式結構中包括四種角色：
一、主題：主題是一個接口，該接口規定了具體主題需要實現的方法，比如添加、刪除觀察者以及通知觀察者更新數據的方法。
二、觀察者：觀察者也是一個接口，該接口規定了具體觀察者用來更新數據的方法。
三、具體主題：具體主題是一個實現主題接口的類，該類包含了會經常發生變化的數據。而且還有一個集合，該集合存放的是觀察者的引用。
四：具體觀察者：具體觀察者是實現了觀察者接口的一個類。具體觀察者包含有可以存放具體主題引用的主題接口變量，以便具體觀察者讓具體主題將自己的引用添加到具體主題的集合中，讓自己成為它的觀察者，或者讓這個具體主題將自己從具體主題的集合中刪除，使自己不在時它的觀察者。
觀察者模式定義了對象間的一對多依賴關系，讓一個或多個觀察者對象觀察一個主題對象。當主題對象的狀態發生變化時，系統能通知所有的依賴于此對象的觀察者對象，從而使得觀察者對象能夠自動更新。
在觀察者模式中，被觀察的對象常常也被稱為目標或主題（Subject），依賴的對象被稱為觀察者（Observer）。
Observer，觀察者接口：
觀察者：觀察者也是一個接口，該接口規定了具體觀察者用來更新數據的方法
publicinterfaceObserver {
voidupdate(Observable o, Object arg);
}
Observable，目標或主題：
主題：主題是一個接口，該接口規定了具體主題需要實現的方法，比如添加、刪除觀察者以及通知觀察者更新數據的方法
importjava.util.ArrayList;
importjava.util.List;
importjava.util.Iterator;
publicabstractclassObservable {
//用一個List來保存該對象上所有綁定的事件監聽器
Listobservers=newArrayList();
//定義一個方法，用于從該主題上注冊觀察者
publicvoidregistObserver(Observer o) {
observers.add(o);
}
//定義一個方法，用于從該主題中刪除觀察者
publicvoidremoveObserver(Observer o) {
observers.add(o);
}
//通知該主題上注冊的所有觀察者
publicvoidnotifyObservers(Object value) {
//遍歷注冊到該被觀察者上的所有觀察者
for(Iteratorit =observers.iterator(); it.hasNext();) {
Observer o = (Observer) it.next();
//顯式每個觀察者的update方法
o.update(this, value);
}
}
}
Product被觀察類：
具體主題：具體主題是一個實現主題接口的類，該類包含了會經常發生變化的數據。而且還有一個集合，該集合存放的是觀察者的引用。
publicclassProductextendsObservable {
//定義兩個屬性
privateStringname;
privatedoubleprice;
//無參數的構造器
publicProduct() {
}
publicProduct(String name,doubleprice) {
this.name= name;
this.price= price;
}
publicString getName() {
returnname;
}
//當程序調用name的setter方法來修改Product的name屬性時
//程序自然觸發該對象上注冊的所有觀察者
publicvoidsetName(String name) {
this.name= name;
notifyObservers(name);
}
publicdoublegetPrice() {
returnprice;
}
//當程序調用price的setter方法來修改Product的price屬性時
//程序自然觸發該對象上注冊的所有觀察者
publicvoidsetPrice(doubleprice) {
this.price= price;
notifyObservers(price);
}
}
具體觀察者：具體觀察者是實現了觀察者接口的一個類。具體觀察者包含有可以存放具體主題引用的主題接口變量，以便具體觀察者讓具體主題將自己的引用添加到具體主題的集合中，讓自己成為它的觀察者，或者讓這個具體主題將自己從具體主題的集合中刪除，使自己不在時它的觀察者。
NameObserver名稱觀察者：
importjavax.swing.JFrame;
importjavax.swing.JLabel;
publicclassNameObserverimplementsObserver {
//實現觀察者必須實現的update方法
publicvoidupdate(Observable o, Object arg) {
if(arginstanceofString) {
//產品名稱改變值在name中
String name = (String) arg;
//啟動一個JFrame窗口來顯示被觀察對象的狀態改變
JFramef =newJFrame("觀察者");
JLabel l =newJLabel("名稱改變為："+ name);
f.add(l);
f.pack();
f.setVisible(true);
System.out.println("名稱觀察者:"+ o +"物品名稱已經改變為: "+ name);
}
}
}
PriceObserver價格觀察者：
publicclassPriceObserverimplementsObserver {
//實現觀察者必須實現的update方法
publicvoidupdate(Observable o, Object arg) {
if(arginstanceofDouble) {
System.out.println("價格觀察者:"+ o +"物品價格已經改變為: "+ arg);
}
}
}
測試：
publicclassTest {
publicstaticvoidmain(String[] args) {
//創建一個被觀察者對象
Product p =newProduct("電視機",
176);
//創建兩個觀察者對象
NameObserver no =newNameObserver();
PriceObserver po =newPriceObserver();
//向被觀察對象上注冊兩個觀察者對象
p.registObserver(no);
p.registObserver(po);
//程序調用setter方法來改變Product的name和price屬性
p.setName("書桌");
p.setPrice(345f);
}
}
其中Java工具類提供了被觀察者抽象基類：java.util.Observable。觀察者接口：java.util.Observer。
我們可以把觀察者接口理解成事件監聽接口，而被觀察者對象也可當成事件源處理——換個角度來思考：監聽，觀察，這兩個詞語之間有本質的區別嗎？Java事件機制的底層實現，本身就是通過觀察者模式來實現的。除此之外，主題/訂閱模式下的JMS本身就是觀察者模式的應用。
