目录
1.概述
2.常用的设计模式
3.单例模式
(1)保证只有一个对象
(2)正常情况下一个类的多个对象
(3)创建单例模式的方式
1)使用__new__()魔法方法,创建一个传统的单例模式
2)导入模块
4.工厂模式
(1)工厂模式是一个在软件开发中用来创建对象的设计模式。
(2)使用工厂模式应用场景:
(3)工厂里造出来新车,提到4s店,客户下单之后,就可以取到车,车就能跑能停
用工厂模式实现这个功能
5.策略模式
(1)策略指的就是为了达到某一目的而采取的多种手段或者方法。
(2)策略模式的定义
(3)策略模式的结构
Context(环境类)
Strategy(抽象策略类)
ConcreteStrategy(具体策略类)
(4)练习:
假设某公司维护着一些客户资料,需要在该公司有新产品上市或者举行新活动的时候,通知客户现通知客户的方式有两种:电话通知,邮件通知 type应如何设计该系统的客户通知部分
简单来说设计模式就是一种方法(套路),是软件开发人员在软件开发过程中面临的一般问题的解决方法
使用设计模式是为了重用代码,让代码更容易被他人理解,保证代码的可靠性。
比如说:比如说建筑行业,中西方建筑各有自己的风格,每种风格都有自己的建筑方法(套路),只要按照不同的建筑方法,就能建成不同的建筑。
再比如说:肯德基麦当劳快餐店为什么全球的口味都一样呢,就是做食品的套路相同。
单例模式 | 保证只有一个对象 |
工厂模式 | 用来创建对象 |
策略模式 | 定义一系列算法(逻辑),将每一个算法封装起来(一个算法创建一个类),并让它们可以相互替换。此模式让算法的变化,不会影响到使用算法的客户. |
比如说:世界上只有一个太阳
# 这种方法可以创建单例模式,即创建了相同的对象,但是写法不规范
class Sun(object):
def __new__(cls, *args, **kwargs):
super().__new__(cls)
sun1 = Sun()
sun2 = Sun()
print(id(sun1))
print(id(sun2))
class Sun(object):
instance = None
def __new__(cls, *args, **kwargs):
if not cls.instance: # not None就是True,没有对象就创建一个新对象
cls.instance = super().__new__(cls)
# 调用父类object的__new__()方法,把创建的新对象传给cls.instance
return cls.instance # 有对象就返回原来有的那个对象
sun1 = Sun()
sun2 = Sun()
print(id(sun1))
print(id(sun2))
# sun1和sun2的地址一样
导入singleton模块的sun对象,不管导入几次,sun对象都是一样的,地址也是一样的
当程序运行输入一个“类型”的时候,需要创建于此相应的对象。这就用到了工厂模式。在如此情形中,实现代码基于工厂模式,可以达到可扩展,可维护的代码。当增加一个新的类型,不在需要修改已存在的类,只增加能够产生新类型的子类。
不知道用户想要创建什么样的对象
class Car(object):
def run(self):
print('快快的跑...')
def stop(self):
print('慢慢的停...')
class BMW(Car):
def run(self):
print('宝马---->快快的跑...')
def stop(self):
print('宝马---->慢慢的停...')
class Benz(Car):
def run(self):
print('奔驰---->快快的跑...')
def stop(self):
print('奔驰---->慢慢的停...')
class CarFactory(object):
def new_car(self, name):
if name == 'BMW':
return BMW()
if name == 'Benz':
return Benz()
class CarStore(object):
def __init__(self, factory):
self.factory = factory
def order(self, name):
return self.factory.new_car(name)
car_factory = CarFactory()
car_store = CarStore(car_factory)
car = car_store.order('BMW')
car.run() # 宝马---->快快的跑...
car.stop() # 宝马---->慢慢的停...
car2 = car_store.order('Benz')
car2.run() # 奔驰---->快快的跑...
car2.stop() # 奔驰---->慢慢的停...
如果想要添加别的类型的车的话,就直接新建一个该类型的车的类,在工厂里面多增加一个if判断语句:
比如说:我想再添加一个斯柯达的车:
class SKD(object):
def run(self):
print('斯柯达---->快快的跑...')
def stop(self):
print('斯柯达---->慢慢的停...')
为了实现软件设计,对象可能会用到多种多样的算法(逻辑)。这些算法甚至会经常改变。如果将这些算法都硬编码到对象中,将会使得对象本身变得臃肿不堪,
策略模式很好的实现了将算法与本身对象解耦,从而避免出现上述的问题。
定义一系列算法(逻辑),将每一个算法封装起来(一个算法创建一个类),并让它们可以相互替换。此模式让算法的变化,不会影响到使用算法的客户.
策略模式包含以下3个角色:
'''
练习:假设某公司维护着一些客户资料,需要在该公司有新产品上市或者举行新活动的时候,通知客户
现通知客户的方式有两种:电话通知,邮件通知 type
应如何设计该系统的客户通知部分
'''
class MsgSender(object):
type = '' # 发送信息的方式,用来保存电话号码和邮箱地址
info = '' # 保存给客户发送的信息
def send(self):
pass
class PhoneSender(MsgSender):
def send(self):
print('给{}打电话说:{}'.format(self.type, self.info))
class Emailsender(MsgSender):
def send(self):
print('给{}发送邮件的内容:{}'.format(self.type, self.info))
class Customer(object):
name = '' # 姓名
phone = '' # 电话
email = '' # 电子邮件
send_way = None # 发送方式
# 设置发送方式
def set_send_way(self, send_way):
self.send_way = send_way
# 发送内容
def send_msg(self):
self.send_way.send()
if __name__ == '__main__': # 当做程序的入口
customer = Customer()
customer.name = 'zs'
customer.phone = '110'
customer.email = '[email protected]'
# 1.打电话告诉
phone_sender = PhoneSender()
phone_sender.info = '快来啊,造作啊,新品上市了...'
phone_sender.type = customer.phone
customer.set_send_way(phone_sender) # 设置发送的方式
customer.send_msg() # 给110打电话说:快来啊,造作啊,新品上市了...
# 2.发电子邮件:
email_sender = Emailsender()
email_sender.type = customer.email
email_sender.info = '快来啊,造作啊,新品上市了...'
customer.set_send_way(email_sender)
customer.send_msg() # 给[email protected]发送邮件的内容:快来啊,造作啊,新品上市了...