用Python学习一下设计模式，如果很枯燥的话，就强行能使用的就用一下。设计模式参考Python与设计模式-途索

1. 单例模式

保证一个类仅有一个实例，并提供一个访问它的全局访问点。

  1. import threading
  2. import time
  4. class Singleton(object):
  5.     '''抽象单例'''
  6.     def __new__(self, *args, **kw):
  7.         if not hasattr(self,'_instance'):
  8.             self._instance = super().__new__(self, *args, **kw)
  9.         return self._instance
  11. class Bus(Singleton):
  12.     '''总线'''
  13.     lock = threading.RLock()
  14.     def sendData(self, data):
  15.         self.lock.acquire()
  16.         time.sleep(3)
  17.         print("sending signal data... ", data)
  18.         self.lock.release()
  20. if __name__ == '__main__':
  21.     threadList=[]
  22.     for i in range(3):
  23.         print("entity %d begin to run ... " % i)
  24.         t = threading.Thread(target=Bus().sendData,args=("Entity_"+str(i),))
  25.         t.start()
  26.         threadList.append(t)
  27.     for t in threadList:
  28.         t.join()

输出：

  1. entity 0 begin to run ...
  2. entity 1 begin to run ...
  3. entity 2 begin to run ...
  4. sending signal data...  Entity_0
  5. sending signal data...  Entity_1
  6. sending signal data...  Entity_2

看到阿里号发在知乎的一篇设计模式下，有人评论python单例模式直接用模块就可以解决。

Python单例模式没必要弄一个单例类，用一个模块就很好，实例直接作为模块内的全局变量

实战

那模拟一下游戏中组团打BOSS的话，BOSS只实例一次，各个角色攻击或者治疗同一个BOSS。或许之后能成woext的文字小游戏。好吧，就正式命名成WOEXT吧。(wow text，致敬今日开的8.0，期待怀旧服)

  1. import time
  3. class Singleton(object):
  4.     '''抽象单例'''
  5.     def __new__(self, *args, **kw):
  6.         if not hasattr(self,'_instance'):
  7.             self._instance = super().__new__(self, *args, **kw)
  8.         return self._instance
  10. class Boss(Singleton):
  11.     '''BOSS类'''
  12.     def __new__(self):
  13.         self.hp=100
  14.         self._maxHp=100
  15.         return super().__new__(self)
  17.     def decHp(self,hurt=0):
  18.         '''攻击或者治疗'''
  19.         if hurt>0:
  20.             self.hp-=hurt
  21.             self.hp = self.hp if self.hp>0 else 0
  22.         elif hurt<0:
  23.             self.hp-=hurt
  24.             self.hp = self.hp if self.hp<self._maxHp else self._maxHp
  26.         return self.hp
  28.     def getHp(self):
  29.         return self.hp
  31. class Fighter(object):
  32.     '''人物类'''
  33.     def __init__(self, name, hp=100, attackVal=10):
  34.         self.name=name
  35.         #self.hp=hp
  36.         #self.attackVal=attackVal
  38.     def attack(self, value=0):
  39.         b=Boss()
  40.         b.decHp(value)
  41.         print("{0}| {1} -> boss, {2} {3} . [Boss hp={4}]".format(time.strftime("%M:%S",time.localtime()), self.name,'伤害' if value>=0 else '治疗',abs(value),b.getHp()))
  43. if __name__ == '__main__':
  45.     mt=Fighter("哀木涕")
  46.     mt.attack(10)
  47.     lr=Fighter("劣人")
  48.     lr.attack(-3)
  49.     dz=Fighter("呆呆贼")
  50.     dz.attack(12)

Boss类继承单例类，将hp和 _maxHp属性在__new__中赋值，则拥有了单例属性（唯一、共享）。注：不在super().__new__(self)前赋值的话，则为普通属性。这样还没有赋予抽象单例Singleton太多职责，很单纯的只是实例化。

输出

  1. 47:57| 哀木涕 -> boss, 伤害 10 . [Boss hp=90]
  2. 47:57| 劣人 -> boss, 治疗 3 . [Boss hp=93]
  3. 47:57| 呆呆贼 -> boss, 伤害 12 . [Boss hp=81]

关于Python模块是天然的单例模式。想要实战的话：例子中的打印可以做为战斗日志单独存在，用单例模式（另一个模块文件）实现：

Log.py文件：

  1. class WarLog(object):
  2.     '''战斗日志'''
  3.     def show(self,message):
  4.         print(message)
  6. warLog=WarLog()

导入:

  1. from Log import warLog

和使用（将例子attack()方法中print语句改为）:

  1. message="{0}| {1} -> boss, {2} {3} . [Boss hp={4}]".format(time.strftime("%M:%S",time.localtime()), self.name,'伤害' if value>=0 else '治疗',abs(value),b.getHp())
  2. warLog.show(message)

p.s. 想要比较两个实例是否为同一个实例，可用is比较: Boss() is Boss()

pss. 无意发现这么单例之后，Boss 类中不能使用带参数的__init__(self,x)了，卡了半天，有的说2.x到3.x这函数__new__(cls)后面参数没有的，和我这个无关，我的和别人错误不一样的原因是还重载了__new__，就没那么简单了，弄得心烦不弄了，反正只是为了单例属性用了__init__赋值之后也没用。搁置。我可只是为了练一下设计模式的啊，还想早早做出文字MT。

psss. 修正上面pss的备注，

Boss类中__new__, 参数不足。def __new__(self, *args, **kw)，即可。但也没有用的。因为

  1. class Boss(Singleton):
  2.     '''BOSS类'''
  3.     def __new__(self, *args, **kw):
  4.         self.hp=100
  5.         self._maxHp=100
  6.         return super().__new__(self)
  7.     def __init__(self,x):
  8.         self.o_o=x
  9.         pass
  11. a=Boss('a')
  12. b=Boss('b')
  13. print(a.o_o,b.o_o) #输出 b b

这样的话，后面实例的也会覆盖掉之前的。所以init这种事无所谓的。所以，上面的参数我也不改了，不然我这里说这么多就没有意义了（万一别人也会遇到这种难找的错误呢）。上面这段备注都写得混乱，不好意思。

再补充一句，2.x到3.x继承单例之后如果没有重载__new__的话，有TypeError: object() takes no parameters错误，直接改单例中的__new__(cls)参数即可了。

参考

2. 工厂模式

工厂模式：定义一个用于创建对象的接口，让子类决定实例化哪一个类。

简单工厂模式：省去了将工厂实例化的过程

抽象工厂模式：将每一个细致的产品都建立对应的工厂。 （提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类）

简单工厂模式

  1. # 主食
  2. class Burger():
  3.     def __init__(self, name='', price=0.0):
  4.         self.name=name
  5.         self.price=price
  6.         self.type='BURGER'
  7.     def getPrice(self):
  8.         return self.price
  9.     def setPrice(self,price):
  10.         self.price=price
  11.     def getName(self):
  12.         return self.name
  14. class cheeseBurger(Burger):
  15.     def __init__(self):
  16.         super().__init__("cheese burger", 10.0)
  18. class spicyChickenBurger(Burger):
  19.     def __init__(self):
  20.         super().__init__("spicy chicken burger", 15.0)
  22. # 小吃
  23. class Snack():
  24.     def __init__(self, name='', price=0.0):
  25.         self.name=name
  26.         self.price=price
  27.         self.type='SNACK'
  28.     def getPrice(self):
  29.         return self.price
  30.     def setPrice(self, price):
  31.         self.price = price
  32.     def getName(self):
  33.         return self.name
  35. class chips(Snack):
  36.     def __init__(self):
  37.         super().__init__("chips", 6.0)
  39. class chickenWings(Snack):
  40.     def __init__(self):
  41.         super().__init__("chicken wings", 12.0)
  43. # 饮料
  44. class Beverage():
  45.     def __init__(self, name='', price=0.0):
  46.         self.name=name
  47.         self.price=price
  48.         self.type='BEVERAGE'
  49.     def getPrice(self):
  50.         return self.price
  51.     def setPrice(self, price):
  52.         self.price = price
  53.     def getName(self):
  54.         return self.name
  56. class coke(Beverage):
  57.     def __init__(self):
  58.         super().__init__("coke", 4.0)
  60. class milk(Beverage):
  61.     def __init__(self):
  62.         super().__init__("milk", 5.0)
  64. # 工厂
  65. class SimpleFoodFactory():
  66.     '''简单工厂模式'''
  67.     @classmethod
  68.     def createFood(self,foodClass):
  69.         print(" factory produce a instance.")
  70.         foodIns=foodClass()
  71.         return foodIns
  73. if  __name__=="__main__":
  74.     cheese_burger=SimpleFoodFactory.createFood(cheeseBurger)
  75.     print(cheese_burger.__dict__)
  76.     chicken_wings=SimpleFoodFactory.createFood(chickenWings)
  77.     print(chicken_wings.__dict__)
  78.     coke_drink=SimpleFoodFactory().createFood(coke)
  79.     print(coke_drink.__dict__)

输出：

  1.  factory produce a instance.
  2. {'name': 'cheese burger', 'price': 10.0, 'type': 'BURGER'}
  3.  factory produce a instance.
  4. {'name': 'chicken wings', 'price': 12.0, 'type': 'SNACK'}
  5.  factory produce a instance.
  6. {'name': 'coke', 'price': 4.0, 'type': 'BEVERAGE'}

抽象工厂模式

  1. # 青蛙与虫子
  2. class Frog(object):
  3.     def __init__(self, name):
  4.         self.name = name
  5.     def __str__(self):
  6.         return self.name
  7.     def interact_with(self, obstacle):
  8.         print('{} the Frog encounters {} and {}!'.format(self, obstacle, obstacle.action()))
  10. class Bug(object):
  11.     def __str__(self):
  12.         return 'a bug'
  13.     def action(self):
  14.         return 'eats it'
  16. class FrogWorld(object):
  17.     def __init__(self, name):
  18.         print(self)
  19.         self.player_name = name
  20.     def __str__(self):
  21.         return '\n\n\t------ Frog World ------'
  22.     def make_character(self):
  23.         return Frog(self.player_name)
  24.     def make_obstacle(self):
  25.         return Bug()
  27. # 术士与兽人
  28. class Wizard(object):
  29.     def __init__(self, name):
  30.         self.name = name
  31.     def __str__(self):
  32.         return self.name
  33.     def interact_with(self, obstacle):
  34.         print('{} the Wizard battles against {} and {}!'.format(
  35.             self, obstacle, obstacle.action()))
  37. class Ork(object):
  38.     def __str__(self):
  39.         return 'an evil ork'
  40.     def action(self):
  41.         return 'kills it'
  43. class WizardWorld(object):
  44.     def __init__(self, name):
  45.         print(self)
  46.         self.player_name = name
  47.     def __str__(self):
  48.         return '\n\n\t------ Wizard World ------'
  49.     def make_character(self):
  50.         return Wizard(self.player_name)
  51.     def make_obstacle(self):
  52.         return Ork()
  54. class GameEnvironment(object):
  55.     '''游戏入口'''
  56.     def __init__(self, factory):
  57.         self.hero = factory.make_character()
  58.         self.obstacle = factory.make_obstacle()
  59.     def play(self):
  60.         self.hero.interact_with(self.obstacle)
  62. def validate_age(name):
  63.     '''年龄检测'''
  64.     try:
  65.         age = input('Welcome {}. How old are you? '.format(name))
  66.         age = int(age)
  67.     except ValueError as err:
  68.         print("Age {} is invalid, please try again...".format(age))
  69.         return (False, age)
  70.     return (True, age)
  72. if __name__ == '__main__':
  73.     name = input("Hello. What's your name? ")
  74.     valid_input = False
  75.     while not valid_input:
  76.         valid_input, age = validate_age(name)
  77.     game = FrogWorld if age < 18 else WizardWorld
  78.     environment = GameEnvironment(game(name))
  79.     environment.play()

FrogWorld和WizardWorld为抽象工厂。

通过用户年龄判断执行哪个游戏。

输出

  1. Hello. What's your name? cow
  2. Welcome cow. How old are you? 80
  3.         ------ Wizard World ------
  4. cow the Wizard battles against an evil ork and kills it!
  5. -----------------------------------------------------------
  6. Hello. What's your name? baa
  7. Welcome baa. How old are you? 12
  8.         ------ Frog World ------
  9. baa the Frog encounters a bug and eats it!

本来看到这个简书的例子看到也是小游戏的还有点小惊喜，运行以后很糟心。不影响运行的字符串里面的单词错误battles和evil, 影响运行的类名GameEnvironment和Frog。就搞不懂了，现在贴代码非要改一些东西才好防伪么？乱七八糟。再从游戏里面吐槽一下，Bug怎么可以有一个方法是eats it，这是自己的方法，抽象出来也应该像++美味风蛇++一样是eat me啊，不考虑这一层也应该是Frog

有一个killing或者Dining方法而Bug有die或者relish方法。

实战

把工厂模式加到之前的WOEXT中。

其实很虚啊，以前刚看Laravel文档不知是被那晦涩的翻译还是文档组织结构还是不太懂的设计模式虐的惨，所以一个设计模式不敢说都懂，现在只是看到工厂模式可以说这是工厂模式，但是用的时候就得理解到底什么是工厂模式了。这就是看懂和实战的区别，也是实战的意义所在。

一个简单工厂模式

  1. import time
  2. from Log import warLog
  4. class Singleton(object):
  5.     '''抽象单例'''
  6.     def __new__(self, *args, **kw):
  7.         if not hasattr(self,'_instance'):
  8.             self._instance = super().__new__(self, *args, **kw)
  9.         return self._instance
  11. class Boss(Singleton):
  12.     '''BOSS类'''
  13.     def __new__(self, *args, **kw):
  14.         self.hp=100
  15.         self._maxHp=100
  16.         return super().__new__(self)
  18.     def decHp(self,hurt=0):
  19.         '''攻击或者治疗'''
  20.         if hurt>0:
  21.             self.hp-=hurt
  22.             self.hp = self.hp if self.hp>0 else 0
  23.         elif hurt<0:
  24.             self.hp-=hurt
  25.             self.hp = self.hp if self.hp<self._maxHp else self._maxHp
  27.         return self.hp
  29.     def getHp(self):
  30.         return self.hp
  32. class Fighter(object):
  33.     '''抽象人物类'''
  34.     def __init__(self, name, hp=100, attackVal=10):
  35.         self.name=name
  36.         self.hp=hp
  37.         self.attackVal=attackVal
  39.     def attack(self):
  40.         value=self.attackVal
  42.         b=Boss()
  43.         b.decHp(value)
  44.         message="{0}| {1} -> boss, {2} {3} . [Boss hp={4}]".format(time.strftime("%M:%S",time.localtime()), self.name,'伤害' if value>=0 else '治疗',abs(value),b.getHp())
  45.         warLog.show(message)
  47. class Warrior(Fighter):
  48.     '''战士'''
  49.     name='战士'
  50.     def __init__(self, name=""):
  51.         if name: self.name=str(name)
  52.         super().__init__(self.name, 150, 10)
  54. class Hunter(Fighter):
  55.     '''猎人'''
  56.     name='猎人'
  57.     def __init__(self, name=""):
  58.         if name: self.name=str(name)
  59.         super().__init__(self.name, 100, 8)
  61. class Rogue(Fighter):
  62.     '''盗贼'''
  63.     name='盗贼'
  64.     def __init__(self, name=""):
  65.         if name: self.name=str(name)
  66.         super().__init__(self.name, 80, 12)
  68. class WarFactory(object):
  69.     '''战争工厂'''
  70.     @classmethod
  71.     def createFighter(self, fighter, name=''):
  72.         return fighter(name)
  74. if __name__ == '__main__':
  76.     zs=WarFactory.createFighter(Warrior, '哀木涕')
  77.     zs.attack()
  78.     lr=WarFactory.createFighter(Hunter, '劣人')
  79.     lr.attack()
  80.     dz=WarFactory.createFighter(Rogue, '呆呆贼')
  81.     dz.attack()

输出

  1. 09:25| 哀木涕 -> boss, 伤害 10 . [Boss hp=90]
  2. 09:25| 劣人 -> boss, 伤害 8 . [Boss hp=82]
  3. 09:25| 呆呆贼 -> boss, 伤害 12 . [Boss hp=70]

其中，Fighter为抽象的工厂类，Warrior,Hunter,Rogue为具体的工厂类。不过貌似还没有直接创建人物简单呢，那就再补一个场景：需要人海战术打Boss，每个角色只能补一刀。那么调用只需改成：

  1. while Boss().getHp()>0:
  2.         r=random.choice([Warrior, Hunter, Rogue])
  3.         WarFactory.createFighter(r).attack()

输出：

  1. 17:42| 战士 -> boss, 伤害 10 . [Boss hp=90]
  2. 17:42| 盗贼 -> boss, 伤害 12 . [Boss hp=78]
  3. 17:42| 战士 -> boss, 伤害 10 . [Boss hp=68]
  4. 17:42| 猎人 -> boss, 伤害 8 . [Boss hp=60]
  5. 17:42| 战士 -> boss, 伤害 10 . [Boss hp=50]
  6. 17:42| 猎人 -> boss, 伤害 8 . [Boss hp=42]
  7. 17:42| 战士 -> boss, 伤害 10 . [Boss hp=32]
  8. 17:42| 盗贼 -> boss, 伤害 12 . [Boss hp=20]
  9. 17:42| 猎人 -> boss, 伤害 8 . [Boss hp=12]
  10. 17:42| 盗贼 -> boss, 伤害 12 . [Boss hp=0]

当然现在Boss无还手之力，之后加上治疗之类的就会更有意思的。（巴特，我还是不知道自己有没有理解工厂

参考

3. 建造者模式

将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。

这个比较好理解啊，就是在一个类中，把需要的模块组合好。真·建造。就不放照抄的代码了，直接实例。

把萨满也加上，让他们四个角色组成一个菊爆小队。

  1. import time
  2. import random
  3. from Log import warLog
  5. class Singleton(object):
  6.     '''抽象单例'''
  7.     def __new__(self, *args, **kw):
  8.         if not hasattr(self,'_instance'):
  9.             self._instance = super().__new__(self, *args, **kw)
  10.         return self._instance
  12. class Boss(Singleton):
  13.     '''BOSS类'''
  14.     def __new__(self, *args, **kw):
  15.         self.hp=100
  16.         self._maxHp=100
  17.         return super().__new__(self)
  19.     def decHp(self,hurt=0):
  20.         '''攻击或者治疗'''
  21.         if hurt>0:
  22.             self.hp-=hurt
  23.             self.hp = self.hp if self.hp>0 else 0
  24.         elif hurt<0:
  25.             self.hp-=hurt
  26.             self.hp = self.hp if self.hp<self._maxHp else self._maxHp
  28.         return self.hp
  30.     def getHp(self):
  31.         return self.hp
  33. class Fighter(object):
  34.     '''抽象人物类'''
  35.     def __init__(self, name, hp=100, attackVal=10):
  36.         self.name=name
  37.         self.hp=hp
  38.         self.attackVal=attackVal
  40.     def attack(self):
  41.         value=self.attackVal
  43.         b=Boss()
  44.         b.decHp(value)
  45.         message="{0} -> boss, {1} {2} . [Boss hp={3}]".format( self.name,'伤害' if value>=0 else '治疗',abs(value),b.getHp())
  46.         warLog.show(message)
  48. class Warrior(Fighter):
  49.     '''战士'''
  50.     name='战士'
  51.     def __init__(self, name=""):
  52.         if name: self.name=str(name)
  53.         super().__init__(self.name, 150, 10)
  55. class Hunter(Fighter):
  56.     '''猎人'''
  57.     name='猎人'
  58.     def __init__(self, name=""):
  59.         if name: self.name=str(name)
  60.         super().__init__(self.name, 100, 8)
  62. class Rogue(Fighter):
  63.     '''盗贼'''
  64.     name='盗贼'
  65.     def __init__(self, name=""):
  66.         if name: self.name=str(name)
  67.         super().__init__(self.name, 80, 12)
  69. class Shaman(Fighter):
  70.     '''萨满'''
  71.     name='萨满'
  72.     def __init__(self, name=""):
  73.         if name: self.name=str(name)
  74.         super().__init__(self.name, 80, 6)
  76. class WarFactory(object):
  77.     '''战争工厂'''
  78.     @classmethod
  79.     def createFighter(self, fighter, name=''):
  80.         return fighter(name)
  82. # 建造模式，用来组队
  84. class TeamUp(object):
  85.     '''组队（生产）'''
  86.     def __init__(self, teamName="小队"):
  87.         self.teamName=teamName
  88.         self.total=4
  89.         self.zs=None
  90.         self.ls=None
  91.         self.dz=None
  92.         self.sm=None
  93.         self.team=[]
  94.         warLog.show("来人啊，我们{0}要组队了".format(self.teamName))
  96.     def enrollment(self, fighter):
  97.         '''入队'''
  98.         self.team.append(WarFactory.createFighter(fighter))
  99.         warLog.show("{0} 入队一人：{1}".format(self.teamName,fighter.name))
  101.     def __repr__(self):
  102.         if len(self.team)==self.total:
  103.             return "{0}成员：{1}, {2}, {3} 以及 {4}。".format(self.teamName,*[a.name for a in self.team])
  104.         return "小组不足{0}人".format(self.total)
  106. class TeamDirector(object):
  107.     '''组队过程（步骤）'''
  108.     def __init__(self, builder):
  109.         self.group = builder
  111.     def createTeam(self, zs, lr, dz, sm):
  112.         '''入队人员'''
  113.         self.group.enrollment(zs)
  114.         self.group.enrollment(lr)
  115.         self.group.enrollment(dz)
  116.         self.group.enrollment(sm)
  118.     def show(self):
  119.         warLog.show(self.group)
  121. if __name__ == '__main__':
  122.     # 建造者模式 菊爆小队
  123.     team=TeamDirector(TeamUp('【菊爆小队】'))
  124.     team.createTeam(Warrior, Hunter, Rogue, Shaman)
  125.     team.show()

输出：

  1. 19:15:49 来人啊，我们【菊爆小队】要组队了
  2. 19:15:49 【菊爆小队】 入队一人：战士
  3. 19:15:49 【菊爆小队】 入队一人：猎人
  4. 19:15:49 【菊爆小队】 入队一人：盗贼
  5. 19:15:49 【菊爆小队】 入队一人：萨满
  6. 19:15:49 【菊爆小队】成员：战士, 猎人, 盗贼 以及 萨满。

用到了上节的工厂特性。

4. 原型模式

用原型实例指定创建对象的种类，并且通过复制这些原型创建新的对象

其实最简单的理解还是Python原型模式这一篇

如果想根据现有对象复制出新的对象并对其修改，可以考虑原型模式

多简单，好娇柔和不造作，和那些妖艳贱货完全不一样。其他文章总是把深浅拷贝拿出来做重点说，其实从原型模式角度只是复制一份对象而已啊，深浅拷贝是其他重点了（我觉得）。修改一下来一个简单的原型模式：

  1. #原型模式
  2. import copy
  4. class Point:
  5.     def __init__(self, x, y, l):
  6.         print(l)
  7.         self.x = x
  8.         self.y = y
  9.         self.l = l
  11. p1=Point(1,2,[1,2,3])
  12. p2=copy.copy(p1) # 浅拷贝
  13. p3=copy.deepcopy(p1) # 深拷贝
  15. p1.x=0 # 修改 不可改变对象
  16. p1.l.append(4) # 修改（列表）可改变对象 （浅拷贝只会复制原列表的引用，指向同一个对象，所以修改时会更改p2.l）
  18. print(p1, p1.__dict__)
  19. print(p2, p2.__dict__)
  20. print(p3, p3.__dict__)

输出：

  1. [1, 2, 3] #可以看到只执行了一次初始化
  2. <__main__.Point object at 0x03A7AD10> {'x': 0, 'y': 2, 'l': [1, 2, 3, 4]}
  3. <__main__.Point object at 0x03632490> {'x': 1, 'y': 2, 'l': [1, 2, 3, 4]}
  4. <__main__.Point object at 0x03A8AB50> {'x': 1, 'y': 2, 'l': [1, 2, 3]}

这里就没有实例了，太简单了

Python与设计模式之创建型模式及实战的更多相关文章

  1. Python版设计模式： 创建型模式：单例模式和工厂模式家族

    一. 单例模式(Singleton) 所谓单例模式,也就是说不管什么时候都要确保只有一个对象实例存在.很多情况下,整个系统中只需要存在一个对象,所有的信息都从这个对象获取,比如系统的配置对象,或者是线 ...

  2. Java设计模式之创建型模式

    创建型模式分为五类:工厂方法模式.抽象工厂模式.单例模式.建造者模式.原型模式 一.工厂方法模式:接口-实现类.工厂类

  3. GoF的23种设计模式之创建型模式的特点和分类

    创建型模式的主要关注点是“怎样创建对象?”,它的主要特点是“将对象的创建与使用分离”.这样可以降低系统的耦合度,使用者不需要关注对象的创建细节,对象的创建由相关的工厂来完成.就像我们去商场购买商品时, ...

  4. Typescript玩转设计模式 之 创建型模式

    作者简介 joey 蚂蚁金服·数据体验技术团队 前言 我们团队的工作是用单页面应用的方式实现web工具.涉及到数万到十数万行的前端代码的管理,而且项目周期长达数年. 怎么样很好地管理好这种量级的前端代 ...

  5. 设计模式01 创建型模式 - 单例模式(Singleton Pattern)

    参考 [1] 设计模式之:创建型设计模式(6种) | 博客园 [2] 单例模式的八种写法比较 | 博客园 单例模式(Singleton  Pattern) 确保一个类有且仅有一个实例,并且为客户提供一 ...

  6. （转自精通Python设计模式）Python设计模式之创建型模式——2.建造者模式

    建造者模式将一个复杂对象的构造过程与其表现分离,这样,同一个构造过程可用于创建多个不同的表现. 我们来看个实际的例子,假设我们想要创建一个HMTL页面生成器,HTML页面的基本结构(构造组件)通常是一 ...

  7. python设计模式1:创建型模式

    1.原型模式 如果想根据现有的对象复制出新的对象并进行修改,可以考虑“原型模式”,而无需知道任何创建细节.(有点像写轮眼...你不需要知道它) import copy class Point: __s ...

  8. [C#]设计模式-单例模式-创建型模式

    单例模式用于在整个软件系统当中保持唯一实例,在 C# 当中最能够体现此概念的就是静态类,静态类的生命周期是跟随整个程序,并且在整个程序中仅保有一个实例. 不过在这里我们不再详细阐述单例模式与静态类有什 ...

  9. 设计模式01 创建型模式 - 原型模式(Protype Pattern)

    参考 1. 设计模式:原型模式 | 博客园 2. Java clone深拷贝.浅拷贝 | CSDN 3. Cloneable接口和Object的clone()方法 | 博客园 原型模式(Prototy ...

随机推荐

  1. Binary Tree Path Sum

    Given a binary tree, find all paths that sum of the nodes in the path equals to a given number targe ...

  2. [多线程] 线程中的synchronized关键字锁

    为什么要用锁? 在多线程中,难免会出现在多个线程中对同一个对象的实例变量或者全局静态变量进行并发访问的情况,如果不做正确的同步处理,那么产生的后果就是"脏读",也就是取到的数据其实 ...

  3. alias-unalias

    一.用一条命令完成创建目录/data/test,即在/目录下创建/data目录,及其子目录/data/test 解答:mkdir -p /data/test 实践过程: 二.已知/tmp目录下已经存在 ...

  4. Java学习笔记36（jdbc快速入门）

    JDBC: Java DataBase Connectivity 是java程序连接存取数据库的应用程序接口 (是sun公司的程序员定义的一套操作数据库的规则,然后下面的各个公司如:mysql,sql ...

  5. 剑指Offer 44. 翻转单词顺序列 （字符串）

    题目描述 牛客最近来了一个新员工Fish,每天早晨总是会拿着一本英文杂志,写些句子在本子上.同事Cat对Fish写的内容颇感兴趣,有一天他向Fish借来翻看,但却读不懂它的意思.例如,"st ...

  6. js--变量对象总结

    当 JavaScript 代码执行一段可执行代码(executable code)时,会创建对应的执行上下文(execution context). 对于每个执行上下文,都有三个重要属性: 变量对象( ...

  7. AFN 二次封装

    #import "YQDataManager.h" #import <YYModel/YYModel.h> #pragma mark - 数据model基类 @impl ...

  8. 软件工程 week 03

    一.效能分析 1.作业地址:https://edu.cnblogs.com/campus/nenu/2016CS/homework/2139 2.git地址:https://git.coding.ne ...

  9. （32）forms组件（渲染自建规则：局部钩子函数和全局钩子函数）

    要达成渲染自建规则 1.局部钩子函数(某个字段,自定意义规则,不如不能以sb开头,数据库已存在等) 2.全局钩子函数(校验两次密码是否一致) 3.使用css样式 register.html <! ...

  10. 《DSP using MATLAB》Problem 7.6

    代码: 子函数ampl_res function [Hr,w,P,L] = ampl_res(h); % % function [Hr,w,P,L] = Ampl_res(h) % Computes ...