2. 程式人生 > >淺談Java設計模式——單例項、簡單工廠、抽象工廠、觀察者

淺談Java設計模式——單例項、簡單工廠、抽象工廠、觀察者

阿新 • • 發佈：2019-01-07

最近的專案裡面涉及到一些Java設計模式，在此簡單談一下自己的看法，以下示例一部分參考同行，大部分自己設計。

1.單例模式
如果一個類始終只能建立一個例項，則這個類成為單例類，這種設計模式稱為單例模式。

class Singleton
{
    // 使用一個類變數快取建立的例項
    private static Singleton instance;
    // 隱藏構造器
    private Singleton(){

    }
    // 提供一個靜態方法，用於返回Singleton例項
    public static Singleton getInstance
 
()
    {
        // 如果instance為null，表明還不曾建立Singleton物件
        // 如果instance不為null，則表明已經建立了Singleton物件，將不會執行該方法
        if (instance == null)
        {
            // 建立一個Singleton物件，並將其快取起來
            instance = new Singleton();
        }
        //如果instance已經建立過，直接返回
        return instance;
    }

}

寫個測試程式

public class SingletonTest
{
    public static void main(String[] args)
    {
        // 建立兩個Singleton 物件
        Singleton s1 = Singleton.getInstance();
        Singleton s2 = Singleton.getInstance();
        // 將輸出true
        System.out.println(s1 == s2);
    }
}

Spring容器所管理的Bean例項預設是單例，可以通過scope來修改其行為方式。
使用單例模式的優勢：
（1）減少系統開銷（不用每次都建立新的例項）
（2）便於系統跟蹤單個例項的生命週期與例項狀態等。

2.簡單工廠
通過工廠來建立物件的設計模式稱為簡單工廠模式。
這裡寫圖片描述
當需要建立一個物件的時候不通過new 來建立，而是通過向工廠下訂單來建立。
先定義一個房子（House），房子裡面有張桌子（Table），還可以獲得桌子的相關資訊（getTableMaterial（）獲得桌子的材料）。

/**
 * 
 * 一個House裡面有張桌子table（這個table是抽象的，需要工廠根據使用者的實際要求具體實現）
 * table通過工廠tableFactory來生產
 * tableFactory根據使用者所要求的材料material來定製table
 */
public class House {
    private Table table;

    public House(Table table){
        this.table = table;
    }
    //獲得table 的material（所用材料）
    public void getTableMaterial(){
        table.getMaterial();
    }

    public static void main(String[] args){
        TableFactory tableFactory = new TableFactory();
        //通過工廠生產Table物件並傳遞給構造器
        House house = new House(tableFactory.getTable("wood"));
        house.getTableMaterial();
    }
}

下面是Table介面，擁有Table的一般行為。

public interface Table {
    public void getMaterial();
}

下面是三個具體的實現類（三種材質的桌子）。

/**
 * 木桌
 */
public class WoodTable implements Table {

    @Override
    public void getMaterial() {
        // TODO Auto-generated method stub
        System.out.println("Material of this Table is Wood!");
    }

}
/**
 * 鐵桌
 */
public class SteelTable implements Table {

    @Override
    public void getMaterial() {
        // TODO Auto-generated method stub
        System.out.println("Material of this Table is Steel!");
    }

}
/**
 * 塑料桌
 */
public class PlasticTable implements Table {

    @Override
    public void getMaterial() {
        // TODO Auto-generated method stub
        System.out.println("Material of this Table is Plastic!");
    }

}

下面是桌子工廠，可以根據使用者的需求生產相應的桌子。

public class TableFactory {

    public Table getTable(String material){
        switch(material){
        case "wood":
            return new WoodTable();
        case "steel":
            return new SteelTable();
        default :
            return new PlasticTable();
        }
    }
}

下面進行測試：

public static void main(String[] args){
        TableFactory tableFactory = new TableFactory();
        //工廠根據使用者的需求生產Table物件並傳遞給構造器
        House house = new House(tableFactory.getTable("wood"));//使用者要求木桌(woodTable)
        house.getTableMaterial();
    }

測試結果：
這裡寫圖片描述
使用者可以向工廠提出自己的需求（woodTable ,steelTable還是plasticTable），由工廠來生產Table（建立Table物件）；

簡單工廠的優勢：物件的呼叫者與物件的建立過程分離，避免物件的呼叫與實現以硬編碼的方式耦合，提高系統的可維護性和可拓展性。

3.抽象工廠模式
抽象工廠簡單地說是工廠的工廠，抽象工廠可以建立具體工廠，由具體工廠來產生具體產品。
這裡寫圖片描述
來看個示例。
有一個汽車商店（CarShop），裡面有一輛汽車（car），還可以獲得汽車的相關資訊。

public class CarShop {
    private Car car;

    public CarShop(Car car){
        this.car = car;
    }
    //獲得汽車的相關資訊
    public void getCarInfo(){
        car.getCarInfo();
    }
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        //通過抽象工廠獲得具體工廠
        CarFactory cf = CarFactoryFactory.getCarFactory("A");
        //通過具體工廠建立具體car物件並傳遞給構造器
        CarShop cs = new CarShop(cf.createCar("BMW"));
        cs.getCarInfo();
    }
}

有一個抽象汽車工廠，用來根據使用者需求建立具體汽車工廠。

public class CarFactoryFactory {
    //根據carType建立具體工廠
    public static CarFactory getCarFactory(String carType){
        switch(carType){
        case "A":
            return new ACarFactory();
        case "B":
            return new BCarFactory();
        default :
            return new CCarFactory();
        }
    }
}

有A、B、C三個具體汽車工廠，用來生產三種類型的汽車。

/**
 * A工廠
 * 根據使用者要求的品牌（carBrand）
 * 生產A型別的汽車
 */
public class ACarFactory implements CarFactory {

    @Override
    public Car createCar(String carBrand) {
        // TODO Auto-generated method stub
        switch(carBrand){
        case "BMW":
            return new BMWCarA();
        case "Benz":
            return new BenzCarA();
        default :
            return new AudiCarA();
        }
    }

}

/**
* B工廠
 * 根據使用者要求的品牌（carBrand）
 * 生產B型別的汽車
 */
public class BCarFactory implements CarFactory {

    /* (non-Javadoc)
     * @see com.abstructFactory.CarFactory#createCar(java.lang.String)
     */
    @Override
    public Car createCar(String carBrand) {
        switch(carBrand){
        case "BMW":
            return new BMWCarB();
        case "Benz":
            return new BenzCarB();
        default :
            return new AudiCarB();
        }
    }

}

/**
 * C工廠
 * 根據使用者要求的品牌（carBrand）
 * 生產C型別的汽車
 */
public class CCarFactory implements CarFactory {

    @Override
    public Car createCar(String carBrand) {
        switch(carBrand){
        case "BMW":
            return new BMWCarC();
        case "Benz":
            return new BenzCarC();
        default :
            return new AudiCarC();
        }
    }
}

這三個具體工廠類都實現了同一個汽車工廠介面，該介面擁有一般汽車工廠的行為。

public interface CarFactory {
    public Car createCar(String carBrand);
}

A、B、C三個具體汽車工廠分別生產三種品牌（BMW,Benz和Audi）的汽車。

/**
 * A工廠生產的Audi汽車
 */
public class AudiCarA implements Car {

    @Override
    public void getCarInfo() {
        System.out.println("Audi car from ACarFactory");
    }
}

/**
 * A工廠生產的Benz汽車
 */
public class BenzCarA implements Car {

    @Override
    public void getCarInfo() {
        System.out.println("Benz car from ACarFactory");
    }
}

/**
 * A工廠生產的BMW汽車
 */
public class BMWCarA implements Car {

    @Override
    public void getCarInfo() {
        System.out.println("BMW car from ACarFactory");
    }
}

/**
 * B工廠生產的Audi汽車
 */
public class AudiCarB implements Car {

    @Override
    public void getCarInfo() {
        System.out.println("Audi car from BCarFactory");
    }
}
/**
 * B工廠生產的Benz汽車
 */
public class BenzCarB implements Car {

    @Override
    public void getCarInfo() {
        System.out.println("Benz car from BCarFactory");
    }
}

/**
 * B工廠生產的BMW汽車
 */
public class BMWCarB implements Car {

    @Override
    public void getCarInfo() {
        System.out.println("BMW car from BCarFactory");
    }
}
/**
 * C工廠生產的Audi汽車
 */
public class AudiCarC implements Car {

    @Override
    public void getCarInfo() {
        System.out.println("BMW car from CCarFactory");
    }
}
/**
 * C工廠生產的Benz汽車
 */
public class BenzCarC implements Car {

    @Override
    public void getCarInfo() {
        System.out.println("BMW car from CCarFactory");
    }
}

/**
 * C工廠生產的BMW汽車
 */
public class BMWCarC implements Car {

    @Override
    public void getCarInfo() {
        System.out.println("BMW car from CCarFactory");
    }
}

這些具體的汽車產品都實現了同一個介面（Car），該介面擁有汽車的一般行為。

public interface Car {
    public void getCarInfo();
}

下面來做個測試，使用者要求一輛A工廠生產的BMW汽車：

public static void main(String[] args) {
        // TODO Auto-generated method stub
        //通過抽象工廠獲得具體工廠
        CarFactory cf = CarFactoryFactory.getCarFactory("A");
        //通過具體工廠建立具體car物件並傳遞給構造器
        CarShop cs = new CarShop(cf.createCar("BMW"));
        cs.getCarInfo();
    }

測試結果：
這裡寫圖片描述
抽象工廠可以根據使用者的需求，通過不同的具體工廠生產不同的產品。
那麼抽象工廠模式有什麼好處呢？假如採用簡單工廠模式，假如只有A工廠，當用戶要求一輛B型別的BMW時，就要修改A工廠程式碼來生產BMWCarB物件。所以，抽象工廠模式的優勢是：物件的呼叫者與物件的實現類以及具體的工廠分離，程式碼的耦合性更低，系統可維護性以及可拓展性更高。
但是抽象工廠模式有個缺陷，就是當用戶需求改變的時候，需要修改程式碼，然後需要重新編譯，最好是將使用者需求（可以看做使用者訂單）放在一個配置檔案裡面，由程式碼根據配置檔案來建立相應的工廠以及例項，這樣當用戶需求發生改變的時候，只需要修改配置檔案（產品訂單）即可。
Spring IOC容器是一個抽象工廠，既可以管理Bean例項，還可以管理工廠例項。ApplicationContext.xml可以看作是系統的訂單，容器根據這個訂單生產相應的Bean。

4.觀察者模式
觀察者模式又稱釋出訂閱模式，定義了一種一對多依賴關係，讓一個或多個觀察者物件觀察一個主題物件，當主題物件的狀態發生改變時，系統會通知所有的依賴於此物件的觀察者，從而使得觀察者物件能夠自動更新。
看一個示例：
有一個任務列表TaskList，裡面的任務需要兩個程式設計師去完成，TaskList可以看作是被觀察的主題物件，兩個程式設計師可以看作是依賴於此主題物件的觀察者，當任務列表裡面的任務更新時，要通知這兩個程式設計師。
下面是TaskList：

public class TaskList extends Observable{
    private List<String> allTask;

    private static TaskList instance;
    //私有構造器
    private TaskList(){

    }

    public static TaskList getInstance(){
        if(instance == null){
            instance = new TaskList();
            instance.allTask = new ArrayList<String>();
        }
        return instance;
    }
    //新增觀察者
    public void addTaskObserver(Observer observer){
        this.addObserver(observer);
    }
    //任務列表發生改變
    public void addNewTask(String newTask){
        allTask.add("new Task");
        System.out.println("系統添加了新任務");
        //被觀察物件發生改變
        this.setChanged();
        //通知觀察者並傳遞新任務
        this.notifyObservers(newTask);

    }
}

  下面是兩個程式設計師：

public class ProgrammerA implements Observer{
    //自動更新
    @Override
    public void update(Observable o, Object task) {
        String newTask = (String)task;
        System.out.println("ProgrammerA 您有新的任務: " +newTask);
    }
}

public class ProgrammerB implements Observer{
    //自動更新
    @Override
    public void update(Observable o, Object task) {
        String newTask = (String)task;
        System.out.println("ProgrammerB 您有新的任務: " +newTask);        
    }
}

下面做個測試：

public class ObserverTest {

    public static void main(String[] args) {
        //被觀察的任務列表
        TaskList observable = TaskList.getInstance();
        //觀察者
        ProgrammerA pa = new ProgrammerA();
        ProgrammerB pb = new ProgrammerB();
        //新增觀察者
        observable.addObserver(pa);
        observable.addObserver(pb);
        //任務列表發生改變
        observable.addNewTask("new Task");
    }
}

測試結果：
這裡寫圖片描述

Java EE 應用中，主題/訂閱模式下的JMS就是觀察者模式的應用。

設計模式是對處於特定環境下，經常出現的某類軟體開發問題的一種相對成熟的設計方案，是軟體設計師集體經驗的體現。優雅的程式碼沒必要刻意使用哪種設計模式，最好是它本身就體現出設計模式。

相關推薦

淺談Java設計模式——單例項、簡單工廠、抽象工廠、觀察者

最近的專案裡面涉及到一些Java設計模式，在此簡單談一下自己的看法，以下示例一部分參考同行，大部分自己設計。 1.單例模式 如果一個類始終只能建立一個例項，則這個類成為單例類，這種設計模式稱為單例模式。 class Singleton {

淺談Java設計模式——單例模式

一、概述         單例模式主要是為了避免因為建立了多個例項造成資源的浪費，且多個例項由於多次呼叫容易導致結果出現錯誤，而使用單例模式能夠保證整個應用中有且只有一個例項。 二、定義 定義：只

淺談Java設計模式——簡單工廠模式

一、定義         通過專門定義一個類來負責建立其他類的例項，被建立的例項通常都具有共同的父類。 二、類圖 三、理解         Operation為抽象類，它定義了一個抽象方法getResult；OperationAdd和OperationSubtra

淺談Java設計模式——抽象工廠模式(AbstractFactory)

一、對比簡單工廠模式、工廠方法模式         簡單工廠模式只通過一個工廠類，通過給定引數返回相應的例項物件。工廠方法模式只有一個抽象產品類，而抽象工廠模式有多個。 工廠方法模式的具體工廠類只能建立一個具體產品類的例項，而抽象工廠模式可以建立多個。 普通工廠產出是一個產

淺談Java設計模式——建造者模式(Builder)

一、概述         將一個複雜物件的構建與它的表示分離，使得同樣的構建過程可以建立不同的表示。         建造者模式將複雜產品的構建過程封裝分解在不同的方法中，使得建立過程非常清晰，能夠讓我們更加精確的控制複雜產品物件的建立過程，同時它隔離了複雜產品物件的建立

淺談Java設計模式——原型模式(Prototype)

一、概述         用原型例項指定建立物件的種類，並且通過拷貝這些原型建立新的物件。 二、使用場景 1.當一個系統應該獨立於它的產品建立、構成和表示時。 2.當要例項化的類是在執行時刻指定時，例如，通過動態裝載。  3.為了避免建立一個與產品類層次平行的工廠類

淺談Java設計模式——介面卡模式(Adapter)

一、概述         將一個類的介面轉換成客戶希望的另外一個介面。Adapter模式使得原本由於介面不相容而不能一起工作的那些類可以一起工作。在我們的應用程式中我們可能需要將兩個不同介面的類來進行通訊，在不修改這兩個的前提下我們可能會需要某個中介軟體來完成這個銜接的過程

淺談Java設計模式——組合模式(Composite)

一、概述         將物件組合成樹形結構以表示"部分-整體"的層次結構。"Composite使得使用者對單個物件和組合物件的使用具有一致性。它定義瞭如何將容器物件和葉子物件進行遞迴組合，使得客戶在使用的過程中無須進行區分，可以對他們進行一致的處理。在使用組合模式中需要

淺談Java設計模式——外觀模式(facade)

一、概述         為子系統中的一組介面提供一個一致的介面，Facade模式定義了一個高層介面，這個介面使得這一子系統更加容易使用。我們都知道類與類之間的耦合越低，那麼可複用性就越好，如果兩個類不必彼此通訊，那麼就不要讓這兩個類發生直接的相互關係，如果需要呼叫裡面的方

淺談Java設計模式——享元模式(Flyweight)

一、概述         運用共享技術有效地支援大量細粒度的物件。在一個系統中物件會使得記憶體佔用過多，特別是那些大量重複的物件，這就是對系統資源的極大浪費。享元模式對物件的重用提供了一種解決方案，它使用共享技術對相同或者相似物件實現重用。享元模式就是執行共享技術有效地支援

淺談Java設計模式——迭代器模式(Iterator)

一、概述         給定一個語言，定義它的文法的一種表示，並定義一個直譯器，這個直譯器使用該表示來解釋語言中的句子。 二、使用場景 1.訪問一個聚合物件的內容而無需暴露它的內部表示。  2.支援對聚合物件的多種遍歷。  3.為遍歷不同的聚合結構提供一個統一的介

淺談Java設計模式——觀察者模式(Observer)

一、概述         定義物件間的一種一對多的依賴關係,當一個物件的狀態發生改變時,所有依賴於它的物件都得到通知並被自動更新。觀察者模式定義了物件之間的一對多依賴關係，這樣一來，當一個物件改變狀態時，它的所有依賴者都會收到通知並且自動更新。在這裡，發生改變的物件稱之為觀

淺談Java設計模式（十七）責任鏈模式（Chain of Responsibility）

前言： 接下來我們將要談談責任鏈模式，有多個物件，每個物件持有對下一個物件的引用，這樣就會形成一條鏈，請求在這條鏈上傳遞，直到某一物件決定處理該請求。但是發出者並不清楚到底最終那個物件會處理該請求，所

淺談Java設計模式（五）原型模式（Prototype）

前言： 原型模式雖然是建立型的模式，但是與工程模式沒有關係，從名字即可看出，該模式的思想就是將一個物件作為原型，對其進行復制、克隆，產生一個和原物件類似的新物件。本小結會通過物件的複製，進行講解。在Java中，複製物件是通過clone()實現的，先建立一個原型類： publ

淺談常見設計模式--單例模式 簡單工廠模式

今題那站在這裡和大家一起分享最近在一本書上看到的關於設計模式的內容，接下來要講的設計模式有： 單例模式 簡單工廠模式 工廠方法和抽象工廠 代理模式 命令模式 策略模式 門面模式 橋接模式 觀察者模式 接下來詳細介紹滅一種設計模式（注意：下面的講解都是基於ja

淺談JAVA設計模式之——備忘錄模式（Memento）

一、概述 在不破壞封裝性的前提下，捕獲一個物件的內部狀態，並在該物件之外儲存這個狀態。這樣以後就可將該物件恢復到原先儲存的狀態。 二、適用性 1.必須儲存一個物件在某一個時刻的(部分)狀態,這樣以後需要時它才能恢復到先前的狀態。 2.如果一個用介面來讓其它物件直接得到這

淺談JAVA設計模式之——組合模式（Composite）

一、概述 將物件組合成樹形結構以表示"部分-整體"的層次結構。"Composite使得使用者對單個物件和組合物件的使用具有一致性。 二、適用性 1.你想表示物件的部分-整體層次結構。 2.你希望使用者忽略組合物件與單個物件的不同，使用者將統一地使用組合結構

淺談JAVA設計模式之——外觀模式(Facade)

一、概述 為子系統中的一組介面提供一個一致的介面，Facade模式定義了一個高層介面，這個介面使得這一子系統更加容易使用。 二、適用性 1.當你要為一個複雜子系統提供一個簡單介面時。子系統往往因為不斷演化而變得越來越 複雜。大多數模式使用時都會產生更多更小的類。這使得子系

淺談JAVA設計模式之——責任鏈模式(COR)

一、概述 使多個物件都有機會處理請求，從而避免請求的傳送者和接收者之間的耦合關係。將這些物件連成一條鏈， 並沿著這條鏈傳遞該請求，直到有一個物件處理它為止。 這一模式的想法是，給多個物件處理一個請求的機會，從而解耦傳送者和接受者. 二、適用性 1.有多個的物件可以處理一個

Java設計模式-單例模式、觀察者模式、工廠模式

單例設計模式 概念： 全域性只有一個例項，自行例項化物件，自行向整個系統提供這個例項。 應用場景： 需要全域性只有一個例項的時候，如儲存使用者資訊。 只有一個訪問途徑 優點： 全域性只有一個例項，避免了頻繁的建立例項，耗費的資源。 提