#!/usr/bin/env python

# -*- coding: utf-8 -*-

# @Time : 2020/11/29 18:06

# @Author : Antenna

# @Email : lilyef2000@163.com

# @File : creationalpatterns.py

# 1.简单工厂型模式

# 简单工厂模式不直接向客户端暴露对象创建

# 的细节，而是通过一个工厂类来负责创建产品类的实

# 例。简单工程模式的角色有：工厂角色、抽象产品角

# 色、具体产品角色

from abc import ABCMeta, abstractmethod

# 抽象产品角色，以什么样的表现去使用

class Payment(metaclass=ABCMeta):

@abstractmethod

def pay(self, money):

pass

# 产品角色

class Alipay(Payment):

def __init__(self,use_huabei=False):

self.use_huabei = use_huabei

def pay(self, money):

if self.use_huabei == True:

print("花呗支付了{0}元!".format(money))

else:

print("支付宝余额支付了{0}元!".format(money))

# 产品角色

class WechatPay(Payment):

def pay(self, money):

print("微信支付了%d元!" % (money))

# 工厂类角色

class PaymentFactory:

def ctreate_payment(self, method):

if method == 'Alipay':

return Alipay()

elif method == 'WechatPay':

return WechatPay()

elif method == 'HuabeiPay':

return Alipay(use_huabei=True)

else:

raise TypeError('No such payment named% s' % method)

# 客户端调用。不直接向客户端暴露对象创建的实现

# 细节，而是通过一个工厂类来负责创建产品类的实例

pf = PaymentFactory()

p = pf.ctreate_payment('HuabeiPay')

p.pay(100)

# 2.工厂方法模式

# 工厂模式方法模式的概念是定义了一个用于创建对

# 象的接口(工厂接口)，让子类决定实例化那一个产品

# 类。角色有抽象工厂角色、具体工厂角色、抽象产品角

# 色和具体产品角色。

from abc import ABCMeta, abstractmethod

# 抽象产品角色

class Payment(metaclass=ABCMeta):

@abstractmethod

def pay(self, money):

pass

# 产品角色

class Alipay(Payment):

def __init__(self, use_huabei=False):

self.use_huabei = use_huabei

def pay(self, money):

if self.use_huabei == True:

print("花呗支付了{0}元！".format(money))

else:

print("支付宝支付了{0}元！".format(money))

# 产品角色

class WechatPay(Payment):

def pay(self, money):

print("微信支付了{0}元！".format(money))

# 抽象工厂角色

class PaymentFactory(metaclass=ABCMeta):

@abstractmethod

def create_payment(self):

pass

# 具体工厂角色

class AlipayFactory(PaymentFactory):

def create_payment(self):

return Alipay()

class WechatPayFactory(PaymentFactory):

def create_payment(self):

return Alipay()

class HuabeiFactory(PaymentFactory):

def create_payment(self):

return Alipay(use_huabei=True)

hfp = HuabeiFactory().create_payment()

hfp.pay(100) # 花呗支付了100元!

# 缺点是每增加一个具体产品类，就必须增加一个相应的具体方法

# 3.抽象工厂模式

# 定义一个工厂类的接口让工厂子

# 类来创建一系列相关或者相互依赖的对象 。相比工厂方法

# 模式，抽象工厂模式中的每一个具体工厂都生产一套产

# 品 。抽象工厂模式的角色有：抽象工厂角色、具体

# 工厂角色、抽象产品角色、具体产品角色和客户端。抽

# 象工厂模式的优点是：将客户端和类的具体实现相分

# 离；每个工厂创建了一个完整的产品系列 ，使得易于交

# 换产品系列；有利于产品的一致性，即产品之间的约束

# 关系。缺点是：难以支持新种类抽象产品 。

from abc import ABCMeta, abstractmethod

# ------抽象的产品------

class PhoneShell(metaclass=ABCMeta):

@abstractmethod

def show_shell(self):

pass

class PhoneCPU(metaclass=ABCMeta):

@abstractmethod

def show_cpu(self):

pass

class PhoneOS(metaclass=ABCMeta):

@abstractmethod

def show_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(PhoneCPU):

def show_cpu(self):

print('骁龙CPU')

class HuaweiCPU(PhoneCPU):

def show_cpu(self):

print('化为CPU')

class AppleCPU(PhoneCPU):

def show_cpu(self):

print('苹果CPU')

class AndroidOS(PhoneOS):

def show_os(self):

print('IOS系统')

class AppleOS(PhoneOS):

def show_os(self):

print('安卓系统')

# ------抽象的工厂------

class PhoneFactory(metaclass=ABCMeta):

@abstractmethod

def make_shell(self):

pass

@abstractmethod

def make_cpu(self):

pass

@abstractmethod

def make_os(self):

pass

# ------具体的工厂------

class HuaweiFactory(PhoneFactory):

def make_shell(self):

return SmallShell()

def make_cpu(self):

return HuaweiCPU()

def make_os(self):

return AndroidOS()

class AppleFactory(PhoneFactory):

def make_shell(self):

return AppleShell()

def make_cpu(self):

return AppleCPU()

def make_os(self):

return AppleOS()

# ------客户端------

class Phone:

def __init__(self, shell, cpu, os):

self.shell = shell

self.cpu = cpu

self.os = os

def show_info(self):

print('手机信息：')

self.shell.show_shell()

self.cpu.show_cpu()

self.os.show_os()

def make_phone(factory):

shell = factory.make_shell()

cpu = factory.make_cpu()

os = factory.make_os()

return Phone(shell, cpu, os)

p = make_phone(HuaweiFactory())

p.show_info()

# 4.建造者模式

# 建造者模式是将一个复杂对象的构建与它的表

# 示分离，使得同样的构建过程可以创建不同的表示。角

# 色有抽象创建者、具体创建者、指挥者和产品。建造者

# 模式与抽象工厂模式相似，也用来创建复杂的对象。主

# 要区别是 建造者模式着重一步步构造一个复杂对象(控制

# 顺序)。而抽象工厂模式着重于多个系列的产品对象

from abc import ABCMeta, abstractmethod

# ------产品------

class Player:

def __init__(self, face=None, body=None, arms=None, legs=None):

self.face = face

self.body = body

self.arms = arms

self.legs = legs

def __str__(self):

return '%s,%s,%s,%s' % (self.face, self.body, self.arms, self.legs)

# ------抽象建造者------

class PlayerBuilder(metaclass=ABCMeta):

@abstractmethod

def build_face(self):

pass

@abstractmethod

def build_body(self):

pass

@abstractmethod

def build_arms(self):

pass

@abstractmethod

def build_legs(self):

pass

# ------具体建造者,隐藏了一个产品的内部结构------

class GirlBuilder(PlayerBuilder):

def __init__(self):

self.player = Player()

def build_face(self):

self.player.face = '漂亮的脸蛋'

def build_body(self):

self.player.body = '苗条的身材'

def build_arms(self):

self.player.arms = '细细的胳膊'

def build_legs(self):

self.player.legs = '大长腿'

# ------具体建造者，表示代码------

class MonsterBuilder(PlayerBuilder):

def __init__(self):

self.player = Player()

def build_face(self):

self.player.face = '绿脸'

def build_body(self):

self.player.body = '魁梧的身体'

def build_arms(self):

self.player.arms = '粗壮的胳膊'

def build_legs(self):

self.player.legs = '粗壮的大腿'

# ------指挥者，构造代码(构造代码和表示代码分开)，可以对构造过程进行更加精细地控制 ------

class PlayerDirectory():

def builder_player(self, builder):

"""隐藏了装配过程:param builder::return:"""

builder.build_face()

builder.build_body()

builder.build_arms()

builder.build_legs()

return builder.player

# ------客户端------

builder = GirlBuilder()

director = PlayerDirectory()

p = director.builder_player(builder)

print(p)

# 5.单例模式

# 单例模式保证一个类只有一个实例，并提供一

# 个访问它的全局访问点。优点是对唯一实例的受控访问

# (只有一个实例)，单例相当于全局变量，但防止了命

# 名空间被污染(变量命名不会有冲突)。

class Singleton:

def __new__(cls, *args, **kwargs):

if not hasattr(cls, "_instance"):

cls._instance = super(Singleton, cls).__new__(cls)

return cls._instance

class MyClass(Singleton):

def __init__(self, a):

self.a = a

ms1 = MyClass(1)

ms2 = MyClass(2)

# print(ms1.a)

# print(id(ms1), id(ms2))

# 该例子在python3.6中不能成功运行,其实python中可以通过导入模块实现单实例运行.