java 設計模式

標籤：

主要摘自：http://blog.csdn.net/zhangerqing/article/details/8194653

 

設計模式的六大原則

1、開閉原則（Open Close Principle）

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

2、裡氏代換原則（Liskov Substitution Principle）

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

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

這個是開閉原則的基礎，具體內容：真對介面編程，依賴於抽象而不依賴於具體。

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

這個原則的意思是：使用多個隔離的介面，比使用單個介面要好。還是一個降低類之間的耦合度的意思，從這兒我們看出，其實設計模式就是一個軟體的設計思想，從大型軟體架構出發，為了升級和維護方便。所以上文中多次出現：降低依賴，降低耦合。

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

為什麼叫最少知道原則，就是說：一個實體應當盡量少的與其他實體之間發生相互作用，使得系統功能模組相對獨立。

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

原則是盡量使用合成/彙總的方式，而不是使用繼承。

 

一、原廠模式

1. 普通原廠模式，就是建立一個工廠類，對實現了同一介面的一些類進行執行個體的建立。

建立一個介面：

public interface Sender {    public void Send();}

其次，建立實作類別：

MailSender.java

public class MailSender implements Sender{    @Override    public void Send() {        // TODO Auto-generated method stub        System.out.println("MailSender");    }}

SMSSender.java

public class SMSSender implements Sender {    @Override    public void Send() {        // TODO Auto-generated method stub        System.out.println("SMSSender");    }}

建立工廠類：

public class SendFactory {    public Sender produce(String type)    {        if("mail".equals(type))        {            return new MailSender();        }        else if("sms".equals(type))        {            return new SMSSender();        }        else return null;    }    }

測試類別：

public class FactoryTest {    public static void main(String[] args) {        SendFactory sendFactory = new SendFactory();        Sender sender = sendFactory.produce("mail");        sender.Send();    }}

2. 多個Factory 方法模式。是對普通Factory 方法模式的改進，在普通Factory 方法模式中，如果傳遞的字串出錯，則不能正確建立對象，而多個Factory 方法模式是提供多個Factory 方法，分別建立對象。

改動SendFactory類：

public class SendFactory {    public Sender produceMailSender()    {        return new MailSender();    }    public Sender produceSmsSender()    {        return new SMSSender();    }}

測試：

public class FactoryTest {    public static void main(String[] args) {        SendFactory sendFactory = new SendFactory();        Sender sender = sendFactory.produceMailSender();        sender.Send();    }}

 

3. 靜態Factory 方法模式，將上面的多個Factory 方法模式裡的方法置為靜態，不需要建立執行個體，直接調用即可。

 

改動SendFactory類：

public class SendFactory {    public static Sender produceMailSender()    {        return new MailSender();    }    public static Sender produceSmsSender()    {        return new SMSSender();    }}

測試類別：

public class FactoryTest {    public static void main(String[] args) {        Sender sender = SendFactory.produceMailSender();        sender.Send();    }}

 

二、抽象原廠模式（Abstract Factory）

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

 

實現介面：

public interface Sender {    public void Send();}

兩個實作類別：

MailSender.java

public class MailSender implements Sender{    @Override    public void Send() {        // TODO Auto-generated method stub        System.out.println("MailSender");    }}

SMSSender.java

public class SMSSender implements Sender {    @Override    public void Send() {        // TODO Auto-generated method stub        System.out.println("SMSSender");    }}

兩個工廠類：

SendSMSFactory.java

public class SendSMSFactory implements Provider{    @Override    public Sender produce() {        // TODO Auto-generated method stub        return new SMSSender();    }}

SendMailFactory.java

public class SendMailFactory implements Provider{    @Override    public Sender produce() {        // TODO Auto-generated method stub        return new MailSender();    }}

 

再實現一個介面：

public interface Provider {     public Sender produce();  }

 

測試類別：

public class FactoryTest {    public static void main(String[] args) {        Provider provider = new SendSMSFactory();        Sender sender = provider.produce();         sender.Send();    }}

 

3. 單例模式（Singleton）

單例對象（Singleton）是一種常用的設計模式。在Java應用中，單例對象能保證在一個JVM中，該對象只有一個執行個體存在。這樣的模式有幾個好處：

1、某些類建立比較頻繁，對於一些大型的對象，這是一筆很大的系統開銷。

2、省去了new操作符，降低了系統記憶體的使用頻率，減輕GC壓力。

3、有些類如證券交易所的核心交易引擎，控制著交易流程，如果該類可以建立多個的話，系統完全亂了。（比如一個軍隊出現了多個司令員同時指揮，肯定會亂成一團），所以只有使用單例模式，才能保證核心交易伺服器獨立控制整個流程。

public class Singleton {    /* 持有私人靜態執行個體，防止被引用，此處賦值為null，目的是實現消極式載入 */    private static Singleton instance = null;    /* 私人構造方法，防止被執行個體化 */    private Singleton() {    }    /* 靜態工程方法，建立執行個體 */    public static Singleton getInstance() {        if (instance == null) {            instance = new Singleton();        }        return instance;    }    /* 如果該對象被用於序列化，可以保證對象在序列化前後保持一致 */    public Object readResolve() {        return instance;    }}

     這個類可以滿足基本要求，但是，像這樣毫無線程安全保護的類，如果我們把它放入多線程的環境下，肯定就會出現問題了，如何解決？我們首先會想到對getInstance方法加synchronized關鍵字，如下：

public static synchronized Singleton getInstance() {        if (instance == null) {            instance = new Singleton();        }        return instance;    }

 

java 設計模式