目录
一、简单工厂模式
问题描述
小菜今年计算机专业大四了，学了不少软件开发方面的东西，也学着编了些小程序，踌躇满志，一心要找一个好单位。当投递了无数份简历后，终于收到了一个单位的面试通知，小菜欣喜若狂。到了人家单位，前台小姐给了他一份题目，上面写着："请用C++、Java, C#或VB.NET任意一种面向对象语言实现一个计算器控制台程序，要求输入两个数和运算符号，得到结果。
模式定义
简单工厂模式（Simple Factory Pattern）是用一个单独的类来实现具体的实例化过程，避免客户端对具体实例化过程的显式指定。
问题分析
面向对象：封装、继承、多态
简单工厂模式可以用于这个问题。将加减乘除等运算类独立实现，并创建工厂类维护对运算类的使用。之后若需要增加新的运算符号，则只需增加运算类，修改工厂类即可，这也同时降低修改后的重复编译量（松耦合）。此外，简单工厂模式降了低业务逻辑和界面逻辑的耦合，易于复用（不是复制），若未来该windows程序迁移到web版，业务部分（计算部分）不需要修改。
代码实现
class Operation(object):
__numberA = 0
__numberB = 0
def get_numberA(self):
return self.__numberA
def set_numberA(self, numberA):
self.__numberA = numberA
def get_numberB(self):
return self.__numberB
def set_numberB(self, numberB):
self.__numberB = numberB
def get_result(self):
result = 0
return result
numberA = property(get_numberA, set_numberA)
numberB = property(get_numberB, set_numberB)
class OperationAdd(Operation): # 加法类，继承运算类
def get_result(self):
result = self.numberA + self.numberB
return result
class OperationSub(Operation): # 减法类，继承运算类
def get_result(self):
result = self.numberA - self.numberB
return result
class OperationMul(Operation): # 乘法类，继承运算类
def get_result(self):
result = self.numberA * self.numberB
return result
class OperationDiv(Operation): # 除法类，继承运算类
def get_result(self):
if self.numberB == 0:
raise Exception("除数不能为0")
result = self.numberA / self.numberB
return result
class OperationFactory(object): # 简单运算工厂类
def createOperate(self, operate):
if operate == "+":
self.oper = OperationAdd()
elif operate == "-":
self.oper = OperationSub()
elif operate == "*":
self.oper = OperationMul()
elif operate == "/":
self.oper = OperationDiv()
return self.oper
if __name__ == '__main__':
oper = OperationFactory().createOperate("+")
oper.numberA = 1
oper.numberB = 2
result = oper.get_result()
print(result)
二、策略模式
问题描述
小菜，给你出个作业，做一个商场收银软件，营业员根据客户所购买商品的单价和数量，向客户收费。
问题分析
简单工厂模式虽然也能解决这个问题，但这个模式只是解决对象的创建问题，而且由于工厂本身包括了所有的收费方式，商场是可能经常性地更改打折额度和返利额度，每次维护或扩展收费方式都要改动这个工厂，以致代码需重新编译部署，这真的是很糟精的处理方式，所以用它不是最好的办法。面对算法的时常变动，应该有更好的办法。
模式定义
策略模式（Strategy Pattern）是指定义一个算法家族，使得家族内的不同算法都遵从算法家族的接口及方法规范，从而可以实现算法间互相替换，且不会影响到使用算法的客户。
代码实现
import tkinter
import tkinter.ttk
class CashSuper(object): # 现金收取超类的抽象方法，收取现金，参数为原价，返回为当前价
def __init__(self):
pass
def accept_cash(self, money):
pass
class CashNormal(CashSuper): # 正常收费，原价返回
def accept_cash(self, money):
return money
class CashRebate(CashSuper): # 打折收费，初始化时，必需要输入折扣率，如八折，就是0.8
__moneyRebate = 1
def cash_rebate(self, moneyRebateStr):
self.__moneyRebate = float(moneyRebateStr)
def accept_cash(self, money):
return money * self.__moneyRebate
class CashReturn(CashSuper): # 返利收费，初始化时必须要输入返利条件和返利值，比如满300返100，则moneyCondition为300，moneyReturn为100
__moneyCondition = 0
__moneyReturn = 0
def cash_return(self, moneyConditionStr, moneyReturnStr):
self.__moneyCondition = float(moneyConditionStr)
self.__moneyReturn = float(moneyReturnStr)
def accept_cash(self, money):
result = money
if (money >= self.__moneyCondition): # 若大于返利条件，则需要减去返利值
result = money - money // self.__moneyCondition * self.__moneyReturn
return result
class CashContext(object):
def __init__(self, typ):
self.cs = CashSuper()
if typ == "正常收费":
self.cs = CashNormal()
elif typ == "满300返100":
self.cs = CashReturn()
self.cs.cash_return("300", "100")
elif typ == "打8折":
self.cs = CashRebate()
self.cs.cash_rebate("0.8")
def get_result(self, money):
return self.cs.accept_cash(money)
class CashWindow(object):
def __init__(self):
self.total = 0 # 声明一个total来计算总计
root = tkinter.Tk()
self.label1 = tkinter.Label(root, text="单价：")
self.txtPrice = tkinter.Entry(root, width=24, )
self.label2 = tkinter.Label(root, text="数量：")
self.txtNum = tkinter.Entry(root, width=24, )
self.ibxList = tkinter.Text(root, width=45, height=10)
self.label4 = tkinter.Label(root, text="总计：")
self.iblResult = tkinter.StringVar()
self.iblResult.set("%.2f" % self.total) # 保留两位小数的浮点型
self.result = tkinter.Label(root, textvariable=self.iblResult, height=2, font=('TimeNewsRoman', 24))
self.button = tkinter.Button(root, text="确定", width=10, command=self.btnOK_click)
self.buttonReset = tkinter.Button(root, text="重置", width=10, command=self.btnReset_click)
self.label3 = tkinter.Label(root, text="计算方式：")
self.comboVar = tkinter.StringVar()
self.combobox = tkinter.ttk.Combobox(root, textvariable=self.comboVar, width=22, )
self.combobox['value'] = ("正常收费", "打8折", "满300返100") # 在combobox中加下拉选项
self.combobox.current(0)
self.layout()
root.mainloop()
def refresh(self):
self.txtPrice.delete('0', 'end')
self.txtNum.delete('0', 'end')
def layout(self):
self.label1.grid(row=0, column=0, padx=(10, 0), pady=10)
self.txtPrice.grid(row=0, column=1, pady=10, padx=(0, 5), )
self.label2.grid(row=1, column=0, padx=(10, 0))
self.txtNum.grid(row=1, column=1, padx=(0, 5), )
self.label3.grid(row=2, column=0, padx=(10, 0))
self.combobox.grid(row=2, column=1, padx=(0, 5), pady=10)
self.ibxList.grid(row=4, column=0, columnspan=4, padx=(5, 5), pady=10)
self.label4.grid(row=5, column=0, padx=(10, 0))
self.result.grid(row=5, column=1, columnspan=3, rowspan=2)
self.button.grid(row=0, column=2, columnspan=2, pady=10, padx=(0, 10))
self.buttonReset.grid(row=1, column=2, columnspan=2, padx=(0, 10))
def btnReset_click(self):
self.total = 0
self.ibxList.delete('1.0', 'end')
self.iblResult.set("%.2f" % self.total)
self.refresh()
# 主要部分
def btnOK_click(self):
csuper = CashContext(self.comboVar.get())
totalPrice = csuper.get_result(
float(self.txtPrice.get()) * float(self.txtNum.get())) # 声明一个totalPrice来计算每个商品的单价（txtPrice）*数量（txtNum）后的合计
self.total = self.total + totalPrice # 将每个商品合计计入总计
self.ibxList.insert('end',
"单价：" + self.txtPrice.get() + "数量：" + self.txtNum.get() + " " + self.comboVar.get() + "合计：%.2f" % (
totalPrice) + "\n") # 在列表框中显示信息
self.iblResult.set("%.2f" % self.total)
self.refresh()
if __name__ == '__main__':
CashWindow()
三、装饰模式
问题描述
我现在要求你写一个可以给人搭配不同的服饰的系统，比如类似QQ、网络游戏或论坛都有的Avatar系统。你怎么开发？
问题分析
建造者模式要求建造的过程必须是稳定的，而现在我们这个例子，建造过程是不稳定的，比如完全可以内穿西装，外套T恤，再加披风，打上领带，皮鞋外再穿上破球鞋：当然也完全可以只穿条辫衩就算完成。换句话就是说，通过服饰组合出一个有个性的人完全可以有无数种方案，并非是固定的。我们需要把所需的功能按正确的顺序串联起来进行控制，此时可以考虑使用装饰模式。
模式定义
装饰模式（Decorator Pattern）是指创建一个装饰类，来包装原有的类，从而实现动态地向一个现有的对象添加一些额外的职责，同时不改变其原有的结构。装饰模式比生成子类更为灵活。
代码实现
class Person(object):
def __init__(self, name=""):
self.name = name
def show(self):
print("装扮的" + self.name)
# 服饰类（Decorator）
class Finery(Person):
component = None
def decorate(self, component: Person):
self.component = component
def show(self):
if self.component != None:
self.component.show()
# 具体服饰类（Concrete Decorator）
class Tshirts(Finery):
def show(self):
print("大T恤", end=" ")
super().show()
class BigTrouser(Finery):
def show(self):
print("垮裤", end=" ")
super().show()
class Sneakers(Finery):
def show(self):
print("破球鞋", end=" ")
super().show()
class Suit(Finery):
def show(self):
print("西装", end=" ")
super().show()
class Tie(Finery):
def show(self):
print("领带", end=" ")
super().show()
class LeatherShoes(Finery):
def show(self):
print("皮鞋", end=" ")
super().show()
if __name__ == '__main__':
xc = Person('小菜')
print("第一种装扮：")
dtx = Tshirts()
kk = BigTrouser()
pqx = Sneakers()
pqx.decorate(xc)
kk.decorate(pqx)
dtx.decorate(kk)
dtx.show()
print("第二种装扮：")
xz = Suit()
ld = Tie()
px = LeatherShoes()
px.decorate(xc)
ld.decorate(px)
xz.decorate(ld)
xz.show()
print("第三种装扮：")
pqx2 = Sneakers()
px2 = LeatherShoes()
kk2 = BigTrouser()
ld2 = Tie()
pqx2.decorate(xc)
px2.decorate(pqx2)
kk2.decorate(px2)
ld2.decorate(kk2)
ld2.show()
四、代理模式
问题描述
隔壁班的卓贾易想追求娇娇，但是他自己不好意思，就委托和娇娇同班的戴励帮助他。
问题分析
模式定义
代理模式（Proxy Pattern）是指实现一个类代表另一个类的功能，为其他对象提供一种代理以控制对这个对象的访问。
- 第一，远程代理，也就是为一个对象在不同的地址空间提供局部代表。这样可以隐藏一个对象存在于不同地址空间的事实。
- 第二种应用是虚拟代理，是根据需要创建开销很大的对象.通过它来存放实例化需要很长时间的真实对象。
- 第三种应用是安全代理，用来控制真实对象访问时的权限［DP］,一般用于对象应该有不同的访问权限的时候。第四种是智能指引，是指当调用真实的对象时，代理处理另外一些事。
代码实现
class SchoolGirl(object):
__name = None
def get_name(self):
return self.__name
def set_name(self, name):
self.__name = name
name = property(get_name, set_name)
class IGiveGift(object):
def give_dolls(self):
pass
def give_flowers(self):
pass
def give_chocolate(self):
pass
class Pursuit(IGiveGift):
__mm = None
def __init__(self, mm: SchoolGirl):
self.__mm = mm
def give_dolls(self):
print(self.__mm.name + " 送你洋娃娃")
def give_flowers(self):
print(self.__mm.name + " 送你鲜花")
def give_chocolate(self):
print(self.__mm.name + " 送你巧克力")
class Proxy(IGiveGift):
def __init__(self, mm: SchoolGirl):
self.gg = Pursuit(mm)
def give_dolls(self):
self.gg.give_dolls()
def give_flowers(self):
self.gg.give_flowers()
def give_chocolate(self):
self.gg.give_chocolate()
if __name__ == '__main__':
jiaojiao = SchoolGirl()
jiaojiao.name = "李娇娇"
daili = Proxy(jiaojiao)
daili.give_dolls()
daili.give_flowers()
daili.give_chocolate()
五、工厂方法模式
问题描述
大学生薛磊风在过去三年里一直在帮助孤寡老人，每周都去老人家里，为老人洗衣扫地、买米买油。有一次，他不幸受了伤，便委托他的两个同学继续去帮助老人，且不必提及任何人的名字，只需说是学雷锋做好事即可。
帮助老人是长期工作，三名“学雷锋的大学生”毕业后，也依然会以“社区志愿者”的名义继续学雷锋做好事。而老人其实不需要知道是谁来做好事，只需要知道是学雷锋的人来帮助就可以了。
问题分析
这一程序可以先用简单工厂模式实现，但由于学雷锋的学生毕业后，会转变身份成为社区志愿者，此时若使用简单工厂模式会涉及到工厂类的修改，违背开放封闭原则。当我们使用工厂方法模式时，可以对学雷锋的学生和社区志愿者分别建立工厂类，让客户端决定实例化哪一个工厂类。
模式定义
工厂方法模式（Factory Method Pattern）是指定义一个用于创建对象的结构，让子类决定实例化哪个类。工厂方法使类的实例化过程延迟到其子类。
工厂方法模式实现时，客户端需要决定实例化哪一个工厂来实现功能类，即将简单工厂内部的逻辑判断已到了客户端进行。
简单工厂 vs. 工厂方法
简单工厂模式的最大优点在于工厂类中包含了必要的逻辑判断，根据客户端的选择条件动态实例化相关的类，对干客户端来说，去除了与具体产品的依赖。工厂方法克服了简单工厂违背开放-封闭原则的缺点，又保持了封装对象创建过程的优点。
代码实现
class LeiFeng(object):
def sweep(self):
print("扫地")
def wash(self):
print("洗衣")
def buy_rice(self):
print("买米")
class Undergraduate(LeiFeng):
pass
class Volunteer(LeiFeng):
pass
class SimpleFactory(object):
def create_LeiFeng(self, typ: str) -> LeiFeng:
self.result = None
if typ == "学雷锋的大学生":
self.result = Undergraduate()
elif typ == "社区志愿者":
self.result = Volunteer()
return self.result
class IFactory(object):
def create_LeiFeng(self):
pass
class UndergraduateFactory(IFactory):
def create_LeiFeng(self):
return Undergraduate()
class VolunteerFactory(IFactory):
def create_LeiFeng(self):
return Volunteer()
if __name__ == '__main__':
# 简单工厂模式
studentA = SimpleFactory().create_LeiFeng("学雷锋的大学生")
studentA.buy_rice()
studentB = SimpleFactory().create_LeiFeng("学雷锋的大学生")
studentB.sweep()
studentC = SimpleFactory().create_LeiFeng("学雷锋的大学生")
studentC.wash()
# 工厂方法模式
factory = UndergraduateFactory()
student = factory.create_LeiFeng()
student.buy_rice()
student.sweep()
student.wash()
factory = VolunteerFactory()
student = factory.create_LeiFeng()
student.buy_rice()
student.sweep()
student.wash()
学习参考链接：
视频1: https://www.bilibili.com/video/BV1hG4y1d7GK?p=4&vd_source=c5d53beb52dbf1f3fcc4518fb4b1cbfa
视频2: https://www.bilibili.com/video/BV1454y187Er/?spm_id_from=333.1007.top_right_bar_window_history.content.click&vd_source=c5d53beb52dbf1f3fcc4518fb4b1cbfa
494
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
