Java經典設計模式之五大建立型模式(附執行個體和詳解),java設計模式

來源:互聯網
上載者:User

Java經典設計模式之五大建立型模式(附執行個體和詳解),java設計模式
一、概況

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

(1)建立型模式,共五種:Factory 方法模式、抽象原廠模式、單例模式、建造者模式、原型模式。

(2)結構型模式,共七種:適配器模式、裝飾器模式、代理模式、面板模式、橋接模式、組合模式、享元模式。

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

二、設計模式的六大原則

1、開閉原則(Open Close Principle)

開閉原則就是說對擴充開放,對修改關閉。在程式需要進行拓展的時候,不能去修改原有的代碼,實現一個熱插拔的效果。

2、裡氏代換原則(Liskov Substitution Principle)

其官方描述比較抽象,可自行百度。實際上可以這樣理解:(1)子類的能力必須大於等於父類,即父類可以使用的方法,子類都可以使用。(2)傳回值也是同樣的道理。假設一個父類方法返回一個List,子類返回一個ArrayList,這當然可以。如果父類方法返回一個ArrayList,子類返回一個List,就說不通了。這裡子類傳回值的能力是比父類小的。(3)還有拋出異常的情況。任何子類方法可以聲明拋出父類方法聲明異常的子類。 
而不能聲明拋出父類沒有聲明的異常。

3、依賴倒轉原則(Dependence Inversion Principle)

這個是開閉原則的基礎,具體內容:面向介面編程,依賴於抽象而不依賴於具體。

4、介面隔離原則(Interface Segregation Principle)

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

5、迪米特法則(最少知道原則)(Demeter Principle)

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

6、合成複用原則(Composite Reuse Principle)

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

三、建立型模式

建立型模式,共五種:Factory 方法模式、抽象原廠模式、單例模式、建造者模式、原型模式。

3.1、Factory 方法模式

Factory 方法模式分為三種:普通原廠模式、多個Factory 方法模式和靜態Factory 方法模式。

3.1.1、普通原廠模式

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


package com.mode.create;


public interface MyInterface {

    public void print();

}

 


package com.mode.create;


public class MyClassOne implements MyInterface {


    @Override

    public void print() {

        System.out.println("MyClassOne");

    }


}

 


package com.mode.create;


public class MyClassTwo implements MyInterface {


    @Override

    public void print() {

        System.out.println("MyClassTwo");

    }


}

 


package com.mode.create;


public class MyFactory {


    public MyInterface produce(String type) {  

        if ("One".equals(type)) {  

            return new MyClassOne();  

        } else if ("Two".equals(type)) {  

            return new MyClassTwo();  

        } else {  

            System.out.println("沒有要找的類型");  

            return null;  

        }  

    }


}

 


package com.mode.create;


public class FactoryTest {


    public static void main(String[] args){

        MyFactory factory = new MyFactory();  

        MyInterface myi = factory.produce("One");  

        myi.print();

    }


}

FactoryTest的運行結果我想應該很明顯了。

再回頭來理解這句話:普通原廠模式就是建立一個工廠類,對實現了同一介面的一些類進行執行個體的建立。

3.1.2、多個Factory 方法模式

多個Factory 方法模式,是對普通Factory 方法模式的改進,多個Factory 方法模式就是提供多個Factory 方法,分別建立對象。

直接看代碼吧,我們修改MyFactory和FactoryTest如下:


package com.mode.create;


public class MyFactory {


    public MyInterface produceOne() {

        return new MyClassOne();

    }


    public MyInterface produceTwo() {

        return new MyClassTwo();

    }


}

 


package com.mode.create;


public class FactoryTest {


    public static void main(String[] args){

        MyFactory factory = new MyFactory();  

        MyInterface myi = factory.produceOne();

        myi.print();

    }


}

運行結果也是十分明顯了。

再回頭來理解這句話:多個Factory 方法模式,是對普通Factory 方法模式的改進,多個Factory 方法模式就是提供多個Factory 方法,分別建立對象。

3.1.3、靜態Factory 方法模式

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

直接看代碼吧,我們修改MyFactory和FactoryTest如下:


package com.mode.create;


public class MyFactory {


    public static MyInterface produceOne() {

        return new MyClassOne();

    }


    public static MyInterface produceTwo() {

        return new MyClassTwo();

    }


}

 


package com.mode.create;


public class FactoryTest {


    public static void main(String[] args){ 

        MyInterface myi = MyFactory.produceOne();

        myi.print();

    }


}

運行結果依舊很明顯。

再回顧:靜態Factory 方法模式,將上面的多個Factory 方法模式裡的方法置為靜態,不需要建立執行個體,直接調用即可。

3.2、抽象原廠模式

Factory 方法模式有一個問題就是,類的建立依賴工廠類,也就是說,如果想要拓展程式,必須對工廠類進行修改,這違背了閉包原則。

為解決這個問題,我們來看看抽象原廠模式:建立多個工廠類,這樣一旦需要增加新的功能,直接增加新的工廠類就可以了,不需要修改之前的代碼。

這樣就符合閉包原則了。

下面來看看代碼:

MyInterface、MyClassOne、MyClassTwo不變。

新增如下介面和類:


package com.mode.create;


public interface Provider {

    public MyInterface produce(); 

}

 


package com.mode.create;


public class MyFactoryOne implements Provider {


    @Override

    public MyInterface produce() {

        return new MyClassOne();

    }


}

 


package com.mode.create;


public class MyFactoryTwo implements Provider {


    @Override

    public MyInterface produce() {

        return new MyClassTwo();

    }


}

修改測試類別FactoryTest如下:


package com.mode.create;


public class FactoryTest {


    public static void main(String[] args){ 

        Provider provider = new MyFactoryOne();

        MyInterface myi = provider.produce();

        myi.print();

    }


}

運行結果依舊顯然。

再回顧:抽象原廠模式就是建立多個工廠類,這樣一旦需要增加新的功能,直接增加新的工廠類就可以了,不需要修改之前的代碼。

3.3、單例模式

單例模式,不需要過多的解釋。

直接看代碼吧:


package test;


public class MyObject {


    private static MyObject myObject;


    private MyObject() {

    }


    public static MyObject getInstance() {

        if (myObject != null) {

        } else {

            myObject = new MyObject();

        }

        return myObject;

    }


}

但是這樣會引發多線程問題,詳細解說可以看《Java多線程編程核心技術》書中的第六章。

3.4、建造者模式

建造者模式:是將一個複雜的對象的構建與它的表示分離,使得同樣的構建過程可以建立不同的表示。

字面看來非常抽象,實際上它也十分抽象!!!!

建造者模式通常包括下面幾個角色:

(1) Builder:給出一個抽象介面,以規範產品對象的各個組成成分的建造。這個介面規定要實現複雜物件的哪些部分的建立,並不涉及具體的對象組件的建立。

(2) ConcreteBuilder:實現Builder介面,針對不同的商業邏輯,具體化複雜物件的各部分的建立。 在建造過程完成後,提供產品的執行個體。

(3)Director:調用具體建造者來建立複雜物件的各個部分,在指導者中不涉及具體產品的資訊,只負責保證對象各部分完整建立或按某種順序建立。

(4)Product:要建立的複雜物件。

在遊戲開發中建造小人是經常的事了,要求是:小人必須包括頭,身體和腳。

下面我們看看如下代碼:

Product(要建立的複雜物件。):


package com.mode.create;


public class Person {


    private String head;

    private String body;

    private String foot;


    public String getHead() {

        return head;

    }


    public void setHead(String head) {

        this.head = head;

    }


    public String getBody() {

        return body;

    }


    public void setBody(String body) {

        this.body = body;

    }


    public String getFoot() {

        return foot;

    }


    public void setFoot(String foot) {

        this.foot = foot;

    }

}

Builder(給出一個抽象介面,以規範產品對象的各個組成成分的建造。這個介面規定要實現複雜物件的哪些部分的建立,並不涉及具體的對象組件的建立。):


package com.mode.create;


public interface PersonBuilder {

    void buildHead();

    void buildBody();

    void buildFoot();

    Person buildPerson();

}

ConcreteBuilder(實現Builder介面,針對不同的商業邏輯,具體化複雜物件的各部分的建立。 在建造過程完成後,提供產品的執行個體。):


package com.mode.create;


public class ManBuilder implements PersonBuilder {


    Person person;


    public ManBuilder() {

        person = new Person();

    }


    public void buildBody() {

        person.setBody("建造男人的身體");

    }


    public void buildFoot() {

        person.setFoot("建造男人的腳");

    }


    public void buildHead() {

        person.setHead("建造男人的頭");

    }


    public Person buildPerson() {

        return person;

    }


}

Director(調用具體建造者來建立複雜物件的各個部分,在指導者中不涉及具體產品的資訊,只負責保證對象各部分完整建立或按某種順序建立。):


package com.mode.create;


public class PersonDirector {

    public Person constructPerson(PersonBuilder pb) {

        pb.buildHead();

        pb.buildBody();

        pb.buildFoot();

        return pb.buildPerson();

    }

}

測試類別:


package com.mode.create;


public class Test {

    public static void main(String[] args) {

        PersonDirector pd = new PersonDirector();

        Person person = pd.constructPerson(new ManBuilder());

        System.out.println(person.getBody());

        System.out.println(person.getFoot());

        System.out.println(person.getHead());

    }

}

運行結果:

回顧:建造者模式:是將一個複雜的對象的構建與它的表示分離,使得同樣的構建過程可以建立不同的表示。

3.5、原型模式

該模式的思想就是將一個對象作為原型,對其進行複製、複製,產生一個和原對象類似的新對象。

說道複製對象,我將結合對象的淺複製和深複製來說一下,首先需要瞭解對象深、淺複製的概念:

淺複製:將一個對象複製後,基礎資料型別 (Elementary Data Type)的變數都會重新建立,而參考型別,指向的還是原對象所指向的。

深複製:將一個對象複製後,不論是基礎資料型別 (Elementary Data Type)還有參考型別,都是重新建立的。簡單來說,就是深複製進行了完全徹底的複製,而淺複製不徹底。

寫一個深淺複製的例子:


package com.mode.create;


import java.io.ByteArrayInputStream;

import java.io.ByteArrayOutputStream;

import java.io.IOException;

import java.io.ObjectInputStream;

import java.io.ObjectOutputStream;

import java.io.Serializable;


public class Prototype implements Cloneable, Serializable {


    private static final long serialVersionUID = 1L;


    private int base;


    private Integer obj;


     /* 淺複製 */  

    public Object clone() throws CloneNotSupportedException {

        // 因為Cloneable介面是個空介面,你可以任意定義實作類別的方法名

        // 如cloneA或者cloneB,因為此處的重點是super.clone()這句話

        // super.clone()調用的是Object的clone()方法

        // 而在Object類中,clone()是native(本地方法)的

        Prototype proto = (Prototype) super.clone();

        return proto;

    }


    /* 深複製 */

    public Object deepClone() throws IOException, ClassNotFoundException {


        /* 寫入當前對象的二進位流 */

        ByteArrayOutputStream bos = new ByteArrayOutputStream();

        ObjectOutputStream oos = new ObjectOutputStream(bos);

        oos.writeObject(this);


        /* 讀出二進位流產生的新對象 */

        ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());

        ObjectInputStream ois = new ObjectInputStream(bis);

        return ois.readObject();

    }


    public int getBase() {

        return base;

    }


    public void setBase(int base) {

        this.base = base;

    }


    public Integer getObj() {

        return obj;

    }


    public void setObj(Integer obj) {

        this.obj = obj;

    }



}

測試類別:


package com.mode.create;


import java.io.IOException;


public class Test {

    public static void main(String[] args) throws CloneNotSupportedException,

            ClassNotFoundException, IOException {

        Prototype prototype = new Prototype();

        prototype.setBase(1);

        prototype.setObj(new Integer(2));

        /* 淺複製 */ 

        Prototype prototype1 = (Prototype) prototype.clone();

        /* 深複製 */

        Prototype prototype2 = (Prototype) prototype.deepClone();

        System.out.println(prototype1.getObj()==prototype1.getObj());

        System.out.println(prototype1.getObj()==prototype2.getObj());

    }

}

運行結果:

Java團長

號:javatuanzhang

每日分享Java技術乾貨

長按識別二維碼

相關文章

聯繫我們

該頁面正文內容均來源於網絡整理,並不代表阿里雲官方的觀點,該頁面所提到的產品和服務也與阿里云無關,如果該頁面內容對您造成了困擾,歡迎寫郵件給我們,收到郵件我們將在5個工作日內處理。

如果您發現本社區中有涉嫌抄襲的內容,歡迎發送郵件至: info-contact@alibabacloud.com 進行舉報並提供相關證據,工作人員會在 5 個工作天內聯絡您,一經查實,本站將立刻刪除涉嫌侵權內容。

A Free Trial That Lets You Build Big!

Start building with 50+ products and up to 12 months usage for Elastic Compute Service

  • Sales Support

    1 on 1 presale consultation

  • After-Sales Support

    24/7 Technical Support 6 Free Tickets per Quarter Faster Response

  • Alibaba Cloud offers highly flexible support services tailored to meet your exact needs.