【设计模式】-python-创建型

单例模式

只允许一个类只有一个实例。

先了解一下下python 的 init()方法和 new()方法

init不是实例化一个类第一个调用的方法，
第一个调用的方法是new方法，new方法返回一个实例对象，
然后实例对象调用init方法。
new是类级别的方法。
init是实例级别的方法。

class Single:
 
    _instance = None 
 
    def __new__(cls, *args, **kwargs):
        if not cls._instance:
            # instance未实例化 
            # object.__new__(cls)
            cls._instance = super().__new__(cls)
        return cls._instance 
 
s1 = Single()
s2 = Single() 
print(id(s1), id(s2))

简单工厂

隐藏了创建对象的实现细节。哭护短不需要修改代码。
新增对象，需要修改工厂代码。

class Payment(metaclass=ABCMeta):
 
    @abstractmethod
    def pay(self, money):
        pass 
 
class WechatPayment(Payment):
 
    def pay(self, money):
        print("微信支付")
 
class AliPayment(Payment):
 
    def pay(self, money):
        print("阿里支付")
 
class PaymentFactory:
 
    def create_payment(self, method):
 
        if method == "ali":
            return AliPayment()
        elif method == "wechat":
            return WechatPayment()
 
pf = PaymentFactory()
pay = pf.create_payment('ali')
pay.pay(1)

工厂方法模式

一个工厂生产一个产品。 不需要修改工厂类代码。
每增加一个产品，需要增加一个工厂。

class PaymentFactory(metaclass=ABCMeta):
    
    @abstractmethod
    def create_payment(self):
        pass 
 
class WechatFactory(PaymentFactory):
    def create_payment(self):
        return WechatPayment() 

抽象工厂模式

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

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

 # 抽象产品
class PhoneShell(metaclass=ABCMeta):
    @abstractmethod
    def show_shell(self):
        pass 
 
class CPU(metaclass=ABCMeta):
    @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 AppleShell(PhoneShell):
    def show_shell(self):
        print("苹果手机壳")
class SanShell(PhoneShell):
    def show_shell(self):
        print("三星手机壳")
 
class DragonCPU(CPU):
    def show_cpu(self):
        print("梦龙CPU")
 
class AppleCPU(CPU):
    def show_cpu(self):
        print("苹果CPU")
 
class LinuxOS(OS):
    def show_os(self):
        print("linux os")
 
class WindowOS(OS):
    def show_os(self):
        print("window os")
 
# 具体工厂
 
class LLFactory(PhoneFactory):
 
    def make_shell(self):
        return AppleShell()
 
    def make_cpu(self):
        return DragonCPU()
 
    def make_os(self):
        return WindowOS()
 
class MMFactory(PhoneFactory):
    
    def make_shell(self):
        return SanShell()
 
    def make_cpu(self):
        return DragonCPU()
 
    def make_os(self):
        return LinuxOS()
 
# 客户端
class Phone:
    def __init__(self, cpu, os, shell):
        self.cpu = cpu 
        self.os = os 
        self.shell = shell 
    
    def show_info(self):
        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(LLFactory())
p1.show_info() 

建造者模式

将一个复杂对象的构建与它的表示分离。使得同样的构建过程可以创建不同的表示。
和抽象工厂有点像。着重于 顺序， 抽象工厂着重于 系列产品。

• 抽象建造者
• 具体建造者
• 指挥者
• 产品

# 产品
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 self.face + self.body + self.leg + self.arm
# 抽象建造者
class PlayBuilder(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 GirlBuilder(PlayBuilder):
 
    def __init__(self):
        self.player = Player()
 
    def build_face(self):
        self.player.face = "女"
    
    def build_body(self):
        self.player.body = "170"
    
    def build_arm(self):
        self.player.arm = "俩个胳膊"
    
    def build_leg(self):
        self.player.leg = "大长腿"
 
# 指挥者
class PlayerDirector:
    def build_player(self, builder: PlayBuilder):
        builder.build_body()
        builder.build_arm()
        builder.build_face()
        builder.build_leg() 
 
        return builder.player
 
builder = GirlBuilder()
director = PlayerDirector()
player = director.build_player(builder)
print(player)