摘要：還有一個(gè)工廠類。工廠類有一個(gè)方法名有兩個(gè)輸入?yún)?shù)，名字和性別。用戶使用工廠類，通過調(diào)用方法。抽象工廠模式提供一個(gè)創(chuàng)建一系列相關(guān)或相互依賴對(duì)象的接口，而無須指定它們具體的類。

概念
工廠模式：工廠模式就是不管如何實(shí)現(xiàn)的，只需要調(diào)用抽象話的接口就可以創(chuàng)建出特定類型的實(shí)例對(duì)象

簡(jiǎn)單工廠模式：
eg：一個(gè)例子更能很好的理解以上的內(nèi)容：
我們有一個(gè)基類Person ，包涵獲取名字，性別的方法 。有兩個(gè)子類male 和female，可以打招呼。還有一個(gè)工廠類。
工廠類有一個(gè)方法名getPerson有兩個(gè)輸入?yún)?shù)，名字和性別。
用戶使用工廠類，通過調(diào)用getPerson方法。

在程序運(yùn)行期間，用戶傳遞性別給工廠，工廠創(chuàng)建一個(gè)與性別有關(guān)的對(duì)象。因此工廠類在運(yùn)行期，決定了哪個(gè)對(duì)象應(yīng)該被創(chuàng)建。

class Person:

def __init__(self):
    self.name = None
    self.gender = None

def getName(self):
    return self.name

def getGender(self):
    return self.gender

class Male(Person):

def __init__(self, name):
    print "Hello Mr." + name

class Female(Person):

def __init__(self, name):
    print "Hello Miss." + name

class Factory:

def getPerson(self, name, gender):
    if gender == ‘M":
            return Male(name)
        if gender == "F":
        return Female(name)

if name == "__main__":

factory = Factory()
person = factory.getPerson("Chetan", "M")

抽象工廠模式：
提供一個(gè)創(chuàng)建一系列相關(guān)或相互依賴對(duì)象的接口，而無須指定它們具體的類。
class Burger():

"""
漢堡
"""
name=""
price=0.0
type="BURGER"
def getPrice(self):
    return self.price
def setPrice(self,price):
    self.price=price
def getName(self):
    return self.name

class CheeseBurger(Burger):

def __init__(self):
    self.name="cheese burger"
    self.price=10.0

class SpicyChickenBurger(Burger):

def __init__(self):
    self.name="spicy chicken burger"
    self.price=15.0

class Snack():

"""
小食類
"""
name = ""
price = 0.0
type = "SNACK"
def getPrice(self):
    return self.price
def setPrice(self, price):
    self.price = price
def getName(self):
    return self.name

class Chips(Snack):

def __init__(self):
    self.name = "chips"
    self.price = 6.0

class ChickenWings(Snack):

def __init__(self):
    self.name = "chicken wings"
    self.price = 12.0

class Beverage():

"""
飲料
"""
name = ""
price = 0.0
type = "BEVERAGE"
def getPrice(self):
    return self.price
def setPrice(self, price):
    self.price = price
def getName(self):
    return self.name

class Coke(Beverage):

def __init__(self):
    self.name = "coke"
    self.price = 4.0

class Milk(Beverage):

def __init__(self):
    self.name = "milk"
    self.price = 5.0

class FoodFactory():

"""
抽象工廠foodFactory為抽象的工廠類，而burgerFactory，snackFactory，beverageFactory為具體的工廠類。
"""
type=""
def createFood(self,foodClass):
    print(self.type," factory produce a instance.")
    foodIns=foodClass()
    return foodIns

class BurgerFactory(foodFactory):

def __init__(self):
    self.type="BURGER"

class SnackFactory(foodFactory):

def __init__(self):
    self.type="SNACK"

class BeverageFactory(foodFactory):

def __init__(self):
    self.type="BEVERAGE"

if __name__=="__main__":

burger_factory=burgerFactory()
snack_factory=snackFactory()
beverage_factory=beverageFactory()
cheese_burger=burger_factory.createFood(cheeseBurger)
print(cheese_burger.getName(),cheese_burger.getPrice())
chicken_wings=snack_factory.createFood(chickenWings)
print(chicken_wings.getName(),chicken_wings.getPrice())
coke_drink=beverage_factory.createFood(coke)
print(coke_drink.getName(),coke_drink.getPrice())

工廠模式優(yōu)點(diǎn)
工廠方法用來創(chuàng)建客戶所需要的產(chǎn)品，同時(shí)還向客戶隱藏了哪種具體產(chǎn)品類將被實(shí)例化這一細(xì)節(jié) 能夠讓工廠自主確定創(chuàng)建何種產(chǎn)品對(duì)象，而如何創(chuàng)建這個(gè)對(duì)象的細(xì)節(jié)則完全封裝在具體工廠內(nèi)部 在系統(tǒng)中加入新產(chǎn)品時(shí)，完全符合開閉原則
工廠模式缺點(diǎn)
系統(tǒng)中類的個(gè)數(shù)將成對(duì)增加，在一定程度上增加了系統(tǒng)的復(fù)雜度，會(huì)給系統(tǒng)帶來一些額外的開銷 增加了系統(tǒng)的抽象性和理解難度
工廠模式適用環(huán)境
客戶端不知道它所需要的對(duì)象的類（客戶端不需要知道具體產(chǎn)品類的類名，只需要知道所對(duì)應(yīng)的工廠即可，具體產(chǎn)品對(duì)象由具體工廠類創(chuàng)建） 抽象工廠類通過其子類來指定創(chuàng)建哪個(gè)對(duì)象

抽象工廠模式：
模式優(yōu)點(diǎn)
隔離了具體類的生成，使得客戶端并不需要知道什么被創(chuàng)建 當(dāng)一個(gè)產(chǎn)品族中的多個(gè)對(duì)象被設(shè)計(jì)成一起工作時(shí)，它能夠保證客戶端始終只使用同一個(gè)產(chǎn)品族中的對(duì)象 增加新的產(chǎn)品族很方便，無須修改已有系統(tǒng)，符合開閉原則
模式缺點(diǎn)
增加新的產(chǎn)品等級(jí)結(jié)構(gòu)麻煩，需要對(duì)原有系統(tǒng)進(jìn)行較大的修改，甚至需要修改抽象層代碼，這顯然會(huì)帶來較大的不便，違背了開閉原則
模式適用環(huán)境
一個(gè)系統(tǒng)不應(yīng)當(dāng)依賴于產(chǎn)品類實(shí)例如何被創(chuàng)建、組合和表達(dá)的細(xì)節(jié) 系統(tǒng)中有多于一個(gè)的產(chǎn)品族，但每次只使用其中某一產(chǎn)品族 屬于同一個(gè)產(chǎn)品族的產(chǎn)品將在一起使用，這一約束必須在系統(tǒng)的設(shè)計(jì)中體現(xiàn)出來 產(chǎn)品等級(jí)結(jié)構(gòu)穩(wěn)定，設(shè)計(jì)完成之后，不會(huì)向系統(tǒng)中增加新的產(chǎn)品等級(jí)結(jié)構(gòu)或者刪除已有的產(chǎn)品等級(jí)結(jié)構(gòu)

單例模式
單例模式（Singleton Pattern）是一種常用的軟件設(shè)計(jì)模式，該模式的主要目的是確保某一個(gè)類只有一個(gè)實(shí)例存在。當(dāng)你希望在整個(gè)系統(tǒng)中，某個(gè)類只能出現(xiàn)一個(gè)實(shí)例時(shí)，單例對(duì)象就能派上用場(chǎng)。 eg：系統(tǒng)中的打印機(jī)
實(shí)現(xiàn)方式：
使用模塊:
在mysingleton.py模塊文件中：(因?yàn)槟K在第一次導(dǎo)入時(shí)生成了.pyc文件，下次會(huì)直接從這個(gè)里面加載，不需要重新生成)
class Singleton:(object):

 def foo(self):
   pass

singleton = Singeton()

在其他文件中調(diào)用：
from mysingleton import singleton
使用裝飾器：
def Singleton(cls):

_instance = {}

def _singleton(*args, **kargs):

    if cls not in _instance:
        _instance[cls] = cls(*args, **kargs)
    return _instance[cls]

return _singleton

@Singleton
class A(object):

a = 1

def __init__(self, x=0):
    self.x = x

a1 = A(2)
a2 = A(3)
print(id(a1))
print(id(a2))

使用類
import time
import threading
class Singleton(object):

_instance_lock = threading.Lock()

def __init__(self):
    time.sleep(1)

@classmethod
def instance(cls, *args, **kwargs):
    if not hasattr(Singleton, "_instance"):
        with Singleton._instance_lock:
            if not hasattr(Singleton, "_instance"):
                Singleton._instance = Singleton(*args, **kwargs)
    return Singleton._instance

def task(arg):

obj = Singleton.instance()
print(obj)

for i in range(10):

t = threading.Thread(target=task,args=[i,])
t.start()

time.sleep(20)
obj = Singleton.instance()
print(obj)

基于__new__方法創(chuàng)建單例
import threading
class Singleton(object):

_instance_lock = threading.Lock()

def __init__(self):
    pass


def __new__(cls, *args, **kwargs):
    if not hasattr(Singleton, "_instance"):
        with Singleton._instance_lock:
            if not hasattr(Singleton, "_instance"):
                Singleton._instance = object.__new__(cls)  
    return Singleton._instance

obj1 = Singleton()
obj2 = Singleton()
print(obj1,obj2)

def task(arg):

obj = Singleton()
print(obj)

for i in range(10):

t = threading.Thread(target=task,args=[i,])
t.start()

基于metaclass方式來實(shí)現(xiàn)
import threading

class SingletonType(type):

_instance_lock = threading.Lock()
def __call__(cls, *args, **kwargs):
    if not hasattr(cls, "_instance"):
        with SingletonType._instance_lock:
            if not hasattr(cls, "_instance"):
                cls._instance = super(SingletonType,cls).__call__(*args, **kwargs)
    return cls._instance

class Foo(metaclass=SingletonType):

def __init__(self,name):
    self.name = name

obj1 = Foo("name")
obj2 = Foo("name")
print(obj1,obj2)