一抚垃、設(shè)計模式的起源
最早提出“設(shè)計模式”概念的是建筑設(shè)計大師亞力山大Alexander莫鸭。在1970年他的《建筑的永恒之道》里描述了投計模式的發(fā)現(xiàn)吏祸，因為它已經(jīng)存在了千百年之久揭糕，而現(xiàn)代才被通過大量的研究而被發(fā)現(xiàn)竞端。
在《建筑的永恒之道》里這樣描述：模式是一條由三個部分組成的通用規(guī)則：它表示了一個特定環(huán)境屎即、一類問題和一個解決方案之間的關(guān)系。每一個模式描述了一個不斷重復(fù)發(fā)生的問題事富，以及該問題解決方案的核心設(shè)計技俐。
在他的另一本書《建筑模式語言》中提到了現(xiàn)在已經(jīng)定義了253種模式。比如：
說明城市主要的結(jié)構(gòu)：亞文化區(qū)的鑲嵌统台、分散的工作點雕擂、城市的魅力、地方交通區(qū)
住宅團(tuán)組：戶型混合贱勃、公共性的程度井赌、住宅團(tuán)組谤逼、聯(lián)排式住宅、丘狀住宅仇穗、老人天地室內(nèi)環(huán)境和室外環(huán)境流部、陰和陽總是一氣呵成
針對住宅：夫妻的領(lǐng)域、兒童的領(lǐng)域纹坐、朝東的臥室枝冀、農(nóng)家的廚房、私家的沿街露臺耘子、個人居室宾茂、起居空間的序列、多床臥室拴还、浴室跨晴、大儲藏室
針對辦公室、車間和公共建筑物：靈活辦公空間片林、共同進(jìn)餐端盆、共同小組、賓至如歸费封、等候場所焕妙、小會議室、半私密辦公室
盡管亞力山大的著作是針對建筑領(lǐng)域的弓摘，但他的觀點實際上適用于所有的工程設(shè)計領(lǐng)域焚鹊，其中也包括軟件設(shè)計領(lǐng)域∪拖祝“軟件設(shè)計模式”末患，這個術(shù)語是在1990年代由Erich Gamma等人從建筑設(shè)計領(lǐng)域引入到計算機科學(xué)中來的。目前主要有23種锤窑。
二璧针、軟件設(shè)計模式的分類
創(chuàng)建對象時，不再由我們直接實例化對象渊啰；而是根據(jù)特定場景探橱，由程序來確定創(chuàng)建對象的方式，從而保證更大的性能绘证、更好的架構(gòu)優(yōu)勢隧膏。創(chuàng)建型模式主要有簡單工廠模式（并不是23種設(shè)計模式之一）、工廠方法嚷那、抽象工廠模式胞枕、單例模式、生成器模式和原型模式车酣。
用于幫助將多個對象組織成更大的結(jié)構(gòu)曲稼。結(jié)構(gòu)型模式主要有適配器模式adapter索绪、橋接模式bridge、組合器模式component贫悄、裝飾器模式decorator瑞驱、門面模式、亨元模式flyweight和代理模式proxy窄坦。
用于幫助系統(tǒng)間各對象的通信唤反，以及如何控制復(fù)雜系統(tǒng)中流程。行為型模式主要有命令模式command鸭津、解釋器模式彤侍、迭代器模式、中介者模式逆趋、備忘錄模式盏阶、觀察者模式、狀態(tài)模式state闻书、策略模式名斟、模板模式和訪問者模式。
三魄眉、常見設(shè)計模式介紹
3.1.單例模式(singleton)
有些時候砰盐，允許自由創(chuàng)建某個類的實例沒有意義，還可能造成系統(tǒng)性能下降坑律。如果一個類始終只能創(chuàng)建一個實例岩梳，則這個類被稱為單例類，這種模式就被稱為單例模式晃择。
一般建議單例模式的方法命名為：getInstance()冀值，這個方法的返回類型肯定是單例類的類型了。getInstance方法可以有參數(shù)藕各，這些參數(shù)可能是創(chuàng)建類實例所需要的參數(shù)池摧，當(dāng)然，大多數(shù)情況下是不需要的
publicclassSingleton {
publicstaticvoidmain(String[] args)
{
//創(chuàng)建Singleton對象不能通過構(gòu)造器激况，只能通過getInstance方法
Singleton s1 = Singleton.getInstance();
Singleton s2 = Singleton.getInstance();
//將輸出true
System.out.println(s1 == s2);
}
//使用一個變量來緩存曾經(jīng)創(chuàng)建的實例
privatestaticSingletoninstance;
//將構(gòu)造器使用private修飾，隱藏該構(gòu)造器
privateSingleton(){
System.out.println("Singleton被構(gòu)造膘魄！");
}
//提供一個靜態(tài)方法乌逐，用于返回Singleton實例
//該方法可以加入自定義的控制，保證只產(chǎn)生一個Singleton對象
publicstaticSingleton getInstance()
{
//如果instance為null创葡，表明還不曾創(chuàng)建Singleton對象
//如果instance不為null浙踢，則表明已經(jīng)創(chuàng)建了Singleton對象，將不會執(zhí)行該方法
if(instance==null)
{
//創(chuàng)建一個Singleton對象灿渴，并將其緩存起來
instance=newSingleton();
}
returninstance;
}
}
單例模式主要有如下兩個優(yōu)勢：
1)減少創(chuàng)建Java實例所帶來的系統(tǒng)開銷
2)便于系統(tǒng)跟蹤單個Java實例的生命周期洛波、實例狀態(tài)等胰舆。
3.2.簡單工廠(StaticFactory Method)
簡單工廠模式是由一個工廠對象決定創(chuàng)建出哪一種產(chǎn)品類的實例。簡單工廠模式是工廠模式家族中最簡單實用的模式蹬挤，可以理解為是不同工廠模式的一個特殊實現(xiàn)缚窿。
A實例調(diào)用B實例的方法，稱為A依賴于B焰扳。如果使用new關(guān)鍵字來創(chuàng)建一個B實例（硬編碼耦合）倦零，然后調(diào)用B實例的方法。一旦系統(tǒng)需要重構(gòu)：需要使用C類來代替B類時吨悍，程序不得不改寫A類代碼扫茅。而用工廠模式則不需要關(guān)心B對象的實現(xiàn)、創(chuàng)建過程育瓜。
Output葫隙，接口
publicinterfaceOutput
{
//接口里定義的屬性只能是常量
intMAX_CACHE_LINE= 50;
//接口里定義的只能是public的抽象實例方法
voidout();
voidgetData(String msg);
}
Printer，Output的一個實現(xiàn)
//讓Printer類實現(xiàn)Output
publicclassPrinterimplementsOutput
{
privateString[]printData=newString[MAX_CACHE_LINE];
//用以記錄當(dāng)前需打印的作業(yè)數(shù)
privateintdataNum= 0;
publicvoidout()
{
//只要還有作業(yè)躏仇，繼續(xù)打印
while(dataNum> 0)
{
System.out.println("打印機打油＝丁："+printData[0]);
//把作業(yè)隊列整體前移一位，并將剩下的作業(yè)數(shù)減1
System.arraycopy(printData, 1,printData, 0, --dataNum);
}
}
publicvoidgetData(String msg)
{
if(dataNum>=MAX_CACHE_LINE)
{
System.out.println("輸出隊列已滿钙态，添加失敗");
}
else
{
//把打印數(shù)據(jù)添加到隊列里慧起，已保存數(shù)據(jù)的數(shù)量加1。
printData[dataNum++] = msg;
}
}
}
BetterPrinter册倒，Output的一個實現(xiàn)
publicclassBetterPrinterimplementsOutput
{
privateString[]printData=newString[MAX_CACHE_LINE* 2];
//用以記錄當(dāng)前需打印的作業(yè)數(shù)
privateintdataNum= 0;
publicvoidout()
{
//只要還有作業(yè)蚓挤，繼續(xù)打印
while(dataNum> 0)
{
System.out.println("高速打印機正在打印："+printData[0]);
//把作業(yè)隊列整體前移一位驻子，并將剩下的作業(yè)數(shù)減1
System.arraycopy(printData, 1,printData, 0, --dataNum);
}
}
publicvoidgetData(String msg)
{
if(dataNum>=MAX_CACHE_LINE* 2)
{
System.out.println("輸出隊列已滿灿意，添加失敗");
}
else
{
//把打印數(shù)據(jù)添加到隊列里，已保存數(shù)據(jù)的數(shù)量加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)
{
//創(chuàng)建OutputFactory
OutputFactory of =newOutputFactory();
//將Output對象傳入，創(chuàng)建Computer對象
Computer c =newComputer(of.getPrinterOutput("normal"));
c.keyIn("建筑永恒之道");
c.keyIn("建筑模式語言");
c.print();
c =newComputer(of.getPrinterOutput("better"));
c.keyIn("建筑永恒之道");
c.keyIn("建筑模式語言");
c.print();
}
使用簡單工廠模式的優(yōu)勢：讓對象的調(diào)用者和對象創(chuàng)建過程分離域慷，當(dāng)對象調(diào)用者需要對象時荒辕，直接向工廠請求即可。從而避免了對象的調(diào)用者與對象的實現(xiàn)類以硬編碼方式耦合犹褒，以提高系統(tǒng)的可維護(hù)性抵窒、可擴(kuò)展性。工廠模式也有一個小小的缺陷：當(dāng)產(chǎn)品修改時叠骑，工廠類也要做相應(yīng)的修改李皇。
3.3.工廠方法(Factory Method)和抽象工廠(Abstract Factory)
如果我們不想在工廠類中進(jìn)行邏輯判斷，程序可以為不同產(chǎn)品類提供不同的工廠宙枷，不同的工廠類和產(chǎn)不同的產(chǎn)品掉房。
當(dāng)使用工廠方法設(shè)計模式時茧跋，對象調(diào)用者需要與具體的工廠類耦合，如：
//工廠類的定義1
publicclassBetterPrinterFactory
implementsOutputFactory
{
publicOutput getOutput()
{
//該工廠只負(fù)責(zé)產(chǎn)生BetterPrinter對象
returnnewBetterPrinter();
}
}
//工廠類的定義2
publicclassPrinterFactory
implementsOutputFactory
{
publicOutput getOutput()
{
//該工廠只負(fù)責(zé)產(chǎn)生Printer對象
returnnewPrinter();
}
}
//工廠類的調(diào)用
//OutputFactory of = new BetterPrinterFactory();
OutputFactory of =newPrinterFactory();
Computerc =newComputer(of.getOutput());
使用簡單工廠類卓囚，需要在工廠類里做邏輯判斷瘾杭。而工廠類雖然不用在工廠類做判斷。但是帶來了另一種耦合：客戶端代碼與不同的工廠類耦合捍岳。
為了解決客戶端代碼與不同工廠類耦合的問題富寿。在工廠類的基礎(chǔ)上再增加一個工廠類，該工廠類不制造具體的被調(diào)用對象锣夹，而是制造不同工廠對象页徐。如：
//抽象工廠類的定義，在工廠類的基礎(chǔ)上再建一個工廠類
publicclassOutputFactoryFactory
{
//僅定義一個方法用于返回輸出設(shè)備银萍。
publicstaticOutputFactory getOutputFactory(
String type)
{
if(type.equalsIgnoreCase("better"))
{
returnnewBetterPrinterFactory();
}
else
{
returnnewPrinterFactory();
}
}
}
//抽象工廠類的調(diào)用
OutputFactory of = OutputFactoryFactory.getOutputFactory("better");
Computer c =newComputer(of.getOutput());
3.4.代理模式(Proxy)
代理模式是一種應(yīng)用非常廣泛的設(shè)計模式变勇，當(dāng)客戶端代碼需要調(diào)用某個對象時，客戶端實際上不關(guān)心是否準(zhǔn)確得到該對象贴唇，它只要一個能提供該功能的對象即可搀绣，此時我們就可返回該對象的代理（Proxy）。
代理就是一個Java對象代表另一個Java對象來采取行動戳气。如：
publicclassImageProxyimplementsImage
{
//組合一個image實例链患，作為被代理的對象
privateImageimage;
//使用抽象實體來初始化代理對象
publicImageProxy(Image image)
{
this.image= image;
}
/**
*重寫Image接口的show()方法
*該方法用于控制對被代理對象的訪問，
*并根據(jù)需要負(fù)責(zé)創(chuàng)建和刪除被代理對象
*/
publicvoidshow()
{
//只有當(dāng)真正需要調(diào)用image的show方法時才創(chuàng)建被代理對象
if(image==null)
{
image=newBigImage();
}
image.show();
}
}
調(diào)用時瓶您，先不創(chuàng)建：
Image image = new ImageProxy(null);
hibernate默認(rèn)啟用延遲加載麻捻，當(dāng)系統(tǒng)加載A實體時，A實體關(guān)聯(lián)的B實體并未被加載出來呀袱，A實體所關(guān)聯(lián)的B實體全部是代理對象——只有等到A實體真正需要訪問B實體時贸毕，系統(tǒng)才會去數(shù)據(jù)庫里抓取B實體所對應(yīng)的記錄。
借助于Java提供的Proxy和InvocationHandler夜赵，可以實現(xiàn)在運行時生成動態(tài)代理的功能明棍，而動態(tài)代理對象就可以作為目標(biāo)對象使用，而且增強了目標(biāo)對象的功能寇僧。如：
Panther
publicinterfacePanther
{
//info方法聲明
publicvoidinfo();
//run方法聲明
publicvoidrun();
}
GunPanther
publicclassGunPantherimplementsPanther
{
//info方法實現(xiàn)摊腋，僅僅打印一個字符串
publicvoidinfo()
{
System.out.println("我是一只獵豹！");
}
//run方法實現(xiàn)婉宰，僅僅打印一個字符串
publicvoidrun()
{
System.out.println("我奔跑迅速");
}
}
MyProxyFactory歌豺，創(chuàng)建代理對象
publicclassMyProxyFactory
{
//為指定target生成動態(tài)代理對象
publicstaticObject getProxy(Object target)
throwsException
{
//創(chuàng)建一個MyInvokationHandler對象
MyInvokationHandler handler =
newMyInvokationHandler();
//為MyInvokationHandler設(shè)置target對象
handler.setTarget(target);
//創(chuàng)建、并返回一個動態(tài)代理
returnProxy.newProxyInstance(target.getClass().getClassLoader()
, target.getClass().getInterfaces(), handler);
}
}
MyInvokationHandler心包，增強代理的功能
publicclassMyInvokationHandlerimplementsInvocationHandler
{
//需要被代理的對象
privateObjecttarget;
publicvoidsetTarget(Object target)
{
this.target= target;
}
//執(zhí)行動態(tài)代理對象的所有方法時，都會被替換成執(zhí)行如下的invoke方法
publicObject invoke(Object proxy, Method method, Object[] args)
throwsException
{
TxUtil tx =newTxUtil();
//執(zhí)行TxUtil對象中的beginTx馒铃。
tx.beginTx();
//以target作為主調(diào)來執(zhí)行method方法
Object result = method.invoke(target, args);
//執(zhí)行TxUtil對象中的endTx蟹腾。
tx.endTx();
returnresult;
}
}
TxUtil
publicclassTxUtil
{
//第一個攔截器方法:模擬事務(wù)開始
publicvoidbeginTx()
{
System.out.println("=====模擬開始事務(wù)=====");
}
//第二個攔截器方法:模擬事務(wù)結(jié)束
publicvoidendTx()
{
System.out.println("=====模擬結(jié)束事務(wù)=====");
}
}
publicstaticvoidmain(String[] args)
throwsException
{
//創(chuàng)建一個原始的GunDog對象痕惋，作為target
Panther target =newGunPanther();
//以指定的target來創(chuàng)建動態(tài)代理
Panther panther = (Panther)MyProxyFactory.getProxy(target);
//調(diào)用代理對象的info()和run()方法
panther.info();
panther.run();
}
spring所創(chuàng)建的AOP代理就是這種動態(tài)代理。但是Spring AOP更靈活娃殖。
3.5.命令模式(Command)
某個方法需要完成某一個功能值戳，完成這個功能的大部分步驟已經(jīng)確定了，但可能有少量具體步驟無法確定炉爆，必須等到執(zhí)行該方法時才可以確定堕虹。（在某些編程語言如Ruby、Perl里芬首，允許傳入一個代碼塊作為參數(shù)赴捞。但Jara暫時還不支持代碼塊作為參數(shù)）。在Java中郁稍，傳入該方法的是一個對象赦政，該對象通常是某個接口的匿名實現(xiàn)類的實例，該接口通常被稱為命令接口耀怜，這種設(shè)計方式也被稱為命令模式恢着。
如：
Command
publicinterfaceCommand
{
//接口里定義的process方法用于封裝“處理行為”
voidprocess(int[] target);
}
ProcessArray
publicclassProcessArray
{
//定義一個each()方法，用于處理數(shù)組财破，
publicvoideach(int[] target , Commandcmd)
{
cmd.process(target);
}
}
TestCommand
publicclassTestCommand
{
publicstaticvoidmain(String[] args)
{
ProcessArray pa =newProcessArray();
int[] target = {3, -4, 6, 4};
//第一次處理數(shù)組鸦做，具體處理行為取決于Command對象
pa.each(target ,newCommand()
{
//重寫process()方法督暂，決定具體的處理行為
publicvoidprocess(int[]
target)
{
for(inttmp : target )
{
System.out.println("迭代輸出目標(biāo)數(shù)組的元素:"+ tmp);
}
}
});
System.out.println("------------------");
//第二次處理數(shù)組，具體處理行為取決于Command對象
pa.each(target ,newCommand()
{
//重寫process方法，決定具體的處理行為
publicvoidprocess(int[]
target)
{
intsum = 0;
for(inttmp : target )
{
sum += tmp;
}
System.out.println("數(shù)組元素的總和是:"+ sum);
}
});
}
}
HibernateTemplate使用了executeXxx()方法彌補了HibernateTemplate的不足友多，該方法需要接受一個HibernateCallback接口，該接口的代碼如下：
public interface HibernateCallback
{
Object doInHibernate(Session session);
}
策略模式用于封裝系列的算法硼砰，這些算法通常被封裝在一個被稱為Context的類中糠赦，客戶端程序可以自由選擇其中一種算法，或讓Context為客戶端選擇一種最佳算法——使用策略模式的優(yōu)勢是為了支持算法的自由切換磅废。
DiscountStrategy纳像，折扣方法接口
publicinterfaceDiscountStrategy
{
//定義一個用于計算打折價的方法
doublegetDiscount(doubleoriginPrice);
}
OldDiscount，舊書打折算法
publicclassOldDiscountimplementsDiscountStrategy {
//重寫getDiscount()方法拯勉，提供舊書打折算法
publicdoublegetDiscount(doubleoriginPrice) {
System.out.println("使用舊書折扣...");
returnoriginPrice * 0.7;
}
}
VipDiscount竟趾，VIP打折算法
//實現(xiàn)DiscountStrategy接口，實現(xiàn)對VIP打折的算法
publicclassVipDiscountimplementsDiscountStrategy {
//重寫getDiscount()方法宫峦，提供VIP打折算法
publicdoublegetDiscount(doubleoriginPrice) {
System.out.println("使用VIP折扣...");
returnoriginPrice * 0.5;
}
}
策略定義
publicclassDiscountContext
{
//組合一個DiscountStrategy對象
privateDiscountStrategystrategy;
//構(gòu)造器岔帽，傳入一個DiscountStrategy對象
publicDiscountContext(DiscountStrategy strategy)
{
this.strategy= strategy;
}
//根據(jù)實際所使用的DiscountStrategy對象得到折扣價
publicdoublegetDiscountPrice(doubleprice)
{
//如果strategy為null，系統(tǒng)自動選擇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;
//使用默認(rèn)的打折策略
System.out.println("79元的書默認(rèn)打折后的價格是："
+ dc.getDiscountPrice(price1));
//客戶端選擇合適的VIP打折策略
dc.setDiscount(newVipDiscount());
doubleprice2 = 89;
//使用VIP打折得到打折價格
System.out.println("89元的書對VIP用戶的價格是："
+ dc.getDiscountPrice(price2));
}
使用策略模式可以讓客戶端代碼在不同的打折策略之間切換导绷，但也有一個小小的遺憾：客戶端代碼需要和不同的策略耦合犀勒。為了彌補這個不足，我們可以考慮使用配置文件來指定DiscountContext使用哪種打折策略——這就徹底分離客戶端代碼和具體打折策略類。
隨著系統(tǒng)的不斷改進(jìn)和開發(fā)贾费，它們會變得越來越復(fù)雜钦购，系統(tǒng)會生成大量的類，這使得程序流程更難被理解褂萧。門面模式可為這些類提供一個簡化的接口押桃，從而簡化訪問這些類的復(fù)雜性。
門面模式（Facade）也被稱為正面模式导犹、外觀模式唱凯，這種模式用于將一組復(fù)雜的類包裝到一個簡單的外部接口中。
原來的方式
//依次創(chuàng)建三個部門實例
Payment pay =newPaymentImpl();
Cook cook =newCookImpl();
Waiter waiter =newWaiterImpl();
//依次調(diào)用三個部門實例的方法來實現(xiàn)用餐功能
String food = pay.pay();
food = cook.cook(food);
waiter.serve(food);
門面模式
publicclassFacade {
//定義被Facade封裝的三個部門
Paymentpay;
Cookcook;
Waiterwaiter;
//構(gòu)造器
publicFacade() {
this.pay=newPaymentImpl();
this.cook=newCookImpl();
this.waiter=newWaiterImpl();
}
publicvoidserveFood() {
//依次調(diào)用三個部門的方法谎痢，封裝成一個serveFood()方法
String food =pay.pay();
food =cook.cook(food);
waiter.serve(food);
}
}
門面模式調(diào)用
Facade f =newFacade();
f.serveFood();
由于實際的需要磕昼，某個類具有兩個以上的維度變化，如果只是使用繼承將無法實現(xiàn)這種需要舶得，或者使得設(shè)計變得相當(dāng)臃腫掰烟。而橋接模式的做法是把變化部分抽象出來，使變化部分與主類分離開來沐批，從而將多個的變化徹底分離纫骑。最后提供一個管理類來組合不同維度上的變化，通過這種組合來滿足業(yè)務(wù)的需要九孩。
Peppery口味風(fēng)格接口：
publicinterfacePeppery
{
String style();
}
口味之一
publicclassPepperySytleimplementsPeppery
{
//實現(xiàn)"辣味"風(fēng)格的方法
publicString style()
{
return"辣味很重先馆，很過癮...";
}
}
口味之二
publicclassPlainStyleimplementsPeppery
{
//實現(xiàn)"不辣"風(fēng)格的方法
publicString style()
{
return"味道清淡，很養(yǎng)胃...";
}
}
口味的橋梁
publicabstractclassAbstractNoodle
{
//組合一個Peppery變量躺彬，用于將該維度的變化獨立出來
protectedPepperystyle;
//每份Noodle必須組合一個Peppery對象
publicAbstractNoodle(Peppery style)
{
this.style= style;
}
publicabstractvoideat();
}
材料之一煤墙，繼承口味
publicclassPorkyNoodleextendsAbstractNoodle
{
publicPorkyNoodle(Peppery style)
{
super(style);
}
//實現(xiàn)eat()抽象方法
publicvoideat()
{
System.out.println("這是一碗稍嫌油膩的豬肉面條。"
+super.style.style());
}
}
材料之二宪拥，繼承口味
publicclassBeefMoodleextendsAbstractNoodle
{
publicBeefMoodle(Peppery style)
{
super(style);
}
//實現(xiàn)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應(yīng)用中常見的DAO模式正是橋接模式的應(yīng)用。
實際上她君，一個設(shè)計優(yōu)良的項目脚作，本身就是設(shè)計模式最好的教科書，例如Spring框架缔刹，當(dāng)你深入閱讀其源代碼時球涛，你會發(fā)現(xiàn)這個框架處處充滿了設(shè)計模式的應(yīng)用場景。
http://www.cnblogs.com/liuling/archive/2013/04/20/observer.html
觀察者模式結(jié)構(gòu)中包括四種角色：
一校镐、主題：主題是一個接口亿扁，該接口規(guī)定了具體主題需要實現(xiàn)的方法，比如添加鸟廓、刪除觀察者以及通知觀察者更新數(shù)據(jù)的方法从祝。
二襟己、觀察者：觀察者也是一個接口，該接口規(guī)定了具體觀察者用來更新數(shù)據(jù)的方法哄褒。
三稀蟋、具體主題：具體主題是一個實現(xiàn)主題接口的類煌张，該類包含了會經(jīng)常發(fā)生變化的數(shù)據(jù)呐赡。而且還有一個集合，該集合存放的是觀察者的引用骏融。
四：具體觀察者：具體觀察者是實現(xiàn)了觀察者接口的一個類链嘀。具體觀察者包含有可以存放具體主題引用的主題接口變量，以便具體觀察者讓具體主題將自己的引用添加到具體主題的集合中档玻，讓自己成為它的觀察者怀泊，或者讓這個具體主題將自己從具體主題的集合中刪除，使自己不在時它的觀察者误趴。
觀察者模式定義了對象間的一對多依賴關(guān)系霹琼，讓一個或多個觀察者對象觀察一個主題對象。當(dāng)主題對象的狀態(tài)發(fā)生變化時凉当，系統(tǒng)能通知所有的依賴于此對象的觀察者對象枣申，從而使得觀察者對象能夠自動更新。
在觀察者模式中看杭，被觀察的對象常常也被稱為目標(biāo)或主題（Subject）忠藤，依賴的對象被稱為觀察者（Observer）。
Observer楼雹，觀察者接口：
觀察者：觀察者也是一個接口模孩，該接口規(guī)定了具體觀察者用來更新數(shù)據(jù)的方法
publicinterfaceObserver {
voidupdate(Observable o, Object arg);
}
Observable，目標(biāo)或主題：
主題：主題是一個接口贮缅，該接口規(guī)定了具體主題需要實現(xiàn)的方法榨咐，比如添加、刪除觀察者以及通知觀察者更新數(shù)據(jù)的方法
importjava.util.ArrayList;
importjava.util.List;
importjava.util.Iterator;
publicabstractclassObservable {
//用一個List來保存該對象上所有綁定的事件監(jiān)聽器
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被觀察類：
具體主題：具體主題是一個實現(xiàn)主題接口的類，該類包含了會經(jīng)常發(fā)生變化的數(shù)據(jù)憔鬼。而且還有一個集合龟劲，該集合存放的是觀察者的引用。
publicclassProductextendsObservable {
//定義兩個屬性
privateStringname;
privatedoubleprice;
//無參數(shù)的構(gòu)造器
publicProduct() {
}
publicProduct(String name,doubleprice) {
this.name= name;
this.price= price;
}
publicString getName() {
returnname;
}
//當(dāng)程序調(diào)用name的setter方法來修改Product的name屬性時
//程序自然觸發(fā)該對象上注冊的所有觀察者
publicvoidsetName(String name) {
this.name= name;
notifyObservers(name);
}
publicdoublegetPrice() {
returnprice;
}
//當(dāng)程序調(diào)用price的setter方法來修改Product的price屬性時
//程序自然觸發(fā)該對象上注冊的所有觀察者
publicvoidsetPrice(doubleprice) {
this.price= price;
notifyObservers(price);
}
}
具體觀察者：具體觀察者是實現(xiàn)了觀察者接口的一個類轴或。具體觀察者包含有可以存放具體主題引用的主題接口變量昌跌，以便具體觀察者讓具體主題將自己的引用添加到具體主題的集合中，讓自己成為它的觀察者照雁，或者讓這個具體主題將自己從具體主題的集合中刪除蚕愤，使自己不在時它的觀察者答恶。
NameObserver名稱觀察者：
importjavax.swing.JFrame;
importjavax.swing.JLabel;
publicclassNameObserverimplementsObserver {
//實現(xiàn)觀察者必須實現(xiàn)的update方法
publicvoidupdate(Observable o, Object arg) {
if(arginstanceofString) {
//產(chǎn)品名稱改變值在name中
String name = (String) arg;
//啟動一個JFrame窗口來顯示被觀察對象的狀態(tài)改變
JFramef =newJFrame("觀察者");
JLabel l =newJLabel("名稱改變?yōu)椋?+ name);
f.add(l);
f.pack();
f.setVisible(true);
System.out.println("名稱觀察者:"+ o +"物品名稱已經(jīng)改變?yōu)? "+ name);
}
}
}
PriceObserver價格觀察者：
publicclassPriceObserverimplementsObserver {
//實現(xiàn)觀察者必須實現(xiàn)的update方法
publicvoidupdate(Observable o, Object arg) {
if(arginstanceofDouble) {
System.out.println("價格觀察者:"+ o +"物品價格已經(jīng)改變?yōu)? "+ arg);
}
}
}
測試：
publicclassTest {
publicstaticvoidmain(String[] args) {
//創(chuàng)建一個被觀察者對象
Product p =newProduct("電視機",
176);
//創(chuàng)建兩個觀察者對象
NameObserver no =newNameObserver();
PriceObserver po =newPriceObserver();
//向被觀察對象上注冊兩個觀察者對象
p.registObserver(no);
p.registObserver(po);
//程序調(diào)用setter方法來改變Product的name和price屬性
p.setName("書桌");
p.setPrice(345f);
}
}
其中Java工具類提供了被觀察者抽象基類：java.util.Observable。觀察者接口：java.util.Observer萍诱。
我們可以把觀察者接口理解成事件監(jiān)聽接口悬嗓，而被觀察者對象也可當(dāng)成事件源處理——換個角度來思考：監(jiān)聽，觀察裕坊，這兩個詞語之間有本質(zhì)的區(qū)別嗎包竹？Java事件機制的底層實現(xiàn)，本身就是通過觀察者模式來實現(xiàn)的籍凝。除此之外周瞎，主題/訂閱模式下的JMS本身就是觀察者模式的應(yīng)用。
