创建型模式

　　创建型模式：工厂方法模式、抽象工厂模式、创建者模式、原型模式、单例模式。

一、简单工厂模式

　　不直接向客户端暴露对象创建的实现细节，而是通过一个工厂类来负责创建产品类的实例。该模式不属于23种设计模式之一。

1、简单工程模式示例

复制代码
from abc import ABCMeta, abstractmethod

class Payment(metaclass=ABCMeta):
    # abstract class
    @abstractmethod
    def pay(self, money):
        pass

class Alipay(Payment):
    def __init__(self, use_huabei=False):
        self.use_huabei = use_huabei

    def pay(self, money):
        if self.use_huabei:
            print('支付宝支付%d元' % money)
        else:
            print('支付宝余额支付%d元。' % money)

class WechatPay(Payment):
    def pay(self, money):
        print("微信支付%d元" % money)

class PaymentFactory:   # 工厂类：生产支付对象
    def create_payment(self, method):
        if method == 'alipay':
            return Alipay()
        elif method == 'wechat':
            return WechatPay()
        elif method == 'huabei':
            return Alipay(use_huabei=True)
        else:
            raise TypeError("No such payment named %s" % method)


pf = PaymentFactory()
# p = pf.create_payment('alipay')
p = pf.create_payment('huabei')   # 隐藏了类的内部实现，无需了解代码逻辑
p.pay(100)
复制代码

 

　　Payment是抽象类，是为了让产品有同样的表现，可以同样的对外使用。如果要增加新的支付，比如银行支付，只要添加新的产品类即可。

2、简单工厂模式总结

角色：

  • 工厂角色（Creator）
  • 抽象产品角色（Product）
  • 具体产品角色（Concrete Product）

优点：

  • 隐藏了对象创建的实现细节
  • 客户端不需要修改代码

缺点：

  • 违反了单一职责原则，将创建逻辑集中到一个工厂类里
  • 当添加新产品时，需要修改工厂类代码，违反了开闭原则。

二、工厂方法模式

　　定义一个用于创建对象的接口（工厂接口），让子类决定实例化哪一个产品类。

1、工厂方法模式示例

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
from abc import ABCMeta, abstractmethod
 
class Payment(metaclass=ABCMeta):   # 产品接口
    # abstract class
    @abstractmethod
    def pay(self, money):
        pass
 
class Alipay(Payment):    # 具体产品
    def __init__(self, use_huabei=False):
        self.use_huabei = use_huabei
 
    def pay(self, money):
        if self.use_huabei:
            print('支付宝支付%d元' % money)
        else:
            print('支付宝余额支付%d元。' % money)
 
class WechatPay(Payment):
    def pay(self, money):
        print("微信支付%d元" % money)
 
class BankPay(Payment):   # 创建一个新产品
    def pay(self, money):
        print("银行卡支付%d元" % money)
 
class PaymentFactory(metaclass=ABCMeta):   # 工厂类接口
    @abstractmethod
    def create_payment(self):
        pass
 
class AlipayFactory(PaymentFactory):   # 具体工厂类
    def create_payment(self):
        return Alipay()
 
class WechatPayFactory(PaymentFactory):
    def create_payment(self):
        return WechatPay()
 
class HuabeiFactory(PaymentFactory):
    def create_payment(self):
        return Alipay(use_huabei=True)
 
class BankPayFactory(PaymentFactory):   # 创建新产品对应的工厂
    def create_payment(self):
        return BankPay()
 
pf = HuabeiFactory()  # 创建工厂
p = pf.create_payment()
p.pay(100)

2、工厂方法模式总结

角色：

  • 抽象工厂角色（Creator）
  • 具体工厂角色（Concrete Creator）
  • 抽象产品角色（Product）
  • 具体产品角色（Concrete Product）

优点：

  • 每个具体产品都对应一个具体工厂类，不需要修改工厂类代码
  • 隐藏了对象创建的实现细节

缺点：

  • 每增加一个具体产品类，就必须增加一个响应的具体工厂类（代码太多了）

三、抽象工厂模式

　　定义一个工厂类接口，让工厂子类来创建一系列相关或相互依赖的对象。

1、抽象工厂模式示例

　　例：生产一部手机，需要手机壳、CPU、操作系统三类对象进行组装，其中每类对象都有不同的种类。对每个具体工厂，分别生产一部手机所需要的三个对象。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
from abc import abstractmethod, ABCMeta
 
# ------抽象产品------
class PhoneShell(metaclass=ABCMeta):  # 手机壳
    @abstractmethod
    def show_shell(self):
        pass
 
class CPU(metaclass=ABCMeta):   # cpu
    @abstractmethod
    def show_cpu(self):
        pass
 
class OS(metaclass=ABCMeta):   # 系统
    @abstractmethod
    def show_os(self):
        pass
 
 
# ------抽象工厂------
class PhoneFactory(metaclass=ABCMeta):  # 每个工厂都生产一套产品
    @abstractmethod
    def make_shell(self):
        pass
 
    @abstractmethod
    def make_cpu(self):
        pass
 
    @abstractmethod
    def 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 MediaTekCPU()
 
    def make_os(self):
        return Android()
 
    def make_shell(self):
        return SmallShell()
 
class IPhoneFactory(PhoneFactory):  # 苹果工厂，一套组件还做了限制
    def make_cpu(self):
        return AppleCPU()    # 苹果cpu
 
    def make_os(self):
        return IOS()   # 苹果系统
 
    def make_shell(self):
        return AppleShell()   # 苹果手机壳
 
 
# ------客户端------
class Phone:   # 手机
    def __init__(self, cpu, os, shell):
        self.cpu = cpu
        self.os = os
        self.shell = shell
 
    def 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()

　　相比工厂方法模式，抽象工厂模式中每个具体工厂都生产一套产品。

2、抽象工厂模式总结

角色：

  • 抽象工厂角色（Creator）
  • 具体工厂角色（Concrete Creator）
  • 抽象产品角色（Product）
  • 具体产品角色（Concrete Product）
  • 客户端（Client）

优点：

  • 将客户端与类的具体实现相分离
  • 每个工厂创建了一个完整的产品系列，使得易于交换产品系列
  • 有利于产品的一致性（即产品之间的约束关系）

缺点：

  • 难以支持新种类的（抽象）产品：比如在CPU、手机壳、系统外再加一个内存，就非常难添加，该模式很少会用到。

四、创建者（建造者）模式

　　将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。

1、建造者模式示例

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
from abc import ABCMeta, abstractmethod
 
class Player:  # 产品：游戏角色
    def __init__(self, face=None, body=None, arm=None, leg=None):   # 传入初始化参数
        self.face = face
        self.body = body
        self.arm = arm
        self.leg = leg
 
    def __str__(self):
        return "%s, %s, %s, %s" % (self.face, self.body, self.arm, self.leg)
 
 
class PlayerBuilder(metaclass=ABCMeta):  # 抽象建造者：抽象类作为接口
    @abstractmethod
    def build_face(self):
        pass
 
    @abstractmethod
    def build_body(self):
        pass
 
    @abstractmethod
    def build_arm(self):
        pass
 
    @abstractmethod
    def build_leg(self):
        pass
 
 
class 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
 
 
# client调用
# builder = SexyGirlBuilder()   # 创建一个性感女孩builder
builder = Monster()    # 创建一个怪物builder
director = PlayerDirector()  # 指挥者实例化
p = director.build_player(builder)   # 组装创建（不同角色创建函数都是相同的）
print(p)

　　

2、建造者模式总结

角色：

  • 抽象建造者（Builder）
  • 具体建造者（Concrete Builder）
  • 指挥者（Director）
  • 产品（Product）

优点：

  • 隐藏了一个产品的内部结构和装配过程
  • 将构造代码与表示代码分开
  • 可以对构造过程进行更精细的控制

建造者模式与抽象工厂模式对比：

　　建造者模式与抽象工厂模式相似，也用来创建复杂对象。主要区别是建造者模式着重一步步构造一个复杂对象（控制它的顺序），而抽象工厂模式着重于多个系列的产品对象。

五、单例模式

　　保证一个类只有一个实例，并提供一个访问它的全局访问点。

1、单例模式示例

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
from abc import abstractmethod, ABCMeta
 
# 通过 __new__ 方法是实现单例模式的的一种方式，如果实例对象存在了就直接返回该实例即可，如果还没有，那么就先创建一个实例，再返回。
class Singleton:
    def __new__(cls, *args, **kwargs):
        if not hasattr(cls, "_instance"):  # 反射查看是否有_instance的类属性
            cls._instance = super(Singleton, cls).__new__(cls)   # 调用父类的__new__方法来创建实例
        return cls._instance
 
class MyClass(Singleton):
    def __init__(self, a):
        self.a = a
 
 
a = MyClass(10)
b = MyClass(20)
 
print(a.a)  # 输出20
print(b.a)  # 输出20
 
print(id(a), id(b))   # 4400380840 4400380840, id相同说明两者是同一个实例
 
# 常应用于日志文件对象，数据库连接器对象，操作系统文件对象等情况使用。

　　

2、单例模式总结

角色：

  • 单例（Singleton）：所有它的子类都满足单例模式

优点：

  • 对唯一示例的受控访问
  • 单例相当于全局变量，但防止了命名空间被污染（一个名字是全局变量时，在整个命名空间里这个名字就被占用了，再使用这个名字会冲突）

六、创建型模式小结

　　抽象工厂模式和建造者模式相比于简单工厂模式和工厂方法模式而言更灵活也更复杂。

　　通常情况下、设计以简单工厂模式或工厂方法模式开发，当你发现设计需要更大的灵活性时，则向更复杂的设计模式演化。

 

posted @   休耕  阅读(392)  评论(0)  编辑  收藏  举报
编辑推荐：
· 如何编写易于单元测试的代码
· 10年+ .NET Coder 心语，封装的思维：从隐藏、稳定开始理解其本质意义
· .NET Core 中如何实现缓存的预热？
· 从 HTTP 原因短语缺失研究 HTTP/2 和 HTTP/3 的设计差异
· AI与.NET技术实操系列：向量存储与相似性搜索在 .NET 中的实现
阅读排行：
· 10年+ .NET Coder 心语 ── 封装的思维：从隐藏、稳定开始理解其本质意义
· 地球OL攻略 —— 某应届生求职总结
· 周边上新：园子的第一款马克杯温暖上架
· Open-Sora 2.0 重磅开源！
· 提示词工程——AI应用必不可少的技术
点击右上角即可分享
微信分享提示
SQL AI 助手