?

---

知識儲備：

1.接口：若干抽象方法的集合

　　作用：限制實現接口的類必須按照接口給定的調用方式實現這些方法；對高層模塊隱藏了類的內部實現。

2.面向對象設計SOLID原則

• 開放封閉原則：一個軟件實體如類、模塊和函數應該對擴展開放，對修改關閉。即軟件實體應盡量在不修改原有代碼的情況下進行擴展。
• 里氏替換原則：所有引用父類的地方必須能透明的使用其子類的對象。
• 依賴倒置原則：高層模塊不應該依賴底層模塊，二者都應該依賴其抽象；抽象不應該依賴細節；細節應該依賴抽象。換言之，要針對接口編程，而不是針對實現編程。
• 接口隔離原則：使用多個專門的接口，而不使用單一的總接口，即客戶端不應該依賴那些它不需要的接口。
• 單一職責原則：不要存在多于一個導致類變更的原因。通俗的說，即一個類只負責某一項職責。

3.設計模式分類

創建型模式（5種）：工廠方法模式、抽象工廠模式、創建者模式、原型模式、單例模式

結構型模式（7種）：適配器模式、橋模式、組合模式、裝飾模式、外觀模式、享元模式、代理模式

行為型模式（11種）：解釋器模式、責任鏈模式、命令模式、迭代器模式、中介者模式、備忘錄模式、觀察者模式、狀態模式、策略模式、訪問者模式、模板方法模式

?

1、簡單工廠模式

內容：不直接向客戶端暴露對象創建的實現細節，而是通過一個工廠類來負責創建產品類的實例。

角色：

• 工廠角色（Creator）
• 抽象產品角色（Product）
• 具體產品角色（Concrete Product）

from abc import ABCMeta, abstractmethodclass Payment(metaclass=ABCMeta):# abstract class@abstractmethoddef pay(self, money):passclass Alipay(Payment):def __init__(self, use_huabei=False):self.use_hubei = use_huabeidef pay(self, money):if self.use_hubei:print("花唄支付%d元" % money)else:print("支付寶余額支付%d" % money)class Wechat(Payment):def pay(self, money):print("微信支付%d元" % money)# 工廠類 class PaymentFactory:def create_payment(self, method):if method == 'alipay':return Alipay()elif method == 'wechat':return Wechat()elif method == 'huabei':return Alipay(use_huabei=True)else:raise TypeError("No such payment named %s" % method)# client pf = PaymentFactory() p = pf.create_payment('huabei') p.pay(100)## 工廠角色： PaymentFactory 抽象產品角色：Payment 具體產品角色：Alipay，WechatPay View Code

優點：

　　1.隱藏了對象創建的實現細節

　　2.客戶端不需要修改代碼

缺點：

　　1.違反了單一職責原則，將創建邏輯集中到一個工廠類里

　　2.當添加新產品時，需要修改工廠類代碼，違反了開閉原則

?

2、工廠方法模式

內容：定義一個用于創建對象的接口（工廠接口），讓子類決定實例化哪一個產品類。

角色：

• 抽象工廠角色（Creator）
• 具體工廠角色（Concrete Cretor）
• 抽象產品角色（Product）
• 具體產品角色（Concrete Product）

from abc import ABCMeta, abstractmethodclass Payment(metaclass=ABCMeta):@abstractmethoddef pay(self, money):passclass PaymentFactory(metaclass=ABCMeta):@abstractmethoddef create_payment(self):passclass Alipay(Payment):def __init__(self, use_huabei=False):self.use_huabei = use_huabeidef pay(self, money):if self.use_huabei:print("花唄支付%d元" % money)else:print("支付寶余額支付%d元" % money)class Wechat(Payment):def pay(self, money):print("微信支付%d元" %money)class AlipayFactory(PaymentFactory):def create_payment(self):return Alipay()class WechatPayFactory(PaymentFactory):def create_payment(self):return Wechat()# clientpf = AlipayFactory() p = pf.create_payment() p.pay(100)##抽象工廠角色：PaymentFactory具體工廠角色：AliFactory,WechatFactory抽象產品角色：Payment具體產品角色：AliPay，WechatPay View Code

優點：

　　1.每個產品都對應一個具體工廠類，不需要修改修改共產類代碼

　　2.隱藏了對象創建的實現細節

缺點：

　　1.每增加一個具體產品類，就必須增加一個相應的具體工廠類

?

3、抽象工廠模式

內容：定義一個工廠類接口，讓工廠子類來創建一系列相關或相互依賴的對象。

例：生產一部手機，需要手機殼、CPU、操作系統三類對象進行組裝，其中每類都有不同的種類。對每個具體工廠，分別生產一部手機所需要的三個對象。

相比工廠方法模式，抽象工廠模式中的每個具體工廠都生產一套產品。

角色：

• 抽象工廠角色（Creator）
• 具體工廠角色（Concrete Cretor）
• 抽象產品角色（Product）
• 具體產品角色（Concrete Product）
• 客戶端（Client）

from abc import abstractmethod, ABCMeta# ------抽象產品------class PhoneShell(metaclass=ABCMeta):@abstractmethoddef show_shell(self):passclass CPU(metaclass=ABCMeta):@abstractmethoddef show_cpu(self):passclass OS(metaclass=ABCMeta):@abstractmethoddef show_os(self):pass# ------抽象工廠------class PhoneFactory(metaclass=ABCMeta):@abstractmethoddef make_shell(self):pass@abstractmethoddef make_cpu(self):pass@abstractmethoddef make_os(self):pass# ------具體產品------class SmallShell(PhoneShell):def show_shell(self):print("普通手機小手機殼")class BigShell(PhoneShell):def show_shell(self):print("普通手機大手機殼")class AppleShell(PhoneShell):def show_shell(self):print("蘋果手機殼")class SnapDragonCPU(CPU):def show_cpu(self):print("驍龍CPU")class MediaTekCPU(CPU):def show_cpu(self):print("聯發科CPU")class AppleCPU(CPU):def show_cpu(self):print("蘋果CPU")class Android(OS):def show_os(self):print("Android系統")class IOS(OS):def show_os(self):print("iOS系統")# ------具體工廠------class MiFactory(PhoneFactory):def make_cpu(self):return SnapDragonCPU()def make_os(self):return Android()def make_shell(self):return BigShell()class HuaweiFactory(PhoneFactory):def make_cpu(self):return MediaTekCPUdef make_os(self):return Android()def make_shell(self):return SmallShell()class IPhoneFactory(PhoneFactory):def make_cpu(self):return AppleCPU()def make_os(self):return IOS()def make_shell(self):return AppleShell()# ------客戶端------class Phone:def __init__(self, cpu, os, shell):self.cpu = cpuself.os = osself.shell = shelldef show_info(self):print("手機信息")self.cpu.show_cpu()self.os.show_os()self.shell.show_shell()def make_phone(factory):cpu = factory.make_cpu()os = factory.make_os()shell = factory.make_shell()return Phone(cpu, os, shell)p1 = make_phone(IPhoneFactory()) p1.show_info() View Code

優點：

　　1.將客戶端與類的具體實現相分離

　　2.每個工廠創建了一個完整的產品系列，使得易于交換產品系列

　　3.有利于產品一致性（即產品之間的約束關系）

缺點：

　　1.難以支持新種類的（抽象）產品

?

4、創建者模式

內容：將一個復雜對象的構造與它的表示分離，使得同樣的構建過程可以創建不同的表示。

角色：

• 抽象建造者（Builder）
• 具體建造者（Concrete Builder）
• 指揮者（Director）
• 產品（Product）

from abc import ABCMeta, abstractmethodclass Player:def __init__(self, face=None, body=None, arm=None, leg=None):self.face = faceself.body = bodyself.arm = armself.leg = legdef __str__(self):return "%s, %s, %s, %s" % (self.face, self.body, self.arm, self.leg)class PlayerBuilder(metaclass=ABCMeta):@abstractmethoddef build_face(self):pass@abstractmethoddef build_body(self):pass@abstractmethoddef build_arm(self):pass@abstractmethoddef build_leg(self):passclass SexyGirlBuilder(PlayerBuilder):def __init__(self):self.player = Player()def build_face(self):self.player.face = "漂亮臉蛋"def build_body(self):self.player.body = "苗條"def build_arm(self):self.player.arm = "漂亮胳膊"def build_leg(self):self.player.leg = "大長腿"class Monster(PlayerBuilder):def __init__(self):self.player = Player()def build_face(self):self.player.face = "怪獸臉"def build_body(self):self.player.body = "怪獸身材"def build_arm(self):self.player.arm = "長毛的胳膊"def build_leg(self):self.player.leg = "長毛的腿"class PlayerDirector: # 控制組裝順序def build_player(self, builder):builder.build_body()builder.build_face()builder.build_arm()builder.build_leg()return builder.player# clientbuilder = Monster() director = PlayerDirector() p = director.build_player(builder) print(p)##抽象建造者：PlayerBuilder具體建造者：SexyGirlBuilder， Monster指揮者：PlayerDirector產品：p View Code

建造者模式與抽象工廠模式類似，也用來創建復雜對象。主要區別是建造者模式著重一步步構造一個復雜對象，而抽象工廠模式著重于多個系列的產品對象。

優點:

　? ?1.隱藏了一個產品的內部結構和裝配過程

　　2.將構造代碼與表示代碼分開

　　3.可以對構造過程更精細的控制　

?

5、單例模式

內容：保證一個類只有一個實例，并提供一個訪問它的全局訪問點

角色：

• 單例

優點：

　　1.對唯一實例的受控訪問

　　2.單例相當于全局變量，但防止了命名空間被污染。

class Singleton:def __new__(cls, *args, **kwargs):if not hasattr(cls, "_instance"):cls._instance = super(Singleton, cls).__new__(cls)return cls._instanceclass Myclass(Singleton):def __init__(self, a):self.a = aa = Myclass(10) b = Myclass(20)print(a.a) print(b.a) print(id(a), id(b)) View Code

?

## 創建型模式小結 1、抽象工廠模式和建造者模式相比于簡單工廠模式和工廠方法模式而言更靈活也更復雜。 2、通常情況下，設計以簡單工廠模式或工廠方法模式開始，當你發現設計需要更大的靈活性時，則像更復雜的設計模式演化。

?

轉載于:https://www.cnblogs.com/Xuuuuuu/p/10856870.html

總結

以上是生活随笔為你收集整理的设计模式一：创建型模式的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。