創建型模式————工廠模式（2.2）

来源:https://www.cnblogs.com/noneplus/archive/2019/08/11/11337158.html
-Advertisement-
Play Games

和單例模式相似，工廠模式同樣聚焦於在考慮整個軟體構建的情況下合理創建對象，從而保證軟體的擴展性和穩定性。 簡單工廠模式：適用客戶端無需擴展的應用場景 //工廠方法模式：適合客戶端創建單個產品的應用場景 //抽象工廠模式：適合創建多個產品(產品固定)的應用場景 ...


什麼是工廠模式？

工廠模式是創建型模式的一種，工廠是用來生產的，而在Java里，是用來生產對象實例的。


和單例模式相似，工廠模式同樣聚焦於在考慮整個軟體構建的情況下合理創建對象，從而保證軟體的擴展性和穩定性。

工廠模式分為三種：

  • 簡單工廠模式
  • 工廠方法模式
  • 抽象工廠模式

簡單工廠模式（實現服務端自擴展）

服務端：提供代碼的人（作者）

客戶端：使用代碼的人（用戶）

【對於程式員來說，自己是作者，用戶是普通人；那麼對於發明語言,框架的人來說，創建者是作者，而普通程式員是用戶】

假設沒有使用簡單工廠模式：

定義一個Coder介面，然後定義JavaCoder和PythonCoder實現Coder介面。客戶端通過new來創建對象。（耦合）

//服務端
interface Coder {

    void express();
}

class JavaCoder implements Coder
{
    @Override
    public void express()
    {
        System.out.println("I am a Java Coder");

    }
}

class PythonCoder implements Coder
{

    @Override
    public void express()
    {
        System.out.println("I am a Python Coder");

    }
}

//===============================================================================
public class ProductManager     //客戶端
{
    public static void main(String[] args) {

        Coder javaCoder = new JavaCoder();
        javaCoder.express();

        
    }



}

當服務端需要擴展一個類時：需要進行1,2兩步

//服務端
interface Coder {

    void express();
}

class JavaCoder implements Coder
{
    @Override
    public void express()
    {
        System.out.println("I am a Java Coder");

    }
}

class PythonCoder implements Coder
{

    @Override
    public void express()
    {
        System.out.println("I am a Python Coder");

    }
}


class GoCoder implements Coder    //1.服務端擴展
{

    @Override
    public void express()
    {
        System.out.println("I am a Go Coder");

    }
}
//===============================================================================
public class ProductManager     //客戶端
{
    public static void main(String[] args) {

        Coder javaCoder = new JavaCoder();
        javaCoder.express();

        Coder goCoder = new GoCoder();   //2.客戶端跟著修改
        goCoder.express();
    }



}

服務端和客戶端處於高度耦合狀態。（服務端的變化會引起客戶端的變化）

使用簡單工廠模式：（如果服務端要擴展一個GoCoder，客戶端無需做修改）

//服務端
interface Coder {

    void express();
}

class JavaCoder implements Coder
{
    @Override
    public void express()
    {
        System.out.println("I am a Java Coder");

    }
}

class PythonCoder implements Coder
{

    @Override
    public void express()
    {
        System.out.println("I am a Python Coder");

    }
}


class GoCoder implements Coder    //1.服務端擴展
{

    @Override
    public void express()
    {
        System.out.println("I am a Go Coder");

    }
}

class SimpleFactory
{

    //使用靜態內部類實現單例模式
    private static class StaticClassInnerInstance {
        private static final SimpleFactory INSTANCE = new SimpleFactory();
    }
    

    public static SimpleFactory getInstance() {
        return StaticClassInnerInstance.INSTANCE;
    }

    public Coder createCoder(String language)
    {
        Coder coder = null;
        if(language.equals("Java"))
        {
            coder= new JavaCoder();

        }
        else if(language.equals("Python"))
        {
            coder= new PythonCoder();
        }
        else if(language.equals("Go"))  //2.擴展條件
        {
            coder= new GoCoder();
        }
        return coder;
    }
}
//===============================================================================
public class ProductManager     //客戶端
{

    public static void main(String[] args) {

        SimpleFactory factory = SimpleFactory.getInstance();
        Coder javaCoder = factory.createCoder("Java");
        javaCoder.express();


    }



}

簡單工廠UML類圖：

1565531609458

簡單工廠的優缺點:

優點：

解決了服務端與客戶端的耦合問題，實現了服務端的自擴展。

缺點：

當客戶端需要進行功能擴展時，無法在SimpleFactory中添加對應修改代碼。

簡單工廠可以完成服務端的自擴展，但客戶端只能調用，無法擴展。

工廠方法模式（實現客戶端自擴展）

//服務端
interface Coder {

    void express();
}

class JavaCoder implements Coder
{
    @Override
    public void express()
    {
        System.out.println("I am a Java Coder");

    }
}

class PythonCoder implements Coder
{

    @Override
    public void express()
    {
        System.out.println("I am a Python Coder");

    }
}


class GoCoder implements Coder    //1.服務端擴展
{

    @Override
    public void express()
    {
        System.out.println("I am a Go Coder");

    }
}

interface CoderFactory   //抽象出CoderFactory
{
    public Coder createCoder(String language);
}

class ServerFactory implements CoderFactory
{

    private static class StaticClassInnerInstance {
        private static final ServerFactory INSTANCE = new ServerFactory();
    }

    public static ServerFactory getInstance() {
        return StaticClassInnerInstance.INSTANCE;
    }

    @Override
    public Coder createCoder(String language)
    {
        Coder coder = null;
        if(language.equals("Java"))
        {
            coder= new JavaCoder();

        }
        else if(language.equals("Python"))
        {
            coder= new PythonCoder();
        }
        else if(language.equals("Go"))  //2.擴展條件
        {
            coder= new GoCoder();
        }
        return coder;
    }
}
//===============================================================================

class RustCoder implements Coder
{
    @Override
    public void express()
    {
        System.out.println("I am a Rust Coder");

    }
}

class ClientFactory implements CoderFactory
{
    private static class StaticClassInnerInstance1 {
        private static final ClientFactory INSTANCE = new ClientFactory();
    }

    public static ClientFactory getInstance() {
        return ClientFactory.StaticClassInnerInstance1.INSTANCE;
    }

    @Override
    public Coder createCoder(String language)
    {

        return new RustCoder();
    }
}

public class ProductManager     //客戶端
{

    public static void main(String[] args) {

       ClientFactory clientFactory = ClientFactory.getInstance();
       Coder coder = clientFactory.createCoder("Rust");
       coder.express();
    }
}

工廠方法UML類圖：

1565532368140

工廠方法模式的優缺點：

優點：實現了客戶端的自擴展。

缺點：無法擴展多個產品。

抽象工廠模式（實現產品簇）

適應多個產品，加入設計師。

抽象工廠中可以生產多個產品，產品之間存在內在聯繫。比如說JavaCoder對應JavaDesigner。

而實例化的工廠就是根據這種內在聯繫來劃分的。

同一個工廠的產品屬於一個產品簇，不同產品簇之間是不能互相組合的。比如說GoDesigner和PythonCoder是不能組合到一個工廠里的。

//服務端
interface Coder {

    void express();
}
interface Designer {

    void express();
}


class JavaCoder implements Coder
{
    @Override
    public void express()
    {
        System.out.println("I am a Java Coder");

    }
}

class PythonCoder implements Coder
{

    @Override
    public void express()
    {
        System.out.println("I am a Python Coder");

    }
}


class GoCoder implements Coder
{

    @Override
    public void express()
    {
        System.out.println("I am a Go Coder");

    }
}

class JavaDesigner implements Designer
{
    @Override
    public void express()
    {
        System.out.println("I am a Java Designer!");

    }
}
class PythonDesigner implements Designer
{
    @Override
    public void express()
    {
        System.out.println("I am a Python Designer!");

    }
}
class GoDesigner implements Designer
{
    @Override
    public void express()
    {
        System.out.println("I am a Go Designer!");

    }
}

interface ProductFactory
{
    public Coder createCoder();
    public Designer createDesigner();

}

class GoFactory implements ProductFactory
{

    private static class StaticClassInnerInstance {
        private static final GoFactory INSTANCE = new GoFactory();
    }

    public static GoFactory getInstance() {
        return StaticClassInnerInstance.INSTANCE;
    }

    @Override
    public Coder createCoder()
    {

            Coder coder= new GoCoder();

        return coder;
    }
    @Override
    public Designer createDesigner()
    {
        Designer designer= new GoDesigner();

        return designer;
    }

}

class JavaFactory implements ProductFactory
{

    private static class StaticClassInnerInstance {
        private static final JavaFactory INSTANCE = new JavaFactory();
    }

    public static JavaFactory getInstance() {
        return StaticClassInnerInstance.INSTANCE;
    }

    @Override
    public Coder createCoder()
    {

        Coder coder= new JavaCoder();

        return coder;
    }
    @Override
    public Designer createDesigner()
    {
        Designer designer= new JavaDesigner();

        return designer;
    }

}
//===============================================================================



public class ProductManager     //客戶端
{

    public static void main(String[] args) {
        JavaFactory javaFactory = JavaFactory.getInstance();
        Coder coder =javaFactory.createCoder();
        Designer designer = javaFactory.createDesigner();
        coder.express();
        designer.express();




    }



}

抽象工廠UML類圖：

1565533010264

工廠模式總結

簡單工廠模式：適用客戶端無需擴展的應用場景

工廠方法模式：適合客戶端創建單個產品的應用場景

抽象工廠模式：適合創建多個產品的應用場景（但產品類別需要固定）

-------------------------------------------------------------------------------------------------------------2019.8.11


您的分享是我們最大的動力!

-Advertisement-
Play Games
更多相關文章
  • 創建型設計模式 -- 原型模式
    一、小案例分析 1、功能需求： 現有一個員工，姓名為Rick，年齡22，ID為193211，如何創建10個完全相同的對象。 2、小菜雞的答案： （1）直接new 10個對象就完了。（2）代碼實現： （3）代碼分析： 容易理解，好操作。但是每次都是初始化對象，而不是動態獲得對象，不夠靈活，效率低。 二 ...
  • 結構型模式————裝飾器模式（3.1）
    裝飾器模式的目的——**核心部分和裝飾部分可以自由組合。** 裝飾器模式要求： - 裝飾可選 - 裝飾可擴展 - 核心部分可擴展 ...
  • 創建型模式總結(2.x)
    顧名思義，創建型模式的聚焦點在如何創建對象能夠將對象的創建與使用最大化的分離從而降低系統的耦合度。 ...
  • 設計模式的七大原則(7) --合成復用原則
    前言 我們終於學習最後一個設計原則了，其實博主更新的還是挺慢的，因為我想一個一個吃透以後再繼續學習，切記不要囫圇吞棗。 基本介紹 其實這個能說的內容很少，就是： 儘量使用合成/聚合的方式，而不是使用繼承 為什麼要這樣做？有一下兩點原因： 1. 通過繼承來進行復用的主要問題在於繼承復用會破壞系統的封裝 ...
  • 設計模式的七大原則(6) --迪米特法則
    前言 迪米特法則，聽名字有點奇怪，但是這個法則真的非常非常有意思，在我看來，這個法則其實描述的就是一個矜持的小姑娘，害羞的惹人憐愛。但是啊，姑娘雖好，切不可"貪杯"哦~ 基本介紹 1. 一個對象應該對其他對象保持最少的瞭解。 2. 類與類關係越密切，耦合度越大 3. 一個類對自己依賴的類知道的越少越 ...
  • 前後端分離模式下的許可權設計方案
    作者：_liuxx cnblogs.com/liuyh/p/8027833.html 前後端分離模式下，所有的交互場景都變成了數據，傳統業務系統中的許可權控制方案在前端已經不再適用，因此引發了我對許可權的重新思考與設計。對於非前後端分離模式下的許可權思考，看這裡：通用數據許可權的思考與設計 許可權控制到底控制 ...
  • 創建型模式————建造者模式（2.4）
    什麼是建造者模式？ 工廠模式聚焦於創建出一個對象，而建造者除此之外還需要為創建的對象賦值。 簡單來說，建造者模式=創建對象+屬性賦值。 建造者模式應用場景 建造者模式適合創建 類中包含多個參數且需要定製化 的情況。 簡單來說，建造者模式的目的就是創造 一條龍服務 ：不僅創建出對象，順便給屬性賦值。 ...
  • 創建型模式————原型模式（2.3）
    簡單來說，通過複製的方式創建對象。 【舉個慄子】：點外賣的收貨地址 ...
一周排行
    -Advertisement-
    Play Games
  • UOS 開啟 VisualStudio 遠程調試 .NET 應用之旅
    前言 在我們開發過程中基本上不可或缺的用到一些敏感機密數據，比如SQL伺服器的連接串或者是OAuth2的Secret等，這些敏感數據在代碼中是不太安全的，我們不應該在源代碼中存儲密碼和其他的敏感數據，一種推薦的方式是通過Asp.Net Core的機密管理器。 機密管理器 在 ASP.NET Core ...
  • C# - 能否讓 SortedSet.RemoveWhere 內傳入的委托非同步執行
    新改進提供的Taurus Rpc 功能，可以簡化微服務間的調用，同時可以不用再手動輸出模塊名稱，或調用路徑，包括負載均衡，這一切，由框架實現並提供了。新的Taurus Rpc 功能，將使得服務間的調用，更加輕鬆、簡約、高效。 ...
  • 順序棧的介面程式
    順序棧的介面程式 目錄順序棧的介面程式頭文件創建順序棧入棧出棧利用棧將10進位轉16進位數驗證 頭文件 #include <stdio.h> #include <stdbool.h> #include <stdlib.h> 創建順序棧 // 指的是順序棧中的元素的數據類型，用戶可以根據需要進行修改 ...
  • mORMot2 獲取數據集1
    前言 整理這個官方翻譯的系列，原因是網上大部分的 tomcat 版本比較舊，此版本為 v11 最新的版本。 開源項目 從零手寫實現 tomcat minicat 別稱【嗅虎】心有猛虎，輕嗅薔薇。 系列文章 web server apache tomcat11-01-官方文檔入門介紹 web serv ...
  • 萬字長文總結與剖析C語言關鍵字 -- <<C語言深度解剖>>
    C總結與剖析:關鍵字篇 -- <<C語言深度解剖>> 目錄C總結與剖析:關鍵字篇 -- <<C語言深度解剖>>程式的本質:二進位文件變數1.變數:記憶體上的某個位置開闢的空間2.變數的初始化3.為什麼要有變數4.局部變數與全局變數5.變數的大小由類型決定6.任何一個變數,記憶體賦值都是從低地址開始往高地 ...
  • 【Flink入門修煉】2-3 Flink Checkpoint 原理機制
    如果讓你來做一個有狀態流式應用的故障恢復，你會如何來做呢？ 單機和多機會遇到什麼不同的問題？ Flink Checkpoint 是做什麼用的？原理是什麼？ ...
  • C++ 多級繼承與多重繼承：代碼組織與靈活性的平衡
    C++ 多級繼承 多級繼承是一種面向對象編程（OOP）特性，允許一個類從多個基類繼承屬性和方法。它使代碼更易於組織和維護，並促進代碼重用。 多級繼承的語法 在 C++ 中，使用 : 符號來指定繼承關係。多級繼承的語法如下： class DerivedClass : public BaseClass1 ...
  • 圖文結合手把手教你創建SpringCloud項目
    前言 什麼是SpringCloud？ Spring Cloud 是一系列框架的有序集合，它利用 Spring Boot 的開發便利性簡化了分散式系統的開發，比如服務註冊、服務發現、網關、路由、鏈路追蹤等。Spring Cloud 並不是重覆造輪子，而是將市面上開發得比較好的模塊集成進去，進行封裝，從 ...
  • 類模板的常見用法
    class_template 類模板和函數模板的定義和使用類似，我們已經進行了介紹。有時，有兩個或多個類，其功能是相同的，僅僅是數據類型不同。類模板用於實現類所需數據的類型參數化 template<class NameType, class AgeType> class Person { publi ...
  • system-v IPC共用記憶體通信
    目錄system v IPC簡介共用記憶體需要用到的函數介面shmget函數--獲取對象IDshmat函數--獲得映射空間shmctl函數--釋放資源共用記憶體實現思路註意 system v IPC簡介 消息隊列、共用記憶體和信號量統稱為system v IPC(進程間通信機制)，V是羅馬數字5，是UNI ...
所有分類