创建型模式 2_抽象工厂模式

---

定义：抽象工厂模式

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

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

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

代码

1.底层代码

from  abc  import  abstractmethod, ABCMeta

#  -------------abstract  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

#----------  abstract factory -----------

class  PhoneFactory(metaclass=ABCMeta):
       @abstractmethod
       def make_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("common phone, small shell")

class BigShell(PhoneShell):
      def show_shell(self):
          print(' common phone, bing shell ')

class AppleShell(PhoneShell):
      def  show_shell(self):
           print(' apple phone shell ')

# --------cpu-------
class SnapDragonCPU( CPU):
     def show_cpu(self):
         print(' snapDragonCpu')

class MediaTekCPU(CPU):
      def show_cpu(self):
          print("MediaTek cpu")

class AppleCPU(CPU):
      def  show_cpu(self):
          print('Apple cpu ')

# ----------- OS --------------
class Android(OS):
    def show_os(self):
        print(" Android  system")

class IOS(OS):
    def  show_os(self):
        print(" IOS system")

#---------------------  Concrete  Factory --------------------

class MiFactory(PhoneFactory):
    def make_shell(self):
        return  SmallShell()

    def  make_cpu(self):
        return SnapDragonCPU()
        
    def make_os(self):
        return  Android()


class  HuaWeiFactory(PhoneFactory):
    def make_shell(self):
        return BigShell()
    def make_cpu(self):
        return  MediaTekCPU()
    def make_os(self):
        return Android()


class IPhoneFactory(PhoneFactory):
    def make_shell(self):
        return AppleShell()
        
    def make_cpu(self):
        return AppleShell()

    def make_os(self):
        return IOS()

2.高层代码

#----------------  High level  code ---------------
class Phone:
    def __init__(self, cpu, os, shell):
        self.cpu = cpu
        self.os  = os
        self.shell = shell

    def show_info(self):
        print(' your phone information: ')
        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(MiFactory())
p1.show_info()

---

总结

优点：

1. 将 高层代码 与 底层中类的具体实现相分离；
2. 将 每个工厂 创建 一个完整的产品系列， 使得易于交换产品系列；
3. 有利于 产品的一致性 （即产品之间的约束关系）

缺点：
难以支持新种类的 抽象 产品；