1、開閉原則開閉原則中“開”，是指對于組件功能的擴展是開放的，是允許對其進行功能擴展的；開閉原則中“閉”，是指對于原有代碼的修改是封閉的，即不應該修改原有的代碼。 import java.lang.*; interface Fruit public void plant(); public void blossom(); public void outcome(); class Apple implements Fruit Apple()this.plant(); public void plant()System.out.println("Plant a apple"); p

2、ublic void blossom()System.out.println("Apple blossomed"); public void outcome()System.out.println("Apple outcomed"); class Pear implements Fruit Pear()this.plant(); public void plant()System.out.println("Pear a apple"); public void blossom()System.out.println("Pea

3、r blossomed"); public void outcome()System.out.println("Pear outcomed"); interface gardenerBase /Garden,是不能改變的.以后增加一個水果只需要 再寫個類繼承它! public Fruit getFruit(); class AppleGardener implements gardenerBase/種植Apple的Garden private static AppleGardener singleton; private AppleGardener(); publ

4、ic static AppleGardener getGardener() if(singleton=null) singleton = new AppleGardener(); return singleton; public Fruit getFruit() return new Apple(); class PearGardener implements gardenerBase/種植Pear的Garden private static PearGardener singleton; private PearGardener(); public static PearGardener g

5、etGardener() if(singleton=null) singleton = new PearGardener(); return singleton; public Fruit getFruit() return new Pear(); public class MyFirstOCPJAVA public static void main(String a) Fruit tempApple; gardenerBase appleGarden = AppleGardener.getGardener(); tempApple = appleGarden.getFruit(); Frui

6、t tempPear; gardenerBase pearGarden = PearGardener.getGardener(); tempPear = pearGarden.getFruit(); 里氏代換原則一個軟件實體如果使用的是一個基類的話，那么一定適用于其子類。而且它覺察不出基類對象和子類對象的區別。也就是說,在軟件里面,把基類都替換成它的子類,程序的行為沒有變化。反過來的代換不成立，如果一個軟件實體使用的是一個子類的話，那么它不一定適用于基類。里氏代換原則的四層含義1）子類必須完全實現父類的方法。在類中調用其他類是務必要使用父類或接口，如果不能使用父類或接口，則說明類的設計已經違背

7、了LSP原則。2）子類可以有自己的個性。子類當然可以有自己的行為和外觀了，也就是方法和屬性3）覆蓋或實現父類的方法時輸入參數可以被放大。即子類可以重載父類的方法，但輸入參數應比父類方法中的大，這樣在子類代替父類的時候，調用的仍然是父類的方法。即以子類中方法的前置條件必須與超類中被覆蓋的方法的前置條件相同或者更寬松。4）覆蓋或實現父類的方法時輸出結果可以被縮小。4、里氏代換原則在設計模式中的體現 策略模式（Strategy） 如果有一組算法，那么就將算法封裝起來，使得它們可以互換。客戶端依賴于基類類型，而變量的真實類型則是具體策略類。這是具體策略焦色可以“即插即用”的關鍵。 合成模式（Compo

8、site） 合成模式通過使用樹結構描述整體與部分的關系，從而可以將單純元素與符合元素同等看待。由于單純元素和符合元素都是抽象元素角色的子類，因此兩者都可以替代抽象元素出現在任何地方。里氏代換原則是合成模式能夠成立的基礎。 代理模式（Proxy） 代理模式給某一個對象提供一個代理對象，并由代理對象控制對原對象的引用。代理模式能夠成立的關鍵，就在于代理模式與真實主題模式都是抽象主題角色的子類。客戶端只知道抽象主題，而代理主題可以替代抽象主題出現在任何需要的地方，而將真實主題隱藏在幕后。里氏代換原則是代理模式能夠成立的基礎。public interface Quadrangle public lon

9、g getWidth() ; public long getHeight() ;public class Rectangle implements Quadrangle private long width ; private long height ; public void setWidth(long width) this.width = width ; public void setHeight(long height) this.height = height ; public long getWidth() return this.width ; public long getHe

10、ight() return this.height ; public class Square implements Quadrangle private long side ; public void setSide(long side) this.side = side ; public long getSide() return this.side ; public long getWidth() return getSide() ; public long getHeight() return getSide() ; public class Test public static vo

11、id main(String args) public void resizeQuadrangle r) while(r.getWidth <= r.getHeight) r.setWidth(r.getWidth() + 1) ; 合成/聚合復用原則（CARP）：又稱合成復用原則(CRP),就是在一個新的對象里面使用一些已有的對象，使之成為新對象的一部分；新的對象通過向這些對象的委派達到復用已有功能的目的。簡而言之就是：要盡量使用合成/聚合，盡量不要使用繼承。依賴倒轉原則依賴倒轉原則的一種表述是：細節應當依賴與抽象，抽象不應當依賴于細節。 另一種描述是：要針對接口編程，不要針對實現編程

12、。意思就是應當使用接口和抽象類而不是具體類進行變量的類型聲明、參數的類型聲明、方法的返回類型聲明以 及數據類型的轉換等。要保證這一點，一個具體java類應當只實現java接口和抽象java類中聲明過的方法，而不應當給出多余的方法。 1 /Dependency Inversion Principle - Good example2 interface IWorker 3 publicvoid work(); 4 5 class Worker implements IWorker 6 publicvoid work() 7 / .working8 9 10 class SuperWorker im

13、plements IWorker 11 publicvoid work() 12 /. working much more13 14 15 class Manager 16 IWorker m_worker; 17 publicvoid setWorker(IWorker w) 18 m_worker=w; 19 20 publicvoid manage() 21 m_worker.work(); 22 23 接口隔離下面是實現的代碼./-這兒不用接口繼承,因為可能出現修改了父接口影響了子接口interface IOrderForPortal String getOrder();interfa

14、ce IOrderForOtherSys String insertOrder(); String getOrder();interface IOrderForAdmin /extends IOrderForPortal,IOrderForOtherSys String deleteOrder(); String updateOrder(); String insertOrder(); String getOrder();/*interface IOrderForPortal String getOrder();interface IOrderForOtherSys String insert

15、Order();interface IOrderForAdmin extends IOrderForPortal,IOrderForOtherSys String updateOrder(); String deleteOrder();*/class Order implements IOrderForPortal,IOrderForOtherSys,IOrderForAdmin private Order() /-什么都不干,就是為了不讓直接 new,防止客戶端直接New,然后訪問它不需要的方法. /返回給Portal public static IOrderForPortal getOrd

16、erForPortal() return (IOrderForPortal)new Order(); /返回給OtherSys public static IOrderForOtherSys getOrderForOtherSys() return (IOrderForOtherSys)new Order(); /返回給Admin public static IOrderForAdmin getOrderForAdmin() return (IOrderForAdmin)new Order(); /-下面是接口方法的實現.只是返回了一個String用于演示- public String get

17、Order() return "implemented getOrder" public String insertOrder() return "implemented insertOrder" public String updateOrder() return "implemented updateOrder" public String deleteOrder() return "implemented deleteOrder" public class TestCreateLimit public sta

18、tic void main(String args) IOrderForPortal orderForPortal = Order.getOrderForPortal(); IOrderForOtherSys orderForOtherSys = Order.getOrderForOtherSys(); IOrderForAdmin orderForAdmin = Order.getOrderForAdmin(); System.out.println("Portal門戶調用方法:"+orderForPortal.getOrder(); System.out.println

19、("OtherSys外部系統調用方法:"+orderForOtherSys.insertOrder(); System.out.println("Admin管理后臺調用方 法:"+orderForAdmin.getOrder()+""+orderForAdmin.insertOrder()+""+orderForAdmin.updateOrder()+""+orderForAdmin.deleteOrder(); 迪米特法則一個軟件實體應當盡可能少的與其他實體發生相互作用。每一個軟件單位對其他的

20、單位都只有最少的知識，而且局限于那些與本單位密切相關的軟件單位。迪米特法則的初衷在于降低類之間的耦合。由于每個類盡量減少對其他類的依賴，因此，很容易使得系統的功能模塊功能獨立，相互之間不存在（或很少有）依賴關系。public class SomeOne public void operator1(Friend friend) Stranger stranger=vide(); stranger.operation3(); public class Friend private Stranger stranger=new Stranger(); public void ope

21、ration2() public Stranger provide() return stranger; 顯然，SomeOne的方法operation1()不滿足迪米特法則，因為這個方法引用了Stranger對象，而Stranger對象不是SomeOne的朋友。public class SomeOne public void operation1(Friend friend) friend.forward(); SomeOne通過調用自己朋友Friend對象的forward()方法作到了原來需要調用Stranger對象才能做到的事情。public class Friend private St

22、ranger stranger=new Stranger(); public void operation2() public void forward() stranger.operation3(); 在系統的某一個類需要修改時，僅僅會直接影響到這個類的“朋友們”，而不會直接影響到其他部分。Factory Method定義一個用于創建對象的接口，讓子類決定實例化哪一個類。Factory Method 使一個類的實例化延遲到其子類。適用性 當一個類不知道它所必須創建的對象的類的時候。當一個類希望由它的子類來指定它所創建的對象的時候。當類將創建對象的職責委托給多個幫助子類中的某一個，并且你希望將

23、哪一個幫助子類是代理者這一信息局部化的時候。按照圖1中所定義的結構寫了下面的一段演示代碼.這段代碼的作用是創建不同的Shape實例,每個實例完成兩個操作:draw和erase.具體的創建過程委托?oShapeFactory來完成.1.a 首先定義一個抽象類Shape,定義兩個抽象的方法.1abstractclassShape 23/勾畫shape45publicabstractvoiddraw();67/擦去 shape89publicabstractvoiderase();1011publicString name;1213publicShape(String aName)1415name=

24、aName;1617181920211.b 定義 Shape的兩個子類: Circle, Square,實現Shape中定義的抽象方法1/圓形子類23classCircleextendsShape 45publicvoiddraw() 67System.out.println("It will draw a circle.");891011publicvoiderase() 1213System.out.println("It will erase a circle.");14151617/構造函數1819publicCircle(String aNam

25、e)2021super(aName);222324252627/方形子類2829classSquareextendsShape 3031publicvoiddraw() 3233System.out.println("It will draw a square.");34353637publicvoiderase() 3839System.out.println("It will erase a square.");40414243/構造函數4445publicSquare(String aName)4647super(aName);4849505152

26、531.c 定義抽象的創建器,anOperation調用factoryMethod創建一個對象,并對該對象進行一系列操作.1abstractclassShapeFactory 23protectedabstractShape factoryMethod(String aName);45/在anOperation中定義Shape的一系列行為67publicvoidanOperation(String aName)89Shape s=factoryMethod(aName);1011System.out.println("The current shape is:"+s.nam

27、e);1213s.draw();1415s.erase();1617181920211.d 定義與circle和square相對應的兩個具體創建器CircleFactory,SquareFactory,實現父類的methodFactory方法1/定義返回 circle 實例的 CircleFactory23classCircleFactoryextendsShapeFactory 45/重載factoryMethod方法,返回Circle對象67protectedShape factoryMethod(String aName) 89returnnewCircle(aName+"(c

28、reated by CircleFactory)");101112131415/定義返回 Square 實例的 SquareFactory1617classSquareFactoryextendsShapeFactory 1819/重載factoryMethod方法,返回Square對象2021protectedShape factoryMethod(String aName) 2223returnnewSquare(aName+"(created by SquareFactory)");242526272829 1.e 測試類:請注意這個客戶端程序多么簡潔,既沒

29、有羅嗦的條件判斷語句,也無需關心ConcreteProduct和ConcreteCreator的細節 (因為這里我用anOperation封裝了Product里的兩個方法,所以連Product的影子也沒看見,當然把Product里方法的具體調用放 到客戶程序中也是不錯的).1classMain 23publicstaticvoidmain(String args)45ShapeFactory sf1=newSquareFactory();67ShapeFactory sf2=newCircleFactory();89sf1.anOperation("Shape one");

30、1011sf2.anOperation("Shape two");121314151617運行結果如下:1The current shape is: Shape one (created by SquareFactory)23It will draw a square.45It will erase a square.67The current shape is: Shape two (created by CircleFactory)89It will draw a circle.1011It will erase a circle.1213 參數化的Factory Me

31、thod: 這種方式依靠指定的參數作為標志來創建對應的實例,這是很常見的一種辦法.比如JFC中的BorderFactory就是個很不錯的例子. 以下的這個例子是用字符串作為標記來進行判斷的,如果參數的類型也不一樣,那就可以用到過載函數來解決這個問題,定義一系列參數和方法體不同的同名函數, 這里java.util.Calendar.getInstance()又是個極好的例子.參數化的創建方式克服了Factory Method模式一個最顯著的缺陷,就是當具體產品比較多時,我們不得不也建立一系列與之對應的具體構造器. 但是在客戶端我們必須指定參數來決定要創建哪一個類.2.a 我們在第一種方法的基礎上

32、進行修改,首先自定義一個的異常,這樣當傳入不正確的參數時可以得到更明顯的報錯信息.1classNoThisShapeextendsException 23publicNoThisShape(String aName) 45super(aName);678910112.b去掉了ShapeFactory的兩個子類,改為由ShapeFactory直接負責實例的創建. ShapeFactory自己變成一個具體的創建器,直接用參數化的方法實現factoryMethod返回多種對象.1abstractclassShapeFactory 23privatestaticShape s;45privateSha

33、peFactory() 67staticShape factoryMethod(String aName, String aType)throwsNoThisShape89if(aTpareTo("square")=0)1011returnnewSquare(aName);1213elseif(aTpareTo("circle")=0)1415returnnewCircle(aName);1617elsethrownewNoThisShape(aType);18192021/在anOperation中定義Shape的一系列行為2223staticvoid

34、anOperation(String aName, String aType)throwsNoThisShape2425s=factoryMethod(aName, aType);2627System.out.println("The current shape is:"+);2829s.draw();3031s.erase();3233343536372.c 測試類:這里客戶端必須指定參數來決定具體創建哪個類.這個例子里的anOperation是靜態函數,可以直接引用.1classMain 23publicstaticvoidmain(String args)

35、throwsNoThisShape45ShapeFactory.anOperation("Shape one","circle");67ShapeFactory.anOperation("Shape two","square");89ShapeFactory.anOperation("Shape three","delta");101112131415運行結果如下:1classMain 23publicstaticvoidmain(String args)throwsNoTh

36、isShape45ShapeFactory.anOperation("Shape one","circle");67ShapeFactory.anOperation("Shape two","square");89ShapeFactory.anOperation("Shape three","delta");101112131415Abstract Factory提供一個創建一系列相關或相互依賴對象的接口，而無需指定它們具體的類。 適用性 一個系統要獨立于它的產品的創建、組合

37、和表示時。 一個系統要由多個產品系列中的一個來配置時。 當你要強調一系列相關的產品對象的設計以便進行聯合使用時。 當你提供一個產品類庫，而只想顯示它們的接口而不是實現時。圖中，我們可以看到，客戶需要得到某系列的產品的時候，直接用相應的工廠子類來創建產品就可以了。比如，當需要生產Fit時，就用FitFactory，等到換班之后，要生產Odyssey了，直接使用OdysseyFactory替換FitFactory就行了，至于怎么替換就隨便了，GoF也給了我們一些建議，我將在后面總結創建型模式的時候講。把上面的類圖轉換成代碼，應該是這個樣子。 關于車門的類：publicabstractclass A

38、bstractDoor publicclass FitDoor : AbstractDoor publicclass OdysseyDoor : AbstractDoor 關于底盤的類：publicabstractclass AbstractChassis publicclass FitChassis : AbstractChassis publicclass OdysseyChassis : AbstractChassis 關于工廠的類：publicabstractclass HondaFactory publicabstract AbstractDoor CreateDoor();publ

39、icabstract AbstractChassis CreateChassis(); publicclass FitFactory public AbstractDoor CreateDoor() returnnew FitDoor(); public AbstractChassis CreateChassis() returnnew FitChassis(); publicclass OdysseyFactory public AbstractDoor CreateDoor() returnnew OdysseyDoor(); public AbstractChassis CreateCh

40、assis() returnnew OdysseyChassis(); 客戶的調用：publicclass Client private AbstractDoor _door;private AbstractChassis _chassis;private HondaFactory _factory;publicvoid GetACar(string seriesName) this.PrepareFactory(seriesName);this._door = this._factory.CreateDoor();this._chassis = this._factory.CreateCha

41、ssis();/ TODO: Make a car! privatevoid PrepareFactory(string seriesName) switch(seriesName) case "Fit":this._factory = new FitFactory();break;case "Odyssey":this._factory = new OdysseyFactory();break; Builder將一個復雜對象的構建與它的表示分離，使得同樣的構建過程可以創建不同的表示。適用性 當創建復雜對象的算法應該獨立于該對象的組成部分以及它們的裝配方

42、式時。 當構造過程必須允許被構造的對象有不同的表示時。拿廣本來打比方。廣本的四個車間，最開頭的是沖壓科，而在沖壓科的門口有一間小房子，里面放了一臺激光焊接機，它用它的機械手臂抓起旁邊放著的各種各樣 的鋼板，不停的焊接。可能有人要問，這是什么例子？這就是生成器！一般來說，汽車各處外殼的厚度以及硬度是不同的，比如車頭部分就要夠硬（用來撞的_）， 其他一些地方比如車頂就沒有必要用超厚的鋼板。這樣，一來可以降低整車的質量，可以省油；二來可以降低成本（所以廣本暴利啊其實其他汽車廠家也這么 干）先前所講的焊接機就是干這個事情的，它將各種不同厚度不同硬度的鋼板焊接在一起，供那些巨型的沖壓機來沖壓成型，以生產

43、汽車的各個不同的部分。各種汽 車所使用的合成鋼板的組成是不一樣的，但沖壓機不管那么多，它只管壓鋼板。這樣一來就明白了吧？焊接機將各種鋼板按照規定焊接成不同組成的合成鋼板，至于 它是如何焊接的以及合成鋼板的組成，沖壓機對這些信息是不關心的。我們來看一個類圖。publicclass Steel publicobject Part00;publicobject Part01;publicobject Part10;publicobject Part11; publicclass WeldingProgramme object _materials;public WeldingProgramme()

44、this._materials = newobject4;/ TODO: Add some materials public Steel Go() SteelWelder sw = new SteelWelder();foreach(object m inthis._materials) sw.WeldSteel(m); / you can weld the steel like this / sw.WeldSteel(this._materials3); / sw.WeldSteel(this._materials2); / sw.WeldSteel(this._materials1); /

45、 sw.WeldSteel(this._materials0); / also, you can do it like this / sw.WeldSteel(this._materials2); / sw.WeldSteel(this._materials1); / sw.WeldSteel(this._materials0); / sw.WeldSteel(this._materials3);return sw.GetSteel(); publicclass SteelWelder Steel _steel;publicvoid WeldSteel(object materials) if

46、(this._steel = null)this._steel = new Steel();if(this._steel.Part00 = null) this._steel.Part00 = materials; elseif(this._steel.Part01 = null) this._steel.Part01 = materials; elseif(this._steel.Part10 = null) this._steel.Part10 = materials; elseif(this._steel.Part11 = null) this._steel.Part11 = mater

47、ials; else thrownew Exception("what do you want?"); public Steel GetSteel() returnthis._steel; publicclass Punch private Steel _steel;publicvoid Work() WeldingProgramme wp = new WeldingProgramme();this._steel = wp.Go();/ TODO: Punch the Steel Prototype用原型實例指定創建對象的種類，并且通過拷貝這些原型創建新的對象。 適用性 當

48、要實例化的類是在運行時刻指定時，例如，通過動態裝載；或者為了避免創建一個與產品類層次平行的工廠類層次時；當一個類的實例只能有幾個不同狀態組合中的一種時。建立相應數目的原型并克隆它們可能比每次用合適的狀態手工實例化該類更方便一些。生物細胞的自身復制；根據產品模型生產產品等等Prototype模式的模型定義： Prototype +clone():Prototype 即：原型類Prototype 提供clone()方法，實現對對象自身的復制（克隆）。 UML類圖： Prototype模式的實現范例下面我們使用Prototype模式來實現細胞（Cell）的自身復制過程。 Java語言提供了對象復制的

49、機制，Prototype模式的Java實現一般也通過實現Cloneable接口來實現。 這里我們也通過實現Cloneable接口來說明Prototype模式。1 public class Cell implements Cloneable 2 /細胞壁 3 private String cellWall; 4 /細胞膜 5 private String cellMembrane; 6 /細胞組織 7 private String cellularTissue; 8 ./這里省略掉了對成員變量的setter/getter方法的定義 9 /細胞的自身復制 10 /這里重載了Obect#clone(

50、)方法，為了方便外部調用，把返回值由Object修改為Cell，并把訪問級別設置為public 11 public Cell clone() 12 try 13 /只需簡單地調用super.clone();即可 14 return (Cell) super .clone(); 15 catch (CloneNotSupportedException e) 16 throw ( new InternalError(e.getMessage(); 17 18 19 20 /調用方： 21 public class Client 22 public static void main(String a

51、rgs) 23 /準備原型細胞 24 Cell cell = new Cell(); 25 cell.setCellWall("cell wall 1" ); 26 . 27 /克隆原型細胞 28 Cell clonedCell = cell.clone(); 29 . 30 /操作被克隆的細胞（略） 31 32 Singleton保證一個類僅有一個實例，并提供一個訪問它的全局訪問點。 適用性 當類只能有一個實例而且客戶可以從一個眾所周知的訪問點訪問它時。 當這個唯一實例應該是通過子類化可擴展的，并且客戶應該無需更改代碼就能使用一個擴展的實例時。public class S

52、ingleton private static Singleton instance = null; public static synchronized Singleton getInstance() if (instance=null) instancenew Singleton(); return instance; Adapter將一個類的接口轉換成客戶希望的另外一個接口。A d a p t e r 模式使得原本由于接口不兼容而不能一起工作的那些類可以一起工作。 適用性 你想使用一個已經存在的類，而它的接口不符合你的需求。 你想創建一個可以復用的類，該類可以與其他不相關的類或不可預見的類（即那些接口可能不一定兼容的類）協同工作。 （僅適用于對象A d a p t e r ）你想使用一些已經存在的子類，但是不可能對每一個都進行子類化以匹配它們的接口。對象適配器可以適配它的父類接口。我們就使用設計模式精解里面的場景，現在有一個圖形類，此類的行為有： 設定一個Shape對象的位置 獲取一個Shape對象的位置 顯示一個Shape對象（display） 填充一個Shape對象（fill） 設置一個Shape對象的顏色 擦除一個S