国产xxxx99真实实拍_久久不雅视频_高清韩国a级特黄毛片_嗯老师别我我受不了了小说

資訊專欄INFORMATION COLUMN

python設計模式-工廠方法模式

pubdreamcc / 1775人閱讀

摘要:工廠方法模式可以幫助我們將產品的實現從使用中解耦。應用中使用工廠模式的例子的模塊使用工廠方法模式來創建表單字段。也使用到了工廠方法模式。中不同數據庫連接部分也用到了工廠方法模式。

題目:假設你有一個 pizza 店,功能包括下訂單做 pizza,你的代碼會如何寫呢?

def order_pizza():
    pizza = Pizza()
    pizza.prepare()
    pizza.bake()
    pizza.cut()
    pizza.box()
    return pizza

但是現在你遇到了一個問題,你的 pizza 店需要更多的 pizza,所以現在你需要增加一些代碼,來決定適合的 pizza 類型,然后再制造這個 pizza:

def order_pizza(pizza_type):  # 現在把 pizza 的類型傳入 order_pizza()

    # 根據 pizza 類型,我們實例化正確的具體類,然后將其賦值給 pizza 實例變量
    if pizza_type == "cheese":
        pizza = CheesePizza()
    elif pizza_type == "greek":
        pizza = GreekPizza()
    elif pizza_type == "pepperoni":
        pizza = PepperoniPizza()
    # 一旦我們有了一個 pizza,需要做一些準備(搟面皮、加佐料),然后烘烤、切片、裝盒
    pizza.prepare()
    pizza.bake()
    pizza.cut()
    pizza.box()
    return pizza

但是經過幾天的實踐,你發現顧客喜歡點的 ClamPizza、Veggie Pizza 而 Greek pizza 并沒有什么人喜歡,這個時候需要修改代碼:

def order_pizza(pizza_type):  # 現在把 pizza 的類型傳入 order_pizza()

    # 根據 pizza 類型,我們實例化正確的具體類,然后將其賦值給 pizza 實例變量
    if pizza_type == "cheese":
        pizza = CheesePizza()
    # elif pizza_type == "greek":  # greek pizza 不再出現在菜單
    #     pizza = GreekPizza()
    elif pizza_type == "pepperoni":
        pizza = PepperoniPizza()
    # 新加了 clam pizza 和 veggie pizza
    elif pizza_type == "clam":
        pizza = ClamPizza()
    elif pizza_type == "veggie":
        pizza = VeggiePizza()

    #  一旦我們有了一個 pizza,需要做一些準備(搟面皮、加佐料),然后烘烤、切片、裝盒
    pizza.prepare()
    pizza.bake()
    pizza.cut()
    pizza.box()
    return pizza

現在你發現了一個問題, order_pizza() 是在內部實例化了具體的 Pizza 類,并且,order_pizza() 也沒有對修改關閉,以至于每次有了新的 pizza 加入都要修改 order_pizza() 的代碼。這時一個比較好的辦法是把創建 Pizza 對象是抽象出來,修改后的代碼如下:

# 把創建對象的代碼從 order_pizza 方法中抽離
def create_pizza(pizza_type):
    # 根據 pizza 類型,我們實例化正確的具體類,然后將其賦值給 pizza 實例變量
    if pizza_type == "cheese":
        pizza = CheesePizza()
    elif pizza_type == "pepperoni":
        pizza = PepperoniPizza()
    elif pizza_type == "clam":
        pizza = ClamPizza()
    elif pizza_type == "veggie":
        pizza = VeggiePizza()
    return pizza

def order_pizza(pizza_type):  # 現在把 pizza 的類型傳入 order_pizza()
    # 這里使用 create_pizza() 方法創建 pizza 類
    pizza = create_pizza(pizza_type)

    #  一旦我們有了一個 pizza,需要做一些準備(搟面皮、加佐料),然后烘烤、切片、裝盒
    pizza.prepare()
    pizza.bake()
    pizza.cut()
    pizza.box()
    return pizza
簡單工廠模式

我們把創建 pizza 對象的代碼提取到一個新的方法中,我們稱這個新的方法叫做工廠

工廠處理創建對象的細節,一旦有了create_pizzaorder_pizza() 就成了此對象的客戶。當需要 pizza 時,只需要告訴工廠需要什么類型的 pizza,讓它做一個即可。

現在 order_pizza() 方法只關心從工廠得到一個 pizza,這個 pizza 實現了 Pizza 的接口,所以它可以調用 prepare()(準備)bake()(烘烤)cut()(切片)box()(裝盒)

問:現在你可能會問,這段代碼看上去更復雜了,有什么好處了呢?看上去只是把問題搬到另一個對象了。

答: 現在看來,order_pizza 只是create_pizza 的一個客戶,其它客戶(比如pizza 店菜單 PizzaShopMenu)也可以使用這個工廠來取得 pizza。把創建 pizza 的代碼包裝進一個類,當以后實現修改時,只需要修改這個部分代碼即可。

這里我們的工廠create_order() 是一個簡單的方法,利用方法定義一個簡單工廠的方法通常被稱為簡單工廠模式簡單工廠更像是一中編程習慣而不是設計模式)。

重做 PizzaStore 類

上邊的代碼中,order_pizza 是客戶代碼,但是為了讓我們的 pizza 店有更好的擴展性,這里我們需要把客戶代碼做一下修改:

class SimplePizzaFactory:

    def create_pizza(self, pizza_type):
        ...
        return pizza

class PizzaStore:
    def order_pizza(self, pizza_type):  # 現在把 pizza 的類型傳入 order_pizza()
        factory = SimplePizzaFactory()
        pizza = factory.create_pizza(pizza_type)
        ...
        return pizza
    
    # 下邊是其他可能用到的方法

這段代碼中,我們把一個方法(create_pizza)使用類(SimplePizzaFactory)封裝了起來,目的是使工廠可以通過繼承來改變創建方法的行為,并且這樣做,也可以提高工廠方法的擴展性。

現在來看一下我們 pizza 店的類圖:

簡單工廠模式的局限 缺點

由于工廠類集中了所有產品創建邏輯,違反了高內聚責任分配原則,一旦不能正常工作,整個系統都要受到影響。

系統擴展困難,一旦添加新產品就不得不修改工廠邏輯,在產品類型較多時,有可能造成工廠邏輯過于復雜,不利于系統的擴展和維護。

使用場景

工廠類負責創建的對象較少

客戶只知道傳入工廠類的參數,對于如何創建對象(邏輯)不關心;客戶端既不需要關心創建細節,甚至連類名都不需要記住,只需要知道類型所對應的參數。

為了突破這些局限,我們接著看一下工廠方法模式

工廠方法模式

現在我們有了一個新的問題,我們創建 pizza 店后,現在有人想要加盟,但我們還想要控制一下 pizza 的制作流程,該如何實現呢?

首先,要給 pizza 店使用框架,我們所要做的就是把create_pizza()方法放回到PizzaStore類中,不過這個方法需要在每個子類中倒要實現一次。現在 PizzaStore代碼為:

class PizzaStore:

    def create_pizza(self, pizza_type):
        # 每個需要子類實現的方法都會拋出NotImplementedError
        # 我們也可以把 PizzaStore 的 metaclass 設置成 abc.ABCMeta
        # 這樣的話,這個類就是真正的抽象基類
        raise NotImplementedError()

    def order_pizza(self, pizza_type):  # 現在把 pizza 的類型傳入 order_pizza()

        pizza = self.create_pizza(pizza_type)

        #  一旦我們有了一個 pizza,需要做一些準備(搟面皮、加佐料),然后烘烤、切片、裝盒
        pizza.prepare()
        pizza.bake()
        pizza.cut()
        pizza.box()
        return pizza

這樣我們就聲明了一個工廠方法。這個工廠方法用來處理對象的創建,并將這個創建行為封裝在子類中,這樣客戶程序中關于父類的代碼就和子類的對象創建代碼解耦成功。

我們將 create_pizza 放回 PizzaStore 的目的是讓繼承此方法的子類負責定義自己的create_pizza() 方法。現在我們看一下PizzaStore 的子類示意圖:

這里 NYStlyePizzaStoreChicagoStylePizzaStore 需要分別定義自己的 create_pizza 方法。

現在來看下完整代碼:

#! -*- coding: utf-8 -*-

class Pizza:

    name = None
    dough = None
    sauce = None
    toppings = []

    def prepare(self):
        print("Preparing %s" % self.name)
        print("Tossing dough...")
        print("Adding sauce...")
        print("Adding toppings: ")
        for topping in self.toppings:
            print("  %s" % topping)

    def bake(self):
        print("Bake for 25 minutes at 350")

    def cut(self):
        print("Cutting the pizza into diagonal slices")

    def box(self):
        print("Place pizza in official PizzaStore box")

    def __str__(self):
        return self.name


class NYStyleCheesePizza(Pizza):

    name = "NY Style Sauce and Cheese Pizza"
    dough = "Thin Crust Dough"
    sauce = "Marinara Sauce"
    toppings = ["Grated", "Reggiano", "Cheese"]


class ChicagoStyleCheesePizza(Pizza):

    name = "Chicago Style Deep Dish Cheese Pizza"
    dough = "Extra Thick Crust Dough"
    sauce = "Plum Tomato Sauce"
    toppings = ["Shredded", "Mozzarella", "Cheese"]

    def cut(self):
        print("Cutting the pizza into square slices")


class PizzaStore:
    def create_pizza(self, pizza_type):
        # 每個需要子類實現的方法都會拋出NotImplementedError
        # 我們也可以把 PizzaStore 的 metaclass 設置成 abc.ABCMeta
        # 這樣的話,這個類就是真正的抽象基類
        raise NotImplementedError()

    def order_pizza(self, pizza_type):  # 現在把 pizza 的類型傳入 order_pizza()

        pizza = self.create_pizza(pizza_type)

        #  一旦我們有了一個 pizza,需要做一些準備(搟面皮、加佐料),然后烘烤、切片、裝盒
        pizza.prepare()
        pizza.bake()
        pizza.cut()
        pizza.box()
        return pizza

class NYStylePizzStore(PizzaStore):
    def create_pizza(self, pizza_type):
        # 根據 pizza 類型,我們實例化正確的具體類,然后將其賦值給 pizza 實例變量
        if pizza_type == "cheese":
            pizza = NYStyleCheesePizza()
        return pizza


class ChicagoStylePizzaStore(PizzaStore):
    def create_pizza(self, pizza_type):
        # 根據 pizza 類型,我們實例化正確的具體類,然后將其賦值給 pizza 實例變量
        if pizza_type == "cheese":
            pizza = ChicagoStyleCheesePizza()
        return pizza


def main():
    nystore = NYStylePizzStore()
    pizza = nystore.order_pizza("cheese")
    print("goodspeed ordered a %s" % pizza)

    print("*" * 100)
    chicago_store = ChicagoStylePizzaStore()
    pizza = chicago_store.order_pizza("cheese")
    print("goodspeed ordered a %s" % pizza)


if __name__ == "__main__":
    main()

這里工廠方法 create_pizza() 直接拋出了NotImplementedError,這樣做事為了強制子類重新實現 create_pizza() 方法,如果不重新實現就會拋出NotImplementedError
當然也可以把 PizzaStore 的 metaclass 設置成 abc.ABCMeta 這樣的話,這個類就是真正的抽象基類。

現在我們看一下工廠方法模式的類圖:

產品類和創建者類其實是平行的類的層級它們的關系如下圖:

工廠方法模式定義

通過上文的介紹,我們可以得到工廠方法模式大概的定義:

工廠方法模式中,工廠父類負責定義創建產品對象的公共接口,而工廠子類則負責生成具體的產品對象,這樣做的目的是將產品類的實例化操作延遲到工廠子類中完成,即通過工廠子類來確定究竟應該實例化哪一個具體產品類。

工廠方法模式能夠封裝具體類型的實例化,抽象的 Creator 提供了一個創建對象的工廠方法。在抽象的 Creator 中,任何其他實現的方法,都可能使用到這個方法鎖制造出來的產品,但只有子類真正實現這個工廠方法并創建產品。

下圖是工廠方法模式原理類圖:

工廠方法模式優點

工廠方法集中的在一個地方創建對象,使對象的跟蹤變得更容易。

工廠方法模式可以幫助我們將產品的實現從使用解耦。如果增加產品或者改變產品的實現,Creator 并不會收到影響。

使用工廠方法模式的另一個優點是在系統中加入新產品時,無須修改抽象工廠和抽象產品提供的接口,無須修改客戶端,也無須修改其他的具體工廠和具體產品,而只要添加一個具體工廠和具體產品就可以了。這樣,系統的可擴展性也就變得非常好,完全符合“開閉原則”。

工廠方法可以在必要時創建新的對象,從而提高性能和內存使用率。若直接實例化類來創建對象,那么每次創建新對象就需要分配額外的內存。

簡單工廠工廠方法之間的差異

簡單工廠把全部的事情在一個地方處理完了(create_pizza),而工廠方法是創建了一個框架,讓子類去決定如何實現。比如在工廠方法中,order_pizza() 方法提供了一般的框架用來創建 pizza,order_pizza() 方法依賴工廠方法創建具體類,并制造出實際的 pizza。而制造什么樣的 pizza 是通過繼承 PizzaStore來實現的。 但 簡單工廠 只是把對象封裝起來,并不具備工廠方法的彈性。

python 應用中使用工廠模式的例子

Django 的 forms 模塊使用工廠方法模式來創建表單字段。WTForm 也使用到了工廠方法模式。sqlalchemy 中不同數據庫連接部分也用到了工廠方法模式。

總結

工廠方法模式的核心思想是定義一個用來創建對象的公共接口,由工廠而不是客戶來決定需要被實例化的類,它通常在構造系統整體框架時被用到。工廠方法模式看上去似乎比較簡單,但是內涵卻極其深刻,抽象、封裝、繼承、委托、多態等面向對象設計中的理論都得到了很好的體現,應用范圍非常廣泛。

參考

《Head First 設計模式》

《精通 python 設計模式》

《Python 編程實戰》

Python設計模式系列之三: 創建型Factory Method模式


最后,感謝女朋友支持。

歡迎關注(April_Louisa) 請我喝芬達

文章版權歸作者所有,未經允許請勿轉載,若此文章存在違規行為,您可以聯系管理員刪除。

轉載請注明本文地址:http://specialneedsforspecialkids.com/yun/40931.html

相關文章

  • python設計模式-抽象工廠模式

    摘要:源碼參考抽象工廠模式抽象工廠模式提供一個接口,用于創建相關或依賴對象的家族,而不需要指定具體類。工廠方法模式和抽象工廠模式如何選擇開始的時候,可以選擇工廠方法模式,因為他很簡單只需要繼承,并實現工廠方法即可。 問題:在上一篇 python設計模式:工廠方法模式我們嘗試使用工廠方法創建了披薩店,現在為了保證披薩加盟店也能有良好的聲譽,我們需要統一原材料,這個該如何做呢? 為了確保每家加盟...

    seal_de 評論0 收藏0
  • Python實現設計模式——工廠模式

    摘要:本文會用實現三種工廠模式的簡單例子,所有代碼都托管在上。工廠方法模式繼承了簡單工廠模式的優點又有所改進,其不再通過一個工廠類來負責所有產品的創建,而是將具體創建工作交給相應的子類去做,這使得工廠方法模式可以允許系統能夠更高效的擴展。 前言 工廠模式,顧名思義就是我們可以通過一個指定的工廠獲得需要的產品,在設計模式中主要用于抽象對象的創建過程,讓用戶可以指定自己想要的對象而不必關心對象的...

    CrazyCodes 評論0 收藏0
  • 設計模式工廠方法模式

    摘要:通過工廠方法模式的類圖可以看到,工廠方法模式有四個要素工廠接口工廠接口是工廠方法模式的核心,與調用者直接交互用來提供產品。使用場景創建類模式,在任何需要生成復雜對象的地方,都可以使用工廠方法模式。 0x01.定義與類型 定義:定義一個創建對象的接口,但讓實現這個接口的類來決定實例化那個類,工廠方法讓類的實例化推遲到子類中進行 類型:創建型 uml類圖 showImg(https:/...

    geekidentity 評論0 收藏0
  • 設計模式之抽象工廠模式

    摘要:所謂的產品族,一般或多或少的都存在一定的關聯,抽象工廠模式就可以在類內部對產品族的關聯關系進行定義和描述,而不必專門引入一個新的類來進行管理。 0x01.定義與類型 定義:抽象工廠模式提供一個創建一系列相關或相互依賴對象的接口 無需指定它們具體的類 類型:創建型 UML showImg(https://segmentfault.com/img/bVbtBp1?w=800&h=862...

    Acceml 評論0 收藏0
  • python之單例模式工廠模式

    摘要:在工廠方法模式中,我們會遇到一個問題,當產品非常多時,繼續使用工廠方法模式會產生非常多的工廠類。從簡單工廠模式到抽象工廠模式,我們都是在用后一種模式解決前一種模式的缺陷,都是在最大程度降低代碼的耦合性。 單例模式 所謂單例模式,也就是說不管什么時候我們要確保只有一個對象實例存在。很多情況下,整個系統中只需要存在一個對象,所有的信息都從這個對象獲取,比如系統的配置對象,或者是線程池。這些...

    jayce 評論0 收藏0

發表評論

0條評論

最新活動
閱讀需要支付1元查看
<