• 内容：定义一个工厂类接口，让工厂子类来创建一系列相关或相互依赖的对象。
    • 例如：生产一部手机，需要手机壳、CPU、操作系统三类对象进行组装，其中每类对象都有不同的种类。对每个具体工厂，分别生产一部手机所需要的三个对象。
    • 角色：
      • 抽象工厂角色（Creator）
      • 具体工厂角色（Concrete Creator）
      • 抽象产品角色（Product）
      • 具体产品角色（Concrete Product）
      • 客户端（Client）
    • 相比工厂方法模式，抽象工厂模式中的每个具体工厂都生产一套产品。

    image.png

    1. from abc import ABCMeta, abstractmethod
    3. # ------抽象产品-------
    4. class PhoneShell(metaclass=ABCMeta):
    5.     @abstractmethod
    6.     def show_shell(self):
    7.         raise NotImplementedError
    9. class CPU(metaclass=ABCMeta):
    10.     @abstractmethod
    11.     def show_cpu(self):
    12.         raise NotImplementedError
    14. class OS(metaclass=ABCMeta):
    15.     @abstractmethod
    16.     def show_os(self):
    17.         raise NotImplementedError
    19. # ------抽象工厂-------
    20. class PhoneFactory(metaclass=ABCMeta):
    21.     @abstractmethod
    22.     def make_shell(self):
    23.         raise NotImplementedError
    25.     @abstractmethod
    26.     def make_cpu(self):
    27.         raise NotImplementedError
    29.     @abstractmethod
    30.     def make_os(self):
    31.         raise NotImplementedError
    33. # -----具体产品-----
    34. class SmallShell(PhoneShell):
    35.     def show_shell(self):
    36.         print("普通手机小手机壳")
    38. class BigShell(PhoneShell):
    39.     def show_shell(self):
    40.         print("普通手机大手机壳")
    42. class AppleShell(PhoneShell):
    43.     def show_shell(self):
    44.         print("苹果手机壳")
    46. class SnapDragonCPU(CPU):
    47.     def show_cpu(self):
    48.         print("晓龙CPU")
    50. class MediaTekCPU(CPU):
    51.     def show_cpu(self):
    52.         print("骁龙CPU")
    54. class AppleCPU(CPU):
    55.     def show_cpu(self):
    56.         print("联发科CPU")
    58. class Android(OS):
    59.     def show_os(self):
    60.         print("苹果CPU")
    62. class IOS(OS):
    63.     def show_os(self):
    64.         print("ios系统")
    66. # ----具体工厂-----
    67. class MiFactory(PhoneFactory):
    69.     def make_cpu(self):
    70.         return SnapDragonCPU()
    72.     def make_os(self):
    73.         return Android()
    75.     def make_shell(self):
    76.         return BigShell()
    78. class HuaweiFactory(PhoneFactory):
    79.     def make_cpu(self):
    80.         return MediaTekCPU()
    82.     def make_os(self):
    83.         return Android()
    85.     def make_shell(self):
    86.         return SmallShell()
    88. class IPhoneFactory(PhoneFactory):
    89.     def make_cpu(self):
    90.         return AppleCPU()
    92.     def make_os(self):
    93.         return IOS()
    95.     def make_shell(self):
    96.         return AppleShell()
    98. # ----客户端----
    100. class Phone:
    101.     def __init__(self, cpu, os, shell):
    102.         self.cpu = cpu
    103.         self.os = os
    104.         self.shell = shell
    106.     def show_info(self):
    107.         print("手机信息：")
    108.         self.cpu.show_cpu()
    109.         self.os.show_os()
    110.         self.shell.show_shell()
    112. def make_phone(factory):
    113.     cpu = factory.make_cpu()
    114.     os = factory.make_os()
    115.     shell = factory.make_shell()
    116.     return Phone(cpu, os, shell)
    118. p1 = make_phone(IPhoneFactory())
    119. p1.show_info()
    • 适用场景：
      • 系统要独立于产品的创建与组合时。
      • 强调一系列相关的产品对象的设计以便进行联合使用时。
      • 提供一个产品类库，想隐藏产品的具体实现时。
    • 优点：
      • 将客户端与类的具体实现相分离。
      • 每个工厂创建了一个完整的产品系列，使得易于交换产品系列。
      • 有利于产品的一致性（即产品之间的约束关系）
    • 缺点：
      • 难以支持新种类的（抽象）产品