Concept-概念前置
設(shè)計(jì)模式：軟件設(shè)計(jì)中普遍存在（反復(fù)出現(xiàn)）的各種問(wèn)題，所提出的解決方案。
面向?qū)ο笕筇匦裕悍庋b、繼承、多態(tài)。
面向?qū)ο笤O(shè)計(jì)的SOLID原則：
（1）開放封閉原則：一個(gè)軟件實(shí)體如類、模塊和函數(shù)應(yīng)該對(duì)擴(kuò)展開放，對(duì)修改關(guān)閉。即軟件實(shí)體應(yīng)盡量在不修改原有代碼的情況下進(jìn)行擴(kuò)展。
（2）里氏替換原則：所有引用父類的地方必須能透明地使用其子類的對(duì)象。
（3）依賴倒置原則：高層模塊不應(yīng)該依賴低層模塊，二者都應(yīng)該依賴其抽象； 抽象不應(yīng)該依賴細(xì)節(jié)；細(xì)節(jié)應(yīng)該依賴抽象。
（4）接囗隔離原則：使用多個(gè)專門的接口，而不使用單一的總接口，即客戶端不應(yīng)該依賴那些它不需要的接口。
（5）單一職責(zé)原則：不要存在多于一個(gè)導(dǎo)致類變更的原因，即一個(gè)類只負(fù)責(zé)一項(xiàng)職責(zé)。
?
舉個(gè)例子，可能有不止一塊代碼調(diào)用到該實(shí)體，這時(shí)候去修改實(shí)體里的代碼，就很可能引起其他模塊會(huì)出現(xiàn)問(wèn)題，當(dāng)模塊關(guān)聯(lián)較多時(shí)就會(huì)引起不必要的工作量，這是1；
原方法支持父類，當(dāng)我們?cè)诨A(chǔ)上加或修改功能而衍生的子類也應(yīng)當(dāng)符合，這是2；
要針對(duì)接口編程， 而不是針對(duì)實(shí)現(xiàn)編程，實(shí)現(xiàn)上也就是對(duì)底層的依賴按接口格式去寫，再實(shí)現(xiàn)，而不是隨意修改參數(shù)格式，即3。
創(chuàng)建型模式
簡(jiǎn)單工廠模式，工廠方法模式，抽象工廠模式，創(chuàng)建者模式，原型模式，單例模式。
| 創(chuàng)建型模式（Creational Pattern） | 一種用于?創(chuàng)建對(duì)象?的設(shè)計(jì)模式。它們包含一些通用的方法，更加靈活地創(chuàng)建對(duì)象，且?封裝?了對(duì)象的實(shí)例化過(guò)程 |
| 工廠模式（Factory Pattern） | 用于根據(jù)?客戶端需求動(dòng)態(tài)創(chuàng)建?對(duì)象。 （包括簡(jiǎn)單工廠模式，工廠方法模式，抽象工廠模式） |
| 單例模式（Singleton Pattern） | 用于確保一個(gè)類?只有一個(gè)?實(shí)例，并提供對(duì)該實(shí)例的全局訪問(wèn)點(diǎn)。它通常被用于管理共享資源或者限制系統(tǒng)中某些類的實(shí)例數(shù)量。 |
| 建造者模式（Builder Pattern） | 用于將一個(gè)復(fù)雜對(duì)象的?構(gòu)建過(guò)程分離?成多個(gè)簡(jiǎn)單的步驟，從而可以靈活地組合和構(gòu)建不同的對(duì)象。它通常被用于創(chuàng)建復(fù)雜的對(duì)象，比如包含多個(gè)組件或者配置項(xiàng)的對(duì)象。 |
| 原型模式（Prototype Pattern） | 用于?復(fù)制或克隆?已有的對(duì)象，從而創(chuàng)建新的對(duì)象。它通過(guò)克隆現(xiàn)有對(duì)象來(lái)創(chuàng)建新對(duì)象，從而避免了昂貴的初始化操作。 |
工廠模式
Factory Pattern
簡(jiǎn)單工廠模式（Simple Factory Pattern）：簡(jiǎn)單工廠模式是一種基本的工廠模式，通常由一個(gè)工廠類根據(jù)傳入的參數(shù)動(dòng)態(tài)決定創(chuàng)建哪種產(chǎn)品類的實(shí)例。（簡(jiǎn)單而言：一個(gè)工廠類根據(jù)傳入?yún)?shù)創(chuàng)建哪個(gè)類實(shí)例） 場(chǎng)景：適用于對(duì)象較少且產(chǎn)品等級(jí)結(jié)構(gòu)穩(wěn)定的情況。 Characters: 工廠角色（Factory） 抽象產(chǎn)品角色（Product） 具體產(chǎn)品角色（Concrete Product）
class Product:
def use(self):
pass
class ConcreteProductA(Product):
def use(self):
print("Using product A.")
class ConcreteProductB(Product):
def use(self):
print("Using product B.")
class Factory:
@staticmethod
def create_product(product_type):
if product_type == "A":
return ConcreteProductA()
elif product_type == "B":
return ConcreteProductB()
product_a = Factory.create_product("A")
product_a.use() # 輸出：Using product A.
product_b = Factory.create_product("B")
product_b.use() # 輸出：Using product B.工廠方法模式（Factory Method Pattern）：將實(shí)際創(chuàng)建對(duì)象的工作推遲到子類中完成?？梢栽诓恍薷墓S類的情況下，增加新的產(chǎn)品系列和產(chǎn)品等級(jí)結(jié)構(gòu)。（簡(jiǎn)單而言：工廠類抽象化，將增改操作下發(fā)給子類） 場(chǎng)景: 工廠方法模式適用于對(duì)象數(shù)量較多且產(chǎn)品等級(jí)結(jié)構(gòu)較為復(fù)雜的情況。 Characters: 工廠角色（Factory） 具體工廠角色（Concrete Factory） 抽象產(chǎn)品角色（Product） 具體產(chǎn)品角色（Concrete Product）
class Product:
def use(self):
pass
class ConcreteProductA(Product):
def use(self):
print("Using product A.")
class ConcreteProductB(Product):
def use(self):
print("Using product B.")
class Factory:
def create_product(self):
pass
class ConcreteFactoryA(Factory):
def create_product(self):
return ConcreteProductA()
class ConcreteFactoryB(Factory):
def create_product(self):
return ConcreteProductB()
factory_a = ConcreteFactoryA()
product_a = factory_a.create_product()
product_a.use() # 輸出：Using product A.
factory_b = ConcreteFactoryB()
product_b = factory_b.create_product()
product_b.use() # 輸出：Using product B.抽象工廠模式（Abstract Factory Pattern）：是一種將工廠類進(jìn)行抽象化的進(jìn)一步改進(jìn)，它使用了對(duì)象組合的方式來(lái)構(gòu)建不同的產(chǎn)品族。（工廠抽象化，組合各種產(chǎn)品，有點(diǎn)像工廠方法模式的不同類方法組合）
場(chǎng)景: 抽象工廠模式可以同時(shí)創(chuàng)建多個(gè)不同的產(chǎn)品，且這些產(chǎn)品之間存在著一定的關(guān)聯(lián)性。文章來(lái)源：http://www.zghlxwxcb.cn/news/detail-476834.html
Characters: 工廠角色（Factory） 具體工廠角色（Concrete Factory） 抽象產(chǎn)品角色（Product） 具體產(chǎn)品角色（Concrete Product） 客戶端（Client）文章來(lái)源地址http://www.zghlxwxcb.cn/news/detail-476834.html
class ProductA:
def use(self):
pass
class ConcreteProductA1(ProductA):
def use(self):
print("Using product A1.")
class ConcreteProductA2(ProductA):
def use(self):
print("Using product A2.")
class ProductB:
def operate(self):
pass
class ConcreteProductB1(ProductB):
def operate(self):
print("Operating product B1.")
class ConcreteProductB2(ProductB):
def operate(self):
print("Operating product B2.")
class Factory:
def create_product_a(self):
pass
def create_product_b(self):
pass
class ConcreteFactory1(Factory):
def create_product_a(self):
return ConcreteProductA1()
def create_product_b(self):
return ConcreteProductB1()
class ConcreteFactory2(Factory):
def create_product_a(self):
return ConcreteProductA2()
def create_product_b(self):
return ConcreteProductB2()
factory_1 = ConcreteFactory1()
product_a1 = factory_1.create_product_a()
product_a1.use() # 輸出：Using product A1.
product_b1 = factory_1.create_product_b()
product_b1.operate() # 輸出：Operating product B1.
factory_2 = ConcreteFactory2()
product_a2 = factory_2.create_product_a()
product_a2.use() # 輸出：Using product A2.
product_b2 = factory_2.create_product_b()
product_b2.operate() # 輸出：Operating product B2.單例模式
Singleton Pattern
保證一個(gè)類僅有一個(gè)實(shí)例，并提供訪問(wèn)該實(shí)例的全局訪問(wèn)點(diǎn)。
class Singleton:
__instance = None
def __new__(cls):
if cls.__instance is None:
cls.__instance = object.__new__(cls)
return cls.__instance
s1 = Singleton()
s2 = Singleton()
print(s1 is s2) # 輸出：True =》 說(shuō)明唯一性建造者模式
Builder Pattern
將一個(gè)復(fù)雜對(duì)象的構(gòu)建過(guò)程分離成多個(gè)簡(jiǎn)單的步驟
場(chǎng)景: 靈活地組合和構(gòu)建不同的對(duì)象。
Characters:
產(chǎn)品類（Product） 抽象建造者類（Builder）
具體建造者類（ConcreteBuilder） 指揮者類（Director）
class Product:
def __init__(self):
self.part_a = None
self.part_b = None
class Builder:
def build_part_a(self):
pass
def build_part_b(self):
pass
def get_result(self):
pass
class ConcreteBuilder1(Builder):
def __init__(self):
self.product = Product()
def build_part_a(self):
self.product.part_a = "Part A1"
def build_part_b(self):
self.product.part_b = "Part B1"
def get_result(self):
return self.product
class ConcreteBuilder2(Builder):
def __init__(self):
self.product = Product()
def build_part_a(self):
self.product.part_a = "Part A2"
def build_part_b(self):
self.product.part_b = "Part B2"
def get_result(self):
return self.product
class Director:
def __init__(self, builder):
self.builder = builder
def construct(self):
self.builder.build_part_a()
self.builder.build_part_b()
return self.builder.get_result()
builder_1 = ConcreteBuilder1()
director_1 = Director(builder_1)
product_1 = director_1.construct()
print(f"Product 1: {product_1.part_a}, {product_1.part_b}") # 輸出：Product 1: Part A1, Part B1
builder_2 = ConcreteBuilder2()
director_2 = Director(builder_2)
product_2 = director_2.construct()
print(f"Product 2: {product_2.part_a}, {product_2.part_b}") # 輸出：Product 2: Part A2, Part B2原型模式
Prototype Pattern
允許通過(guò)復(fù)制現(xiàn)有對(duì)象來(lái)創(chuàng)建新的對(duì)象，而無(wú)需重新實(shí)例化。 Think: 定義一個(gè)抽象原型類，包含了用于復(fù)制自身的抽象方法 clone()。然后，定義具體的原型類。在客戶端代碼中，可以通過(guò)調(diào)用具體對(duì)象 clone() 方法來(lái)創(chuàng)建新的對(duì)象，而無(wú)需重新實(shí)例化。（注意深淺拷貝問(wèn)題）
import copy
class Prototype:
def clone(self):
return copy.deepcopy(self)
class ConcretePrototype1(Prototype):
def __init__(self, attr):
self.attr = attr
class ConcretePrototype2(Prototype):
def __init__(self, attr):
self.attr = attr
if __name__ == '__main__':
prototype_1 = ConcretePrototype1("attr_1")
prototype_2 = ConcretePrototype2("attr_2")
clone_1 = prototype_1.clone()
clone_2 = prototype_2.clone()
print(f"Original: ({prototype_1.attr}, {prototype_2.attr})") # 輸出：Original: (attr_1, attr_2)
print(f"Clone: ({clone_1.attr}, {clone_2.attr})") # 輸出：Clone: (attr_1, attr_2)到了這里，關(guān)于設(shè)計(jì)模式-創(chuàng)建型模式（單例、工廠、建造、原型）的文章就介紹完了。如果您還想了解更多內(nèi)容，請(qǐng)?jiān)谟疑辖撬阉鱐OY模板網(wǎng)以前的文章或繼續(xù)瀏覽下面的相關(guān)文章，希望大家以后多多支持TOY模板網(wǎng)！
