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

和工厂方法模式相比，抽象工厂模式的每个工厂生产一套对象，而不是一个对象

优点：每个工厂创建了一个完整的产品系列，使得易于交换产品系列

有利于产品的一致性（即产品之间的约束关系）

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

from abc import ABCMeta, abstractmethod


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 BigShell(PhoneShell):
    def show_shell(self):
        print('大屏')


class SmallShell(PhoneShell):
    def show_shell(self):
        print('小屏')


class SnapDragonCPU(CPU):
    def show_cpu(self):
        print('骁龙')


class MediaTekCPU(CPU):
    def show_cpu(self):
        print('联发科')


class AppleCPU(CPU):
    def show_cpu(self):
        print('苹果处理器')


class Android(OS):
    def show_os(self):
        print('安卓系统')


class IOS(OS):
    def show_os(self):
        print('IOS系统')


class MiPhoneFactory(PhoneFactory):
    def make_shell(self):
        return BigShell()

    def make_cpu(self):
        return SnapDragonCPU()

    def make_os(self):
        return Android()


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

    def make_cpu(self):
        return AppleCPU()

    def make_os(self):
        return IOS()


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)


# mi=MiPhoneFactory()
iphone=IPhoneFactory()

p=make_phone(iphone)
p.show_info()