一、简单工厂模式

什么是简单工厂模式？

        专门定义一个类来负责创建其他类的实例，根据参数的不同创建不同类的实例，被创建的实例通常具有共同的父类，这个模式叫简单工厂模式（Simple Factory Pattern）。

"""
简单工厂模式
"""

from abc import ABCMeta, abstractmethod


class My_abc(metaclass=ABCMeta):
    @abstractmethod
    def test(self):
        pass


class My_class1(My_abc):
    def test(self):
        return "My_class1_test"


class My_class2(My_abc):
    def test(self):
        return "My_class2_test"


class fac:
    @staticmethod
    def fac_func(param):
        if param == "1":
            return My_class1()
        elif param == "2":
            return My_class2()
        else:
            raise "参数错误"


if __name__ == "__main__":
    a1 = fac.fac_func("1")
    a2 = fac.fac_func("2")
    print(a1.test())
    print(a2.test())

二、工厂方法模式

        由于简单工厂模式不符合"开闭原则"，所以在简单工厂模式之上升级出了工厂方法模式。

什么是工厂方法模式？

        定义一个创建对象（实例化对象）的接口，让子类来决定创建哪个类的实例。工厂方法使一个类的实例化延迟到其子类。

"""
工厂方法模式
"""
from abc import ABCMeta, abstractmethod


class EleCar(metaclass=ABCMeta):
    """
    新能源车产品的基类
    """
    @abstractmethod
    def run(self, money):
        pass


class MiCar(EleCar):
    """
    具体的产品
    """
    def run(self):
        print("小米，启动!")


class TslCar(EleCar):
    """
    具体的产品
    """
    def run(self):
        print("特斯拉，启动!")


class CreateCar(metaclass=ABCMeta):
    """
    抽象出来的工厂基类
    """
    @abstractmethod
    def create(self):
        pass


class MiFactory(CreateCar):
    """
    负责创建具体产品的工厂子类
    """
    def create(self):
        return MiCar()


class TslFactory(CreateCar):
    """
    负责创建具体产品的工厂子类
    """
    def create(self):
        return TslCar()


pf = MiFactory()
p = pf.create()
p.run()

三、抽象工厂模式

不太懂!

from abc import ABCMeta, abstractmethod


# 手机壳
class Shell(metaclass=ABCMeta):
    @abstractmethod
    def select_shell(self):
        pass


# CPU处理器
class CPU(metaclass=ABCMeta):
    @abstractmethod
    def select_cpu(self):
        pass


# OS系统
class OS(metaclass=ABCMeta):
    @abstractmethod
    def select_os(self):
        pass


class MiShell(Shell):
    def select_shell(self):
        print("小米手机壳")


class IPhoneShell(Shell):
    def select_shell(self):
        print("苹果手机壳")


class MiCPU(CPU):
    def select_cpu(self):
        print("小米CPU")


class IPhoneCPU(CPU):
    def select_cpu(self):
        print("苹果CPU")


class MiOS(OS):
    def select_os(self):
        print("小米系统")


class IPhoneOS(OS):
    def select_os(self):
        print("苹果系统")


class CreatePhone(metaclass=ABCMeta):
    @abstractmethod
    def make_shell(self):
        pass

    @abstractmethod
    def make_cpu(self):
        pass

    @abstractmethod
    def make_os(self):
        pass


class CreateMi(CreatePhone):
    def make_shell(self):
        return MiShell()

    def make_cpu(self):
        return MiCPU()

    def make_os(self):
        return MiOS()


class CreateIPhone(CreatePhone):
    def make_shell(self):
        return IPhoneShell()

    def make_cpu(self):
        return IPhoneCPU()

    def make_os(self):
        return IPhoneOS()


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

    def show_info(self):
        print("手机信息：")
        self.shell.select_shell()
        self.cpu.select_cpu()
        self.os.select_os()


def make_phone(factory):
    shell = factory.make_shell()
    cpu = factory.make_cpu()
    os = factory.make_os()
    return Phone(shell, cpu, os)


phone_type = CreateMi()
phone = make_phone(phone_type)
phone.show_info()