上一週把《大話設計模式》看完了，對面向物件技術有了新的理解，對於一個在C下寫程式碼比較多、偶爾會用到一些指令碼語言寫指令碼的人來說，很是開闊眼界。《大話設計模式》的程式碼使用C#寫成的，而在本人接觸到的面嚮物件語言中，只對C++和Python還算了解，為了加深對各個模式的理解，我在網上下載了一個C++版的原始碼，並根據自己的理解邊讀這本書邊動手實踐C++原始碼，同時將其改寫成了Python程式碼，算是一箭三雕吧。

　　由於這些程式碼的目的是展示各個設計模式而非完成一個具體的複雜任務，基於C++版本改寫，例子的取材也和《大話設計模式》基本相同，再加上個人水平有限，因此這些Python版程式碼寫的比較簡單，雖然能跑起來是不假，不過難免有bug，而且實現也不一定最優，C++的味道比較濃而不夠pythonic，還請高手包容指正。不過我還是儘量把或多或少有些pythonic的東西放在每個模式的“程式碼特點”部分進行展示，而這個“程式碼特點”裡也不僅僅是pythonic的東西。

　　使用Python版本為2.6。

　　配圖同樣摘自《大話設計模式》，因此是C#風格的UML類圖，為了便於排版已經縮小了。

一、簡單工廠模式

模式特點：工廠根據條件產生不同功能的類。

程式例項：四則運算計算器，根據使用者的輸入產生相應的運算類，用這個運算類處理具體的運算。

程式碼特點：C/C++中的switch...case...分支使用字典的方式代替。

　　　　　使用異常機制對除數為0的情況進行處理。

class Operation:
    def GetResult(self):
        pass

class
 
 OperationAdd(Operation):
    def GetResult(self):
        return self.op1+self.op2


class OperationSub(Operation):
    def GetResult(self):
        return self.op1-self.op2


class OperationMul(Operation):
    def GetResult(self):
        return self.op1*self.op2


class OperationDiv(Operation):
    
 
def GetResult(self):
        try:
            result = self.op1/self.op2
            return result
        except:
            print "error:divided by zero."
            return 0

class OperationUndef(Operation):
    def GetResult(self):
        print "Undefine operation."
        return 0

class OperationFactory:
    operation = {}
    operation["+"] = OperationAdd();
    operation["-"] = OperationSub();
    operation["*"] = OperationMul();
    operation["/"] = OperationDiv();
    def createOperation(self,ch):        
        if ch in self.operation:
            op = self.operation[ch]
        else:
            op = OperationUndef()
        return op

if __name__ == "__main__":
    op = raw_input("operator: ")
    opa = input("a: ")
    opb = input("b: ")
    factory = OperationFactory()
    cal = factory.createOperation(op)
    cal.op1 = opa
    cal.op2 = opb
    print cal.GetResult()

二、策略模式

模式特點：定義演算法家族並且分別封裝，它們之間可以相互替換而不影響客戶端。

程式例項：商場收銀軟體，需要根據不同的銷售策略方式進行收費

程式碼特點：不同於同例1，這裡使用字典是為了避免關鍵字不在字典導致bug的陷阱。

class CashSuper:
    def AcceptCash(self,money):
        return 0

class CashNormal(CashSuper):
    def AcceptCash(self,money):
        return money

class CashRebate(CashSuper):
    discount = 0
    def __init__(self,ds):
        self.discount = ds
    def AcceptCash(self,money):
        return money * self.discount

class CashReturn(CashSuper):
    total = 0;
    ret = 0;
    def __init__(self,t,r):
        self.total = t
        self.ret = r
    def AcceptCash(self,money):
        if (money>=self.total):
            return money - self.ret
        else:
            return money

class CashContext:
    def __init__(self,csuper):
        self.cs = csuper
    def GetResult(self,money):
        return self.cs.AcceptCash(money)

if __name__ == "__main__":
    money = input("money:")
    strategy = {}
    strategy[1] = CashContext(CashNormal())
    strategy[2] = CashContext(CashRebate(0.8))
    strategy[3] = CashContext(CashReturn(300,100))
    ctype = input("type:[1]for normal,[2]for 80% discount [3]for 300 -100.")
    if ctype in strategy:
        cc = strategy[ctype]
    else:
        print "Undefine type.Use normal mode."
        cc = strategy[1]
    print "you will pay:%d" %(cc.GetResult(money))

三、裝飾模式

模式特點：動態地為物件增加額外的職責

程式例項：展示一個人一件一件穿衣服的過程。

程式碼特點：無

class Person:
    def __init__(self,tname):
        self.name = tname
    def Show(self):
       print "dressed %s" %(self.name)

class Finery(Person):
    componet = None
    def __init__(self):
        pass
    def Decorate(self,ct):
        self.componet = ct
    def Show(self):
    if(self.componet!=None):
        self.componet.Show()

class TShirts(Finery):
    def __init__(self):
        pass
    def Show(self):
        print "Big T-shirt "
        self.componet.Show()

class BigTrouser(Finery):
    def __init__(self):
        pass
    def Show(self):
        print "Big Trouser "
        self.componet.Show()

if __name__ == "__main__":
    p = Person("somebody")
    bt = BigTrouser()
    ts = TShirts()
    bt.Decorate(p)
    ts.Decorate(bt)
    ts.Show()

四、代理模式

模式特點：為其他物件提供一種代理以控制對這個物件的訪問。

程式例項：同模式特點描述。

程式碼特點：無

class Interface :
    def Request(self):
    return 0

class RealSubject(Interface): 
    def Request(self):
        print "Real request."

class Proxy(Interface):
    def Request(self):
        self.real = RealSubject()
        self.real.Request()

if __name__ == "__main__":
    p = Proxy()
    p.Request()

五、工廠方法模式

模式特點：定義一個用於建立物件的介面，讓子類決定例項化哪一個類。這使得一個類的例項化延遲到其子類。

程式例項：基類雷鋒類，派生出學生類和志願者類，由這兩種子類完成“學雷鋒”工作。子類的建立由雷鋒工廠的對應的子類完成。

程式碼特點：無

class LeiFeng:
    def Sweep(self):
        print "LeiFeng sweep"

class Student(LeiFeng):
    def Sweep(self):
        print "Student sweep"

class Volenter(LeiFeng):
    def Sweep(self):
        print "Volenter sweep"

class LeiFengFactory:
    def CreateLeiFeng(self):
        temp = LeiFeng()
        return temp

class StudentFactory(LeiFengFactory):
    def CreateLeiFeng(self):
        temp = Student()
        return temp

class VolenterFactory(LeiFengFactory):
    def CreateLeiFeng(self):
        temp = Volenter()
        return temp

if __name__ == "__main__":
    sf = StudentFactory()
    s=sf.CreateLeiFeng()
    s.Sweep()
    sdf = VolenterFactory()
    sd=sdf.CreateLeiFeng()
    sd.Sweep()

 六、原型模式

模式特點：用原型例項指定建立物件的種類，並且通過拷貝這些原型建立新的物件。

程式例項：從簡歷原型，生成新的簡歷

程式碼特點：簡歷類Resume提供的Clone()方法其實並不是真正的Clone，只是為已存在物件增加了一次引用。

　　　　　Python為物件提供的copy模組中的copy方法和deepcopy方法已經實現了原型模式，但由於例子的層次較淺，二者看不出區別。

import copy
class WorkExp:
    place=""
    year=0

class Resume:
    name = ''
    age = 0
    def __init__(self,n):
        self.name = n
    def SetAge(self,a):
        self.age = a
    def SetWorkExp(self,p,y):
        self.place = p
        self.year = y
    def Display(self):
        print self.age
        print self.place
        print self.year
    def Clone(self):
    #實際不是“克隆”，只是返回了自身
        return self

if __name__ == "__main__":
    a = Resume("a")
    b = a.Clone()
    c = copy.copy(a)
    d = copy.deepcopy(a)
    a.SetAge(7)
    b.SetAge(12)
    c.SetAge(15)
    d.SetAge(18)
    a.SetWorkExp("PrimarySchool",1996)
    b.SetWorkExp("MidSchool",2001)
    c.SetWorkExp("HighSchool",2004)
    d.SetWorkExp("University",2007)
    a.Display()
    b.Display()
    c.Display()
    d.Display()

七、模板方法模式

 

模式特點：定義一個操作中的演算法骨架，將一些步驟延遲至子類中。

程式例項：考試時使用同一種考卷（父類），不同學生上交自己填寫的試卷（子類方法的實現）

程式碼特點：無

class TestPaper:
    def TestQuestion1(self):
        print "Test1:A. B. C. D."
        print "(%s)" %self.Answer1()

    def TestQuestion2(self):
        print "Test1:A. B. C. D."
        print "(%s)" %self.Answer2()
    def Answer1(self):
        return ""
    def Answer2(self):
        return ""

class TestPaperA(TestPaper):
    def Answer1(self):
        return "B"
    def Answer2(self):
        return "C";

class TestPaperB(TestPaper):
    def Answer1(self):
        return "D"
    def Answer2(self):
        return "D";

if __name__ == "__main__":
    s1 = TestPaperA()
    s2 = TestPaperB()
    print "student 1"
    s1.TestQuestion1()
    s1.TestQuestion2()
    print "student 2"
    s2.TestQuestion1()
    s2.TestQuestion2()

 八、外觀模式

模式特點：為一組呼叫提供一致的介面。

程式例項：介面將幾種呼叫分別組合成為兩組，使用者通過介面呼叫其中的一組。

程式碼特點：無

class SubSystemOne:
    def MethodOne(self):
        print "SubSysOne"

class SubSystemTwo:
    def MethodTwo(self):
        print "SubSysTwo"

class SubSystemThree:
    def MethodThree(self):
        print "SubSysThree"

class SubSystemFour:
    def MethodFour(self):
        print "SubSysFour"


class Facade:
    def __init__(self):
        self.one = SubSystemOne()
        self.two = SubSystemTwo()
        self.three = SubSystemThree()
        self.four = SubSystemFour()
    def MethodA(self):
        print "MethodA"
        self.one.MethodOne()
        self.two.MethodTwo()
        self.four.MethodFour()
    def MethodB(self):
        print "MethodB"
        self.two.MethodTwo()
        self.three.MethodThree()

if __name__ == "__main__":
    facade = Facade()
    facade.MethodA()
    facade.MethodB()

九、建造者模式

 

相關推薦