第229章

大B:“我來講講我個人對設計模式的理解吧。”

小A:“嗬嗬!好啊!”

大B:“也許能讓你更好地理解23種設計模式。”

1、Adapter(適配器)模式:旨在提供用戶期望的接口,以便利用具有不同接口的類的服務。

(1)個人理解:實際上隻是把客戶調用,轉變為調用已經存在的方法。適配器的作用可以理解為提供一個人人皆知的,顧名思義的新方法名。

(2)提示代碼:

publicdoublegetMass(){

returnrocket.getMass(simTime);

}

2、Facade(外觀)模式:旨在為子係統提供一個接口,使之更加容易使用。

(1)經典範例:JOptionPane類,JOptionPane.showConfirmDialog(……)

(2)個人理解:構建一個個目的明確的類,比如典型的靜態方法的使用。

(3)提示代碼:

intoption;

option=JOptionPane.showConfirmDialog(……);//靜態方法創建對話框

(4)提示關鍵字:外觀類,工具類,實例類

3、Composite(組合)模式:旨在讓用戶能夠用統一的接口處理單個對象以及對象組合。

(1)經典範例:組合,樹,環

(2)個人理解:其他很多模式的基礎,群組可以包含群組或者個體,群組和個體有共同的接口。

(3)提示代碼:

MachineComponentmc=(MachineComponent)i.next();

count+=mc.getMachineCount();

(4)提示關鍵字:遞歸

4、責任型模式Bridge(橋接)模式:旨在將依賴抽象操作的類與這些抽象操作的實現相分離,從而使得抽象類與實現能夠獨立變化。

(1)經典範例:驅動程序

(2)個人理解:將抽象和方法的具體實現分離,抽象類中包含一個driver對象,driver對象即是對方法的具體實現。

(3)提示關鍵字:裝載

5、ChainofResponsibility(責任鏈)模式:旨在將一個方法調用請求沿著責任鏈依次轉發給下一個對象,讓每個對象都有一次機會決定自己是否處理該請求,從而降低請求的發送者與其接受者之間的耦合程度。

(1)個人理解:尋找責任的請求在鏈中傳遞,如果責任人已經找到則終止,否則繼續向其他對象轉發責任。

(2)提示代碼:

publicEngineergetResponsible(VisualizationItemitem){

if(iteminstanceoftool){

Toolt=(Tool)item;

returnt.getToolCart().gerResponsible();

}

if(iteminstanceofToolCart){

ToolCarttc=(ToolCart)item;

returntc.gerResponsible();

}

}

(3)提示關鍵字:轉發

6、Singleton(單例)模式:旨在確保某個類隻有一個實例,並且為之提供一個全局訪問點。

(1)個人理解:創建一個類的唯一實例,可以作為全局變量。

(2)提示代碼:

publicstaticFactorygetFactory(){

if(factory……null)

factory=newFactory();

returnfactory;

}

7、Observer(觀察者)模式:旨在在多個對象之間定義一對多的依賴關係,以便當一個對象狀態改變時,其他所有依賴這個對象的對象都能夠被通知,並自動更新。

(1)經典範例:GUI(MVC中分離M和VC)

(2)個人理解:當一個對象發生改變的時候,其他關心該對象的對象能夠得到通知,並且更新自身狀態。

(3)提示代碼:

publicvoidnotifyObservers(){

observers.update();

}

(4)提示關鍵字:注冊,監聽

8、Mediator(中介者)模式:旨在定義一個對象來封裝一組對象之間交互的方式,這樣可避免對象間的顯示引用,而且還可以獨立對這些對象的交互進行修改。

(1)經典範例:GUI(特指MVC中的controller)

(2)個人理解:中介者類專門用於處理對象間的交互,與GUI的布局組件分離

(3)提示代碼:

publicvoidsetLocation(Machinevalue){

returnmediator.set(this,value);

}

9、Proxy(代理)模式:旨在為某個對象提供一個代理來控製對該對象的訪問。

(1)經典範例:圖像代理(長時間載入內存前的Loading提示)

(2)個人理解:提供一個代理來承擔責任(轉發請求),實際操作的對象並不是根本對象,而是一個用戶和真正實現之間的中間角色。

(3)提示代碼:

setImage(LOADING.getImage());

callbackFrame.repaint();

newThread(this).start();

(4)提示關鍵字:占位

10、Flyweight(享元)模式:旨在通過共享來為大量的細粒度對象提供有效的支持。

(1)個人理解:很多類具有相同的且不變的屬性,可以將這些屬性提取出來構成享元,在一個特定的工廠類中作為內部類,具有static的get方法,便於外部類共享。

(2)提示代碼:

publicclassChemicalFactory{

privatestaticMaochemicals=newHashMap();

ChemicalImp{

//someattributesandmethods

}

static{

chemicals.put(newChemicalImp());

}

publicstaticChemicalgetChemical(Stringname){

return***;

}

}

(3)提示關鍵字:共享對象

11、Builder(生成器)模式:旨在把構造對象實例的代碼邏輯移到要實例化的類的外部,以便於細化構造過程,或者簡化對象。

(1)經典範例:解析文本構造對象

(2)個人理解:用一個builder類收集構造信息,在確定信息足夠(或者滿足構造的最低要求)的時候,再生成對象。

(3)提示代碼:

Stringsample=“*****”;

ReservationBuliderbuilder=newUnforgivingBuilder();

newReservationParser(builder).parse(sample);

Resercationres=builder.build();

(4)提示關鍵字:逐步構造

12、FactoryMethod(工廠方法)模式:旨在定義一個用於創建對象的接口,同時控製對哪個類進行實例化。

(1)經典範例:迭代器

(2)個人理解:為相關的多個類提供一個共同的接口,客戶不需要知道該實例化哪個類,具體實例化的類由服務的提供者決定。

(3)提示代碼:

Listlist=Arrays.asList(newString[]{“1”,“2”,“3”});

Iteratoriter=list.iterator();

(4)提示關鍵字:共同接口

13、AbstractFactory(抽象工廠)模式:旨在創建一係列相互關聯或相互依賴的對象。

(1)經典範例:GUI工具包

(2)個人理解:創建一係列相關的對象,也就是把創建一個大對象所需要的子操作聚合起來。

(3)提示代碼:

publicJButtoncreateButtonOK(){

JButtonb=super.createButtonOk();

b.setIcon(getIcon(“images/123.gif”));

returnb;

}

(4)提示關鍵字:外觀和感覺

14、Prototype(原型)模式:通過拷貝一個現有對象生成新的對象。

(1)個人理解:通過複製一個已經存在的對象,保存原來對象的狀態,在此基礎上進行進一步的改動。

(2)提示代碼:

publicOzPanelcopy2(){

OzPanelresult=newOzPanel();

result.setBackground(this.getBackground());

//moreresult.set***methods……

returnresult;

}

(3)提示關鍵字:複製

15、Memento(備忘錄)模式:旨在為對象提供狀態存儲和狀態恢複功能。

(1)經典範例:撤銷操作

(2)個人理解:使用棧進行撤銷和恢複的操作,棧頂部是當前的狀態。更多的,可以把相關狀態進行持久性存儲。

(3)提示代碼:

publicvoidundo(){

if(!canUndo())return;

mementos.pop();

}

(4)提示關鍵字:redo,undo

16、TemplateMethod(模板方法)模式:旨在一個方法中實現一個算法,並遵循算法中某些步驟的定義,從而使得其他類可以重新定義這些新步驟。

(1)經典範例:(根據不同規則)排序

(2)個人理解:在算法的實現中,把一些需要自定義的部分(通常是算法的核心部分),留在外部的類來實現。並可以需要實現的部分設置鉤子。

(3)提示代碼:

Array.sout(rockets,newApogeeComparator());

publicclassApogeeComparatorimplementsComparator{

//basemethodaboutsort……

}

(4)提示關鍵字:算法框架+算法步驟

17、State(狀態)模式:旨在將與狀態有關的處理邏輯分散到代表狀態的各個類中。

(1)個人理解:將所有的狀態都構建成一個相應的類,它們的超類對外部各個事件提供相應的同意接口,使得調用者無需判斷當前狀態。

(2)提示代碼:

publicclassDoor2extendsObservable{

publicvoidtouch(){

state.touch();

}

}

publicclassDoorOpenextendsDoorState{

publicvoidtouch(){

door.setState(door.STAYOPEN);

}

}

(3)提示關鍵字:狀態處理分散

18、Strategy(策略)模式:旨在把可選的策略或方案封裝到不同的類中,並在這些類中實現一個共同的操作。

(1)個人理解:為不同的解決方案建立類,在執行的時候選擇一個策略執行。與State模式比較,兩者很接近,前者傾向在可選的方案中選擇,後者是在不同的狀態之間遷移。

(2)提示代碼:

privateAdvisorgetAdvisor(){

if(advisor……null){

if(promotionAdvisor.hasItem())

advisor=promotionAdvisor;

//maybemoreelseif

}

returnadvisor;

}

(3)提示關鍵字:策略選擇+策略執行

19、Command(命令)模式:旨在將請求封裝為一個對象,並將該請求對象作為參數;客戶可以提供不同的請求對象,如隊列請求,時間請求或者日誌請求;也可以讓客戶準備調用該請求的特定上下文。

(1)經典範例:菜單命令(actionPerformed())

(2)個人理解:將方法(一般是execute()方法)封裝在對象中,使用時直接調用相關mand對象的execute()方法即可。可以作為Template模式的替代模式。

(3)提示代碼:

Commanddoze=newCommand(){

publicvoidexecute(){

//dosomething

}

}

publicclassCommandTimer{

Publicstaticlongtime(Commandmand){

mand.execute();

}

}

longactual=CommandTimer.time(doze);

(4)提示關鍵字:封裝對象

20、Interpreter(解釋器)模式:旨在使開發者可以根據自己定義的組合規則生成可執行的對象。

(1)個人理解:常與Command和Composite模式配合使用,對命令進行組合使用,有點像編程中使用語句構造功能。

(2)提示代碼:

publicclassIfCommandextendsCommand{

protectedTermterm;

protectedCommandbody;

protectedCommandelseBody;

publicIfCommand(Termterm,Commandbody,CommandelseBody){

this.term=term;

this.body=body;

this.elseBody=elseBody;

}

publicvoidexecute(){

if(term.eval()!=null)

body.execyte();

else

elseBody.execute();

}

}

(3)提示關鍵字:解釋器,組合對象

21、Decorator(裝飾器)模式:旨在使開發者能夠動態地組織對象的行為。

(1)經典範例:流和輸出器,函數包裝器

(2)個人理解:在運行時動態創建不同的變化

(3)提示代碼:

BufferedOutputStreamout=

newBufferedOutputStream(

newGZIPOutputStream(

newFileOutputStream(args[1])));

(4)提示關鍵字:動態組合

22、Iterator(迭代器)模式:旨在為開發人員提供一種順序訪問集合元素的方法。

(1)個人理解:在新建一個結構的時候,為順序訪問其元素,可以同樣新建一個對應的迭代器類。也可以自定義訪問元素的其他方式(比如逆序)。

(2)提示代碼:

Listemployees;

ListIteratorforward(employees);

ReverseListIteratorbackward(employees);

PrintEmployees(forward);

PrintEmployees(backward);

(3)提示關鍵字:訪問元素

23、Visitor(訪問者)模式:旨在讓開發者能夠在不修改現有類層次結構的前提下擴展該類層次結構的行為。

(1)個人理解:在開發類的時候,留有一個accept()操作,該操作接受一個visitor參數。在需要為類增加新的操作時,無需改變原來的類層次,直接編輯visitor中的visit操作,然後使用accept()方法接受即可。

(2)提示代碼:

publicclassFindVisitorimplementsMachineVisitor{

publicMachineComponetfind(MachineComponetmc){

mc.accept(this);

}

publicvoidvisit(MachineCompositemc){

//dosomething

}

}

MachineComponentfactory=OozinozFactory.dublin();

MachineComponentmachine=newFindVisitor().find(factory,3404);

(3)提示關鍵字:不改變類層次附錄:麵向對象基礎

小A:“為什麽要‘麵向對象’?”

大B:“麵向對象方法使構建係統更容易,因為:解決正確的問題,正常工作,易維護,易擴充,易重用。大家發現麵向對象更易理解,實現可以更簡單。把數據和功能組合在一起簡單而自然,分析和實現之間的概念跨度更小,設計良好的一組對象能彈性地適應重用和變化,可視化模型提供更有效的溝通,建模過程有助於創建通用詞匯以及在開發者和用戶/客戶之間達成共識。非計算機編程人員也能理解對象模型,這些好處可以使用麵向對象方法獲得,但麵向對象方法不能保證這一點。”

小A:“怎樣才能變成優秀的麵向對象設計者?”

大B:“隻有靠經驗和聰明的頭腦才能做到。”

過程化方法(TheProceduralApproach)

小A:“怎樣過程化方法?”

大B:“係統由過程(procedures)組成,過程之間互相發送數據,過程和數據各自獨立,集中於數據結構、算法和運算步驟的先後順序,過程經常難以重用,缺乏具有較強表現力的可視化建模技術,分析與實現之間需要進行概念轉換,本質上是機器/匯編語言的抽象,從設計模型到代碼實現跨度很大。”

麵向對象方法

大B:“係統由對象組成,對象互相發送消息(過程調用)相關的數據和行為緊密地綁定在對象中,把問題領域建模成對象,要解決的問題自然的映射為代碼的實現,可視模型表現力強,相對容易理解,集中於實現之前所確定的職責(responsibilities)和接口。強有力的概念:接口,抽象,封裝,繼承,委托(delegation)和多態。問題的可視模型逐漸進化成解決方案模型,設計模型與代碼實現之間跨度較小努力縮減軟件的複雜度。”

溫度換算

大B:“下麵我就以溫度換算為例。”

過程/函數化方法

floatc=getTemperature();//假定為攝氏度。

floatf=toFarenheitFromCelcius(c);

floatk=toKelvinFromCelcius(c);

floatx=toKelvinFromFarenheit(f);

floaty=toFarenheitFromKelvin(k);

麵向對象方法

Temptemp=getTemperature();

floatc=temp.toCelcius();

floatf=temp.toFarenheit();

floatk=temp.toKelvin();

包含有數據的Temp的內部單元是什麽?

建模(Modeling)

小A:“成功的程序能解決真實世界的問題。”

大B:“嗯,是的。它們緊密對應於需要解決的問題。對問題領域和用戶活動進行建模。”

小A:“建模促進與用戶更好的可視化交流。”

大B:“成功的麵向對象設計總是一開始就由領域專家和軟件設計者建立一個反映問題領域的可視化的‘對象模型’。”

小A:“嗯。是的。”

大B:“你願意讓承包人在沒有設計藍圖的情況下建造你的新房子嗎?”

小A:“那當然不行啦。”

對象

大B:“你知道怎樣去理解什麽是對象嗎?”

小A:“對象代表真實或抽象的事物,有一個名字,有明確的職責(well-definedresponsibilities),展示良好的行為(well-definedbehavior),接口清晰,並且盡可能簡單、自相容,內聚,完備(self-consistent,coherent,andplete)。”

大B:“嗯,對。(通常)不是很複雜或很大,隻需要理解自己和一小部分其他對象的接口,與一小部分其它對象協同工作(teamplayers),盡可能地與其它對象鬆散耦合(looselycoupled),很好地文檔化,以便他人使用或重用,對象是類的實例,每一個對象都有唯一的標識,類定義一組對象的接口和實現,即定義了這些對象的行為,抽象類不能擁有實例,隻要有抽象類(如寵物),通常就會有能夠實例化的具體類(如貓,狗等),一些麵向對象語言(如Smalltalk)支持元類(metaclass)的概念,程序員可以隨時(on-the-fly)定義一個類,然後實例化。這種情況下,類也是一個對象,即元類。對象一旦實例化,就不能更改它的類。”

對象的特征

大B:“那你知道對象有什麽特征嗎?”

小A:“有唯一標識,可以分成許多種類(即類),可以繼承或聚合。行為、職責明確,接口與實現分離,隱藏內部結構,有不同的狀態,可以提供服務,可以給其它對象發送消息,從其它對象接收消息,並做出相應響應,可以把職責委托給其它對象。”

大B:“對,說得非常全麵。”

類

小A:“怎麽樣才叫類呢?”

大B:“有公共的屬性和行為的一組對象可以抽象成為類,對象通常根據你所感興趣的屬性而分類。”

小A:“喔。”

大B:“例如:街道,馬路,高速公路……不同的程序對它們分類也不同。交通模擬器程序,單行道,雙通道,有分車道的,住宅區的,限製通行的維護調度程序,路麵材料,重型卡車運輸類本身也可以有屬性和行為。例如:養老金管理程序中的‘雇員’類雇員總數,雇員編製多少,不同語言對類的支持略有不同:Smalltalk把類當作對象(很有好處),C++提供最小限度的支持(有時會帶來很多煩惱),Java位於上述兩者之間,類也是對象,類可以有屬性‘雇員’類可以有一個包含其所有實例的列表(list)‘彩票’類可以有一個種子(seed)用於產生隨機票號,該種子被所有實例共享,類可以有行為,雇員”類可以有getEmployeeBySerialNum行為。‘彩票’類可以有generateRandomNumber行為。

封裝

大B:“隻暴露相關的細節,即公有接口(publicinterface)。”

小A:“封裝什麽?如何封裝?”

大B:“隱藏‘齒輪和控製杆’隻暴露客戶需要的職責,防止對象受到外界幹擾,防止其它對象依賴可能變化的細節,信息隱藏有助於對象和模塊之間的鬆散耦合,使得設計更加靈活,更易於重用,減少代碼之間的依賴,‘有好籬笆才有好鄰居’。例如:汽車的氣動踏板。”

小A:“怎樣才能更好地實踐?”

大B:“最佳實踐:對象之間隻通過方法(函數)互相訪問。切忌直接訪問屬性。”

classPerson{

publicintage;

}

classBetterPerson{

privateintage;//changetodateOfBirth

publicintgetAge(){returnage;}

}

更完善的Person類可能是:privatedateOfBirth

抽象

小A:“什麽是抽象?”

大B:“抽象使得泛化(generalizaions)成為可能,簡化問題-忽略複雜的細節,關注共性,並且允許變更,人類經常使用泛化。當你看見約翰和簡家裏的那頭灰德國牧羊犬時,你有沒有……想到‘狗’這個詞?抽象同樣能簡化計算機程序。例如,軟件中有兩個重要抽象:客戶端和服務器(clientsandservers)。”

小A:“喔。”

大B:“在圖形用戶界麵中,係統可能會詢問用戶各種問題:是或不是多選一?輸入數字,任意文本問題統一處理這些問題會顯得很簡單,每一個問題都作為Question類的特例(specialization);程序隻需維護這些問題的實例列表,分別調用各自的askTheUser()方法。”

繼承

小A:“什麽是繼承?”

大B:“繼承用於描述一個類與其它類的不同之處。例如:類Y像類X,但有下列不同……”

小A:“為什麽使用繼承?”

大B:“你有兩種類型,其中一種是另一種的擴展。有時(不是所有時候)你想忽略對象之間的不同,而隻關注它們的共同之處(基類)。這就是泛化。假如某係統需要對不同的形狀進行操作(經典例子):有時你並不關心你正在操作的形狀的種類(例如,移動形狀時)有時你必須知道形狀的種類(在顯示器上繪製形狀)”

小A:“怎樣去理解派生類?”

大B:“派生類繼承自基類;派生類擴展了基類;派生類是基類的特殊化(specialization)。派生類能夠提供額外的狀態(數據成員),或額外的行為(成員函數/方法),或覆蓋所繼承的方法。基類是所有它的派生類的泛化。如:通常所有寵物都有名字。基類(BaseClass)=父類(parentclass)=超類(superclass)派生類(DerivedClass)=子類(childclass)=子類(subclass)”

小A:“喔。”

大B:“繼承含有(有些,不是全部)是一個(is-a)或是一種(is-a-kind-of)的關係,正方形是一種矩形(使用繼承),Leroy是一種狗(不使用繼承),傳統的過程分析和設計中不能很好地模擬這種關係。繼承是一種強有力的機製,使我們關注共性,而不是特定的細節。使得代碼可以重用且富有彈性(能適應變化)。”

小A:怎樣去實現繼承?

大B:“實現繼承(Implementationinheritance):派生類繼承基類的屬性和行為。”

小A:“又應該怎樣去接口繼承?”

大B:“接口繼承(Interfaceinheritance):類實現抽象接口的方法,保留既定語義(intendedsemantics)C++允許多重實現繼承。Java規定派生類隻能有一個基類,但可以繼承自多個接口。”

多態

小A:“什麽是多態?”

大B:“多態是一種允許多個類針對同一消息有不同的反應的能力。對於任何實現了給定接口的對象,在不明確指定類名的情況下,就可以使用。例如:question.askTheUser();當然,這些不同反應都有類似的本質盡可能使用接口繼承和動態(運行期)綁定Liskov替換原則:如果Y是X的子類,那麽在任何使用X實例的地方都可以用Y的實例來替換。”

演示多態的Java代碼

//File:question/QuestionTest.java

//下麵的代碼將輸出什麽?

//RefertotheBeginningJavalinkonthecoursewebsite.

packagequestion;

abstractclassQuestion{//Fullclassnameisquestion.QuestionTest

publicQuestion(Stringtext){//Constructor

theText=text;

}

publicabstractvoidaskTheUser();

protectedStringtheText;

}

classYesNoQuestionextendsQuestion{

publicYesNoQuestion(Stringtext){super(text);}

publicvoidaskTheUser(){

System.out.println(theText);

System.out.println(“YESorNO……?”);

}

}

classFreeTextQuestionextendsQuestion{

publicFreeTextQuestion(Stringtext){super(text);}

publicvoidaskTheUser(){

System.out.println(theText);

System.out.println(“Well……?Whatstheanswer……?”);

}

}

publicclassQuestionTest{

publicstaticvoidmain(String[]args){

Question[]questions=getQuestions();

for(inti=0;i