设计模式中的工厂模式

创建型设计模式

• 内容

  ​ 不需要像客户端暴露对象创建的实现细节，而是通过一个工厂类来负责创建产品类的实例

• 角色

  1. 工厂模式(creater)
  2. 抽象产品角色（Product）
  3. 具体产品角色（Concrete Productxten）

---

1. 普通工厂模式

   • 优点：

     隐藏了对象创建的细节

     客户段不需要修改代码

   • 缺点

     违反了单一职责的原则，将创建逻辑几种到一个工厂里面

     当添加新产品时，需要修改工厂的代码，违反了开闭原则

   from abc import ABCMeta,abstractstaticmethod
   
   
   class  Pay(metaclass=ABCMeta):
   	"""docstring for  Pay"""
   	@abstractstaticmethod
   	def pay():
   		pass
   
   # 阿里云支付
   class AliPay(Pay):
   	"""docstring for Pay"""
   	def pay():
   		pass
   
   # 微信支付
   class WeChatPay(Pay):
   	"""docstring for Pay"""
   	def pay():
   		pass
   		
   
   # 创建一个工厂
   class Factory(AliPay):
   	"""docstring for Factory"""
   	def create_paymement(self,method):
   		if method == 'ali':
   			ali = AliPay()
   			return ali
   		elif method == 'wechat':
   			wechat = WeChatPay()
   			return wechat
   
   		else:
   			raise TypeError('No such class %s'%method)
   
   
   # 通过工厂发牛一个对像
   factory = Factory()
   ali = factory.create_paymement('ali')
   print(type(AliPay))
   
   

2. 工厂方法模式

   • 代码实例

     from abc import ABCMeta,abstractstaticmethod
     
     
     # 工厂的抽象类
     class Factory(metaclass=ABCMeta):
     	"""docstring for Factory"""
     	@abstractstaticmethod
     	def create_paymember(self):
     		pass
     
     # 支付的抽象类
     class PayMembent(metaclass=ABCMeta):
     
     	"""docstring for PayMembent"""
     	@abstractstaticmethod
     	def pay(self):
     		pass
     
     
     # 支付宝的支付类
     class AliPay(PayMembent):
     	"""docstring for AliyunFactory"""
     	def __init__(self,use_huabei=False):
     		self.use_huabei = use_huabei
     	def pay(self,money):
     		if self.use_huabei:
     			print('使用花呗额进行支付了%s元'%money)
     		else:
     			print('使用支付宝余额支付了%s'%money)
     
     
     # 微信支付的抽象类
     class WeChatPay(PayMembent):
     	"""docstring for  WeChatPay"""
     	def pay(self,money):
     		pritn('使用微信进行支付%s'%s)
     
     
     
     
     # 创建工厂类
     class AliFacotry(Factory):
     	"""docstring for AliFacotry"""
     	def create_paymember(self):
     		return AliPay()
     
     
     class WechatFactory(Factory):
     	"""docstring for WechatFactory"""
     	def create_paymember(self):
     		return WeChatPay()
     
     class  HuaBeiFactory(Factory):
     	"""docstring for  HuaBeiFactory"""
     	def create_paymember(self):
     		return AliPay(use_huabei=True)
     
     Factory = HuaBeiFactory()
     ali=Factory.create_paymember()
     ali.pay('123123')
     

   • 优点

     每个具体的产品都对应一个具体的工厂类，不需要修改工厂类代码

     隐藏了对象创建的细节

   • 缺点

     每增加一个具体产品类，就必须增加一个对应的具体工厂类

3. 抽象工厂模式

   • 内容

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

   • 对比

     相对于工厂模式，抽象工厂的每个具体工厂都是生产一套产品

   • 优点

     将客户段和类的实现想分离

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

     有利于产品的一致性

   • 缺点

     难以支持新种类的产品

   • 具体实现代码

     from abc import ABCMeta,abstractstaticmethod
     
     # 手机壳工厂
     class PhoneShell(metaclass=ABCMeta):
     	"""docstring for PhoneFactory"""
     	@abstractstaticmethod
     	def show_shell(self):
     		pass
     
     # 手机cpu工厂
     class PhoneCpu(metaclass=ABCMeta):
     	@abstractstaticmethod
     	def show_cpu(self):
     		pass
     
     
     # 手机系统工厂
     class PhoneOs(metaclass=ABCMeta):
     	"""docstring for PhoneOs"""
     	@staticmethod
     	def show_os(self):
     		pass
     	
     
     # 制作手机工厂
     class  MakePhone(metaclass=ABCMeta):
     		
     		# 制作手机壳
     		@abstractstaticmethod
     		def make_shell(self):
     			pass
     
     		# 制作手机系统
     		@abstractstaticmethod
     		def make_os(self):
     			pass
     
     		# 制作手机Cpu
     		@abstractstaticmethod
     		def make_cpu(self):
     			pass
     
     
     # 制作手机壳
     class SmallShell(PhoneShell):
     	def show_shell(self):
     		print('普通小手机壳')
     
     
     class BigShell(PhoneShell):
     	def show_shell(self):
     		print('普通大手机壳')
     
     
     class PhoneCpu(PhoneCpu):
     	"""docstring for PhoneCpu"""
     	def show_cpu(self):
     		print('安卓CPU')
     
     class IosCpu(PhoneCpu):
     	def show_cpu(self):
     		print('苹果Cpu')
     
     
     class PhoneOs(PhoneOs):
     	"""docstring for PhoneOs"""
     	def show_os(self):
     		print('安卓系统')
     
     
     class IosOs(PhoneOs):
     	"""docstring for IosOs"""
     	def show_os(self):
     		print('苹果系统')
     
     
     class PhoneFactory(MakePhone):
     	"""docstring for PhoneClient"""
     	def make_shell(self):	
     		return PhoneShell()
     
     	def make_os(self):
     		return PhoneOs()
     
     	def make_cpu(self):
     		return PhoneCpu()
     
     
     class IosPhoneFactory(MakePhone):
     	"""docstring for IosPhoneFactory"""
     	def make_shell(self):	
     		return BigShell()
     
     	def make_os(self):
     		return IosOs()
     
     	def make_cpu(self):
     		return IosCpu()
     class  Phone(PhoneFactory):
     	"""docstring for  Phone"""
     	def __init__(self, cpu,shell,os):
     		self.cpu = cpu
     		self.shell = shell
     		self.os = os
     	
     	def show_phoneinfo(self):
     		print('-------------------**手机信息**--------------------------')
     		self.cpu.show_cpu()
     		self.shell.show_shell()
     		self.os.show_os()
     		print('------------------**输出完毕**----------------------------')
     
     def make_phone(PhoneFactory):
     	cpu = PhoneFactory.make_cpu()
     	os = PhoneFactory.make_os()
     	shell = PhoneFactory.make_shell()
     	return Phone(cpu=cpu,os=os,shell=shell)
     
     phone = make_phone(IosPhoneFactory())
     phone.show_phoneinfo()