原文地址：http://blog.csdn.net/zhangerqing

一、設計模式的分類

總體來說設計模式分為三大類：

建立型模式，共五種：工廠方法模式、抽象工廠模式、單例模式、建造者模式、原型模式。

結構型模式，共七種：介面卡模式、裝飾器模式、代理模式、外觀模式、橋接模式、組合模式、享元模式。

行為型模式，共十一種：策略模式、模板方法模式、觀察者模式、迭代子模式、責任鏈模式、命令模式、備忘錄模式、狀態模式、訪問者模式、中介者模式、直譯器模式。

其實還有兩類：併發型模式和執行緒池模式。用一個圖片來整體描述一下：

二、設計模式的六大原則

總原則：開閉原則（Open Close Principle）

開閉原則就是說對擴充套件開放，對修改關閉。在程式需要進行拓展的時候，不能去修改原有的程式碼，而是要擴充套件原有程式碼，實現一個熱插拔的效果。所以一句話概括就是：為了使程式的擴充套件性好，易於維護和升級。想要達到這樣的效果，我們需要使用介面和抽象類等，後面的具體設計中我們會提到這點。

1、單一職責原則

不要存在多於一個導致類變更的原因，也就是說每個類應該實現單一的職責，如若不然，就應該把類拆分。

2、里氏替換原則（Liskov Substitution Principle）

里氏代換原則(Liskov Substitution Principle LSP)面向物件設計的基本原則之一。 里氏代換原則中說，任何基類可以出現的地方，子類一定可以出現。 LSP是繼承複用的基石，只有當衍生類可以替換掉基類，軟體單位的功能不受到影響時，基類才能真正被複用，而衍生類也能夠在基類的基礎上增加新的行為。里氏代換原則是對“開-閉”原則的補充。實現“開-閉”原則的關鍵步驟就是抽象化。而基類與子類的繼承關係就是抽象化的具體實現，所以里氏代換原則是對實現抽象化的具體步驟的規範。—— From Baidu 百科

歷史替換原則中，子類對父類的方法儘量不要重寫和過載。因為父類代表了定義好的結構，通過這個規範的介面與外界互動，子類不應該隨便破壞它。

3、依賴倒轉原則（Dependence Inversion Principle）

這個是開閉原則的基礎，具體內容：面向介面程式設計，依賴於抽象而不依賴於具體。寫程式碼時用到具體類時，不與具體類互動，而與具體類的上層介面互動。

4、介面隔離原則（Interface Segregation Principle）

這個原則的意思是：每個介面中不存在子類用不到卻必須實現的方法，如果不然，就要將介面拆分。使用多個隔離的介面，比使用單個介面（多個介面方法集合到一個的介面）要好。

5、迪米特法則（最少知道原則）（Demeter Principle）

就是說：一個類對自己依賴的類知道的越少越好。也就是說無論被依賴的類多麼複雜，都應該將邏輯封裝在方法的內部，通過public方法提供給外部。這樣當被依賴的類變化時，才能最小的影響該類。

最少知道原則的另一個表達方式是：只與直接的朋友通訊。類之間只要有耦合關係，就叫朋友關係。耦合分為依賴、關聯、聚合、組合等。我們稱出現為成員變數、方法引數、方法返回值中的類為直接朋友。區域性變數、臨時變數則不是直接的朋友。我們要求陌生的類不要作為區域性變量出現在類中。

6、合成複用原則（Composite Reuse Principle）

原則是儘量首先使用合成/聚合的方式，而不是使用繼承。

三、Java的23中設計模式

A、建立模式

從這一塊開始，我們詳細介紹Java中23種設計模式的概念，應用場景等情況，並結合他們的特點及設計模式的原則進行分析。

首先，簡單工廠模式不屬於23中涉及模式，簡單工廠一般分為：普通簡單工廠、多方法簡單工廠、靜態方法簡單工廠。

0、簡單工廠模式

簡單工廠模式模式分為三種：

01、普通

就是建立一個工廠類，對實現了同一介面的一些類進行例項的建立。首先看下關係圖：

舉例如下：（我們舉一個傳送郵件和簡訊的例子）

首先，建立二者的共同介面：

1. publicinterface Sender {  
2.     publicvoid Send();  
3. }  

其次，建立實現類：

1. publicclass MailSender implements Sender {  
2.     @Override
3.     publicvoid Send() {  
4.         System.out.println("this is mailsender!");  
5.     }  
6. }  

1. publicclass SmsSender implements Sender {  
2.     @Override
3.     publicvoid Send() {  
4.         System.out.println("this is sms sender!");  
5.     }  
6. }  

最後，建工廠類：

1. publicclass SendFactory {  
2.     public Sender produce(String type) {  
3.         if ("mail".equals(type)) {  
4.             returnnew MailSender();  
5.         } elseif ("sms".equals(type)) {  
6.             returnnew SmsSender();  
7.         } else {  
8.             System.out.println("請輸入正確的型別!");  
9.             returnnull;  
10.         }  
11.     }  
12. }  

我們來測試下：

1. publicclass FactoryTest {  
2.     publicstaticvoid main(String[] args) {  
3.         SendFactory factory = new SendFactory();  
4.         Sender sender = factory.produce("sms");  
5.         sender.Send();  
6.     }  
7. }  

輸出：this is sms sender!

02、多個方法

是對普通工廠方法模式的改進，在普通工廠方法模式中，如果傳遞的字串出錯，則不能正確建立物件，而多個工廠方法模式是提供多個工廠方法，分別建立物件。關係圖：

將上面的程式碼做下修改，改動下SendFactory類就行，如下：

[java] view plaincopypublicclass SendFactory {   public Sender produceMail(){  

1.         returnnew MailSender();  
2.     }  
3.     public Sender produceSms(){  
4.         returnnew SmsSender();  
5.     }  
6. }  

測試類如下：

1. publicclass FactoryTest {  
2.     publicstaticvoid main(String[] args) {  
3.         SendFactory factory = new SendFactory();  
4.         Sender sender = factory.produceMail();  
5.         sender.Send();  
6.     }  
7. }  

輸出：this is mailsender!

03、多個靜態方法

將上面的多個工廠方法模式裡的方法置為靜態的，不需要建立例項，直接呼叫即可。

1. publicclass SendFactory {  
2.     publicstatic Sender produceMail(){  
3.         returnnew MailSender();  
4.     }  
5.     publicstatic Sender produceSms(){  
6.         returnnew SmsSender();  
7.     }  
8. }  

1. publicclass FactoryTest {  
2.     publicstaticvoid main(String[] args) {      
3.         Sender sender = SendFactory.produceMail();  
4.         sender.Send();  
5.     }  
6. }  

輸出：this is mailsender!

總體來說，工廠模式適合：凡是出現了大量的產品需要建立，並且具有共同的介面時，可以通過工廠方法模式進行建立。在以上的三種模式中，第一種如果傳入的字串有誤，不能正確建立物件，第三種相對於第二種，不需要例項化工廠類，所以，大多數情況下，我們會選用第三種——靜態工廠方法模式。

1、工廠方法模式（Factory Method）

簡單工廠模式有一個問題就是，類的建立依賴工廠類，也就是說，如果想要拓展程式，必須對工廠類進行修改，這違背了閉包原則，所以，從設計角度考慮，有一定的問題，如何解決？就用到工廠方法模式，建立一個工廠介面和建立多個工廠實現類，這樣一旦需要增加新的功能，直接增加新的工廠類就可以了，不需要修改之前的程式碼。

請看例子：

1. publicinterface Sender {  
2.     publicvoid Send();  
3. }  

兩個實現類：

1. publicclass MailSender implements Sender {  
2.     @Override
3.     publicvoid Send() {  
4.         System.out.println("this is mailsender!");  
5.     }  
6. }  

1. publicclass SmsSender implements Sender {  
2.     @Override
3.     publicvoid Send() {  
4.         System.out.println("this is sms sender!");  
5.     }  
6. }  

兩個工廠類：

1. publicclass SendMailFactory implements Provider {  
2.     @Override
3.     public Sender produce(){  
4.         returnnew MailSender();  
5.     }  
6. }  

1. publicclass SendSmsFactory implements Provider{  
2.     @Override
3.     public Sender produce() {  
4.         returnnew SmsSender();  
5.     }  
6. }  

在提供一個介面：

1. publicinterface Provider {  
2.     public Sender produce();  
3. }  

測試類：

1. publicclass Test {  
2.     publicstaticvoid main(String[] args) {  
3.         Provider provider = new SendMailFactory();  
4.         Sender sender = provider.produce();  
5.         sender.Send();  
6.     }  
7. }  

其實這個模式的好處就是，如果你現在想增加一個功能：發及時資訊，則只需做一個實現類，實現Sender介面，同時做一個工廠類，實現Provider介面，就OK了，無需去改動現成的程式碼。這樣做，拓展性較好！

2、抽象工廠模式

工廠方法模式和抽象工廠模式不好分清楚，他們的區別如下：

<span style="background-color: rgb(255, 255, 255);">工廠方法模式：
一個抽象產品類，可以派生出多個具體產品類。   
一個抽象工廠類，可以派生出多個具體工廠類。   
每個具體工廠類只能建立一個具體產品類的例項。

抽象工廠模式：
多個抽象產品類，每個抽象產品類可以派生出多個具體產品類。   
一個抽象工廠類，可以派生出多個具體工廠類。   
每個具體工廠類可以建立多個具體產品類的例項，也就是建立的是一個產品線下的多個產品。   
    
區別：
工廠方法模式只有一個抽象產品類，而抽象工廠模式有多個。   
工廠方法模式的具體工廠類只能建立一個具體產品類的例項，而抽象工廠模式可以建立多個。</span>

<span style="background-color: rgb(255, 255, 255);"><span style="font-family: Helvetica, Tahoma, Arial, sans-serif; line-height: 25.1875px;">工廠方法建立 "一種" 產品，他的著重點在於"怎麼建立"，也就是說如果你開發，你的大量程式碼很可能圍繞著這種產品的構造，初始化這些細節上面。也因為如此，類似的產品之間有很多可以複用的特徵，所以會和模版方法相隨。 </span><br style="font-family: Helvetica, Tahoma, Arial, sans-serif; line-height: 25.1875px;" /><br style="font-family: Helvetica, Tahoma, Arial, sans-serif; line-height: 25.1875px;" /><span style="font-family: Helvetica, Tahoma, Arial, sans-serif; line-height: 25.1875px;">抽象工廠需要建立一些列產品，著重點在於"建立哪些"產品上，也就是說，如果你開發，你的主要任務是劃分不同差異的產品線，並且儘量保持每條產品線介面一致，從而可以從同一個抽象工廠繼承。</span></span>

            
  
           

              
              
            
            
相關推薦
			   
            
            
            
 

    

    
    
[設計模式]二十三種設計模式
     
 

原文地址：http://blog.csdn.net/zhangerqing
一、設計模式的分類

總體來說設計模式分為三大類：

建立型模式，共五種：工廠方法模式、抽象工廠模式、單例模式、建造者模式、原型模式。

結構型模式，共七種：介面卡模式、裝飾器模式、代理模式、外觀模式、橋接模式、 

  
 

    

    
    
二十三種設計模式 羅列
     
 dap   flyweight   osi   設計   eth   ora   備忘錄   mem   esp   1、工廠方法模式（Factory Method）
2、抽象工廠模式（Abstract Factory）
3、單例模式（Singleton）
4、建造者模式（Builder）
5、原型模式（Pr 

  
 

    

    
    
[系列匯總] - 二十三種設計模式（持續更新中…）
     
 prot   不同   hellip   rac   pro   抽象   trac   pattern   .html   摘要       最近在讀GOF的Design Patterns: Elements of Reusable Object-Oriented Software（設計模式：可復用面向對象 

  
 

    

    
    
（轉）二十三種設計模式及其python實現
     
 本文原始碼寄方於github:https://github.com/w392807287/Design_pattern_of_python 
參考文獻： 
《大話設計模式》——吳強 
《Python設計模式》——pythontip.com 
《23種設計模式》——http://www.cnblogs.com/ 

  
 

    

    
    
二十三種設計模式[13] - 職責鏈模式(Chain Of Responsibility)
     
 前言
       職責鏈模式，屬於物件行為型模式。你可以想象成有一排人等著幫你處理問題，你只需要將你的問題告訴第一個人然後等待結果即可。如果第一個人處理不了這個問題，他會將這個問題告訴第二個人，以此類推。但並不意味著你的問題一定會被解決。
&nbs 

  
 

    

    
    
Java二十三種設計模式
     
  
  
  
 java 23種設計模式 深入理解  以下是學習過程中查詢的資料,別人總結的資料,比較容易理解(站在各位巨人的肩膀上,望博主勿究) 
 建立型  抽象工廠 http://www.cnblogs.com/java-my-life/archive/2012/03/28/2418836.html  

  
 

    

    
    
二十三種設計模式[14] - 命令模式(Command Pattern)
     
 前言
       命令模式，物件行為型模式的一種。它幫助我們將功能的呼叫者與實現者之間解耦（甚至完全解耦）。呼叫者與實現者之間並不是直接引用關係，呼叫者只需要知道如何傳送當前功能的請求即可，而不用關心該請求由誰在何時完成。
   

  
 

    

    
    
java基礎總結(三十三)--二十三種設計模式
     
  
 
 來自：https://www.cnblogs.com/geek6/p/3951677.html 
   
   
 一、設計模式的分類 
 總體來說設計模式分為三大類： 
 建立型模式，共五種：工廠方法模式、抽象工廠模式、單例模式、建造者模式、原型模式。 
 結構型模式，共七種： 

  
 

    

    
    
二十三種設計模式[15] - 解釋器模式(Interpreter)
     
 pub   move   以及   exce   aps   ret   行為型   根節點   key   前言       解釋器模式，類行為型模式。一種用來解釋特定文法（語言的語法和表達式）規則的方式。這種行為模式使用了類似組合的結構來構建一個抽象語法樹(Abstract Syntax Tree，AST 

  
 

    

    
    
二十三種設計模式[16] - 迭代器模式(Iterator Pattern)
     
 前言
       迭代器模式，屬於物件行為型模式。它的目的是將一個集合物件的迭代與其本身分離，使這個聚合物件更單純，並且在遍歷的同時不需要暴露該聚合物件的內部結構。
       在《設計 

  
 

    

    
    
二十三種設計模式[1] - 工廠方法(Factory Method)
     
 前言 
       工廠方法，又名工廠模式，屬於建立型模式。 
       其目的是通過定義一個用於建立物件的介面，讓子類決定例項化哪一個類，使一個類的例項化延遲到子類。 
  

  
 

    

    
    
二十三種設計模式[12] - 代理模式(Proxy Pattern)
     
 前言 
       代理模式，屬於物件結構型模式。在《設計模式 - 可複用的面向物件軟體》一書中將之描述為“ 為其它物件提供一種代理以控制對這個物件的訪問 ”。 
       在代理模式 

  
 

    

    
    
二十三種設計模式[11] - 享元模式(Flyweight Pattern)
     
 摘要
       享元模式，物件結構型模式的一種。在《設計模式 - 可複用的面向物件軟體》一書中將之描述為“ 運用共享技術有效地支援大量細粒度的物件 ”。
       在享元模式中，通過 

  
 

    

    
    
二十三種設計模式[10] - 外觀模式(Facade Pattern)
     
 前言
       外觀模式，又稱門面模式，物件結構型模式。在《設計模式 - 可複用的面向物件軟體》一書中將之描述為“ 為系統中的一組介面提供一個一致的介面，Facade模式定義了一個高層介面，這個介面使得這一子系統更加容易使用 ”。
模式

需要角 

  
 

    

    
    
二十三種設計模式[9] - 裝飾模式(Decorator Pattern)
     
 前言
       裝飾模式，屬於物件結構型模式。在《設計模式 - 可複用的面向物件軟體》一書中將之描述為“ 動態地給一個物件新增一些額外的職責。就增加功能來說，Decorator模式相比生成子類更為靈活”。
   &n 

  
 

    

    
    
二十三種設計模式[15] - 直譯器模式(Interpreter Pattern)
     
 前言 
       直譯器模式，類行為型模式。一種用來解釋特定文法（語言的語法和表示式）規則的方式。這種行為模式使用了類似組合的結構來構建一個抽象語法樹(Abstract Syntax Tree，AST)，用來描述該直譯器所解釋的語法。如果你想要了 

  
 

    

    
    
二十三種設計模式[17] - 中介者模式(Mediator Pattern)
     
 前言
       在開發軟體的過程中，我們通常會將類設計的比較單純，使其複用性更高。但類間的相互引用又使得類本身在沒有其他類的支援下不能正常工作，導致其複用性降低。所以為了提高類的複用性我們需要儘可能的減少對其它類的引用，也就是說我們常說的解耦。中 

  
 

    

    
    
二十三種設計模式（三）
     
 12.外觀模式 
外觀模式（Facade）,隱藏了系統的複雜性，並向客戶端提供了一個可以訪問系統的介面。這種型別的設計模式屬於結構性模式。為子系統中的一組介面提供了一個統一的訪問介面，這個介面使得子系統更容易被訪問或者使用。 
 
簡單來說，該模式就是把一些複雜的流程封裝成一個介面供給外部使用者更簡單的使用。 

  
 

    

    
    
二十三種設計模式_概述
     
  
 
 概述及詳解：https://blog.csdn.net/qq_25827845/article/details/52932234 
   
   
 一、Singleton，單例模式：保證一個類只有一個例項，並提供一個訪問它的全域性訪問點 二、Abstract Factory，抽 

  
 

    

    
    
二十三種設計模式
     
 1、工廠模式：Factory 客戶類和工廠類分開。消費者任何時候需要某種產品，只需向工廠請求即可。消費者無須修改就可以接納新產品。缺點是當產品修改時，工廠類也要做相應的修改。如：如何建立及如何向客戶端提供。 2、建造模式：Builder 將產品的內部表象和產品的生成過程分割開來，從而使一個建造過程生成具有不同