工厂模式是属于创建型模式，它提供了一种创建对象的最佳方式。
在工厂模式中，我们在创建对象的过程中不会向客户端暴露实现逻辑，而是通过一个共同的接口类来指向新创建的对象。
内容：不直接向客户端暴露对象创建实现的细节，而是通过工厂类来负责创建产品类的实例。
具体代码（jiandan.py）：
from abc import ABCMeta, abstractmethod
class Payment(metaclass=ABCMeta):
@abstractmethod
def pay(self):
pass
class WechatPay(Payment):
def pay(self, money):
print("微信支付%s" % money)
return
class Alipay(Payment):
def __init__(self, huabei=False):
self.huabei = huabei
def pay(self, money):
if self.huabei:
print("花呗支付%s" % money)
else:
print("支付宝余额支付%s" % money)
class PaymentFactory:
def create_pay(self, method):
if method == "wechat":
return WechatPay()
elif method == "alipay":
return Alipay()
elif method == "huabei":
return Alipay(huabei=True)
else:
raise TypeError("No such payment name %s" % method)
# client
pf = PaymentFactory()
p = pf.create_pay("huabei")
p.pay(100)结果：
ABCMeta是python的一个元类，用于在Python程序中创建抽象基类，抽象基类中声明的抽象方法，使用abstractmethod装饰器装饰。
简单明了的说：创建一个公共的抽象类，然后创建多个支付的类继承这个抽象类，各种支付类里实现具体的支付方式，通过工厂类选择支付方式，这样客服端只实现支付方式，不需要知道具体的实现方法。
优点：
缺点：
内容：定义了一个用于创建对象的接口（工厂类），让工厂子类决定实例化哪一个产品类。
具体代码（factory_method.py）：
from abc import ABCMeta, abstractmethod
class Payment(metaclass=ABCMeta):
@abstractmethod
def pay(self):
pass
class WechatPay(Payment):
def pay(self, money):
print("微信支付%s" % money)
return
class Alipay(Payment):
def __init__(self, huabei=False):
self.huabei = huabei
def pay(self, money):
if self.huabei:
print("花呗支付%s" % money)
else:
print("支付宝余额支付%s" % money)
class PaymentFactory(metaclass=ABCMeta):
@abstractmethod
def create_method(self):
pass
class AlipayFactory(PaymentFactory):
def create_method(self):
return Alipay()
class WechatFactory(PaymentFactory):
def create_method(self):
return WechatPay()
class HuabeiFactory(PaymentFactory):
def create_method(self):
return Alipay(huabei=True)
pf = HuabeiFactory()
p = pf.create_method()
p.pay(100)结果：
内容：定义一个工厂类接口，让工厂子类来创建一系列相关或者相互依赖的对象。
与工厂模式相比，抽象工厂模式中的每一个产品都生产一套产品。
具体代码（abstract_factory.py）：
from abc import ABCMeta, abstractmethod
"""
抽象产品
"""
class PhoneShell(metaclass=ABCMeta):
@abstractmethod
def show_shell(self):
pass
class OS(metaclass=ABCMeta):
@abstractmethod
def show_os(self):
pass
class CPU(metaclass=ABCMeta):
@abstractmethod
def show_cpu(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 SmallShell(PhoneShell):
def show_shell(self):
print("普通手机壳小手机壳")
class BigShell(PhoneShell):
def show_shell(self):
print("普通手机壳大手机壳")
class AppleShell(PhoneShell):
def show_shell(self):
print("苹果手机壳")
class SnapDragonCPU(CPU):
def show_cpu(self):
print("骁龙CPU")
class MediaTekCPU(CPU):
def show_cpu(self):
print("联发科CPU")
class AppleCPU(CPU):
def show_cpu(self):
print("苹果CPU")
class AppleOS(OS):
def show_os(self):
print("苹果OS系统")
class AndroidOS(OS):
def show_os(self):
print("Android系统")
class IOS(OS):
def show_os(self):
print("IOS系统")
# 具体工厂
class MiFactory(PhoneFactory):
def make_cpu(self):
return SnapDragonCPU()
def make_os(self):
return AndroidOS()
def make_shell(self):
return BigShell()
class HuaweiFactory(PhoneFactory):
def make_cpu(self):
return MediaTekCPU()
def make_os(self):
return AndroidOS()
def make_shell(self):
return SmallShell()
class IPhoneFactory(PhoneFactory):
def make_cpu(self):
return AppleCPU()
def make_os(self):
return AppleOS()
def make_shell(self):
return AppleShell()
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)
p1 = make_phone(MiFactory())
p1.show_info()结果：
优点：
缺点：