面向对象-03抽象工厂模式

抽象工厂模式

• 内容:
  • 定义一个工厂类接口，让工厂子类来创建—系列相关或相互依赖的对象。
• 例:生产一部手机，需要手机壳、CPU、操作系统三类对象进行组装，其中每类对象都有不同的种类。对每个具体工厂，分别生产一部手机所需要的三个对象。
• 相比工厂方法模式，抽象工厂模式中的每个具体工厂都生产一套产品。由于，遵循单一职责原则，所以，他具有限制的作用。
• 角色:
  • 抽象工厂角色(Creator)
  • 具体工厂角色(Concrete Creator)
  • 抽象产品角色(Product)
  • 具体产品角色(Concrete Product)
  • 客户端(Client)
• 优点:
  • 将客户端与类的具体实现相分离
  • 每个工厂创建了一个完整的产品系列,使得易于交换产品系列
  • 有利于产品的—致性(即产品之间的约束关系)
• 缺点
  • 难以支持新种类的(抽象)产品

from abc import ABCMeta, abstractmethod

# 抽象就是一类的型，或说一类接口的型
# -------------------抽象产品Product--------------------------
# 定义产品接口，具体实现的型
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


# -------------------抽象工厂Creator--------------------------
# 定义工厂接口，工厂实现的型
class PhoneFactory(metaclass=ABCMeta):

    @abstractmethod
    def make_phone_shell(self):
        pass

    @abstractmethod
    def make_cpu(self):
        pass

    @abstractmethod
    def make_os(self):
        pass


# -------------------具体产品Concrete Product--------------------------

# 手机壳
# 这里就是根据抽象的型，定义具体的类
class SmallShell(PhoneShell):

    def show_shell(self):
        print("SmallShell")


class BigShell(PhoneShell):

    def show_shell(self):
        print("BigShell")


class AppleShell(PhoneShell):

    def show_shell(self):
        print("AppleShell")


# CPU
# 这里就是根据抽象的型，定义具体的类
class SnapDragonCPU(CPU):

    def show_cpu(self):
        print("SnapDragonCPU")


class DimensityCPU(CPU):

    def show_cpu(self):
        print("DimensityCPU")


class AppleCPU(CPU):

    def show_cpu(self):
        print("AppleCPU")


# os
# 这里就是根据抽象的型，定义具体的类
class AndroidOS(OS):

    def show_os(self):
        print("AndroidOS")


class AppleOS(OS):

    def show_os(self):
        print("AppleOS")


# -------------------具体工厂Concrete Creator--------------------------

# 这里就是根据抽象的型，定义具体的类
class XiaoMI(PhoneFactory):

    def make_phone_shell(self):
        return SmallShell()

    def make_cpu(self):
        return DimensityCPU()

    def make_os(self):
        return AndroidOS()

    
# 这里就是根据抽象的型，定义具体的类
class Apple(PhoneFactory):

    def make_phone_shell(self):
        return AppleShell()

    def make_cpu(self):
        return AppleCPU()

    def make_os(self):
        return AppleOS()


# client
# 高层代码或模块
# 手所包含的内容
class Phone:

    def __init__(self, os, cpu, shell):
        self.os = os
        self.cpu = cpu
        self.shell = shell

    def show_info(self):
        print("手机信息：")
        # 创建的手机对象所包含的info信息
        self.os.show_os()
        self.shell.show_shell()
        self.cpu.show_cpu()

# 创建一台手机，传入手机工厂
def make_phone(factory) -> Phone:
    # 制造手机的各个零件
    shell = factory.make_phone_shell()
    cpu = factory.make_cpu()
    os = factory.make_os()
    # 返回手机对象
    return Phone(os, cpu, shell)

pf = make_phone(Apple())
pf.show_info()