大话设计模式

按有用程度 按页码先后 最新笔记

• 

  第278页

  onesuper (穷则独善其身，达则兼济姑娘)

  享元模式（Flyweight） Flyweight是拳击比赛中轻量级选手的意思，在这里“轻”的是实例的量。 比如下面这个例子中，当有很多网站时，内存中就会有大量的Website实例，而这些实例中存在大量的重复，比如name字段，可能一半的网站的name是product，一半是blog，而不一样的只是user。这个时候可以想办法把相同的东西（name）合并在一个对象内部，而把不同的东西（user）放在对象外部。 用个Web工厂制造出product和blog两种模... (更多)

  享元模式（Flyweight）

  Flyweight是拳击比赛中轻量级选手的意思，在这里“轻”的是实例的量。

  比如下面这个例子中，当有很多网站时，内存中就会有大量的Website实例，而这些实例中存在大量的重复，比如name字段，可能一半的网站的name是product，一半是blog，而不一样的只是user。这个时候可以想办法把相同的东西（name）合并在一个对象内部，而把不同的东西（user）放在对象外部。

  用个Web工厂制造出product和blog两种模板，每个类分别对应一个实例，这个实例只有代码段和name，要工作的话还需要将user作为参数传进来。

  1.网站类

  #!/usr/bin/python
  # Filename: web.py
  
  class Website:
  	def __init__(self, name):
  		self.name = name
  	def Use(self, user):
  		print 'This site is about ' + user.name + '\'s ' + self.name
  
  class WebsiteFactory:
  	def __init__(self):
  		self.flyweights = {}
  	def GetWebsiteCategory(self, key):
  		if not self.flyweights.has_key(key):
  			self.flyweights[key] = Website(key)
  		return self.flyweights[key]
  	def GetWebsiteCount(self):
  		return len(self.flyweights)
  

  2.用户类

  #!/usr/bin/python
  # Filename: user.py
  
  class User:
  	def __init__(self, name):
  		self.name = name
  

  3.客户端

  #!/usr/bin/python
  # Filename: console.py
  
  import web
  import user 
  
  f = web.WebsiteFactory()
  
  web1 = f.GetWebsiteCategory("product")
  web1.Use(user.User('A'))
  
  web2 = f.GetWebsiteCategory("product")
  web2.Use(user.User('B'))
  
  web3 = f.GetWebsiteCategory("product")
  web3.Use(user.User('C'))
  
  web4 = f.GetWebsiteCategory("blog")
  web4.Use(user.User('D'))
  
  web5 = f.GetWebsiteCategory("blog")
  web5.Use(user.User('E'))
  
  web6 = f.GetWebsiteCategory("blog")
  web6.Use(user.User('F'))
  
  print f.GetWebsiteCount()
  

  (收起)

  2011-05-17 14:48:24   1人收藏   回应

  收藏

  推荐
• 

  第188页

  onesuper (穷则独善其身，达则兼济姑娘)

  备忘录模式（Memento） 常用来实现撤销（ctrl+z）的功能，即把上一个状态保存下来，以便迅速恢复。另一大用途就是RPG的存档~ 1.role类 /代码内容已省略/ 2.托管类 /代码内容已省略/ 3.客户端 /代码内容已省略/ (更多)

  备忘录模式（Memento）

  常用来实现撤销（ctrl+z）的功能，即把上一个状态保存下来，以便迅速恢复。另一大用途就是RPG的存档~

  1.role类

  #!/usr/bin/python
  # Filename: role.py
  import memo
  class GameRole:
  	def __init__(self):
  		self.hp = 100
  		self.sp = 100
  	def Display(self):
  		print 'HP:' + str(self.hp)
  		print 'SP:' + str(self.sp)
  	def FightWithBoss(self):
  		self.hp = 0
  		self.sp = 0
  	def Save(self):
  		return memo.Copy(self.hp, self.sp)
  	def Load(self, copy):
  		self.hp = copy.hp
  		self.sp = copy.sp
  

  2.托管类

  #!/usr/bin/python
  # Filename: memo.py
  class Copy:
  	def __init__(self, hp, sp):
  		self.hp = hp
  		self.sp = sp
  class Save:
  	def __init__(self):
  		self.role = Copy()
  
  

  3.客户端

  #!/usr/bin/python
  # Filename: console.py
  import role
  abc = role.GameRole()
  abc.Display()
  #save before meeting the boss
  sav = abc.Save()
  sav.role = abc.Save()
  #see boss
  abc.FightWithBoss()
  abc.Display()
  #load~
  abc.Load(sav.role)
  abc.Display()
  

  (收起)

  2011-05-09 19:22:00   1人收藏   回应

  收藏

  推荐
• 

  面向对象真的很重要

  秦萌

  自从看了这本书，真的好喜欢这本书，它让我意思到软件编程的重要性，每天都有个念头要翻开看一点，这是其它的书都没有过的感觉。 (更多)

  自从看了这本书，真的好喜欢这本书，它让我意思到软件编程的重要性，每天都有个念头要翻开看一点，这是其它的书都没有过的感觉。 (收起)

  2011-08-20 00:00:52   回应

  收藏

  推荐

• 

  第1页

  slfire

  工厂模式的理解 所谓的工厂模式，难道就是用一个工厂类将那些子类实例化，然后再客户端只要调运工厂类就可以实现客户端的要求，并且客户端不会看到子类的调用，从而实现了代码的封装性！！ (更多)

  工厂模式的理解

  所谓的工厂模式，难道就是用一个工厂类将那些子类实例化，然后再客户端只要调运工厂类就可以实现客户端的要求，并且客户端不会看到子类的调用，从而实现了代码的封装性！！ (收起)

  2011-08-15 09:46:08   回应

  收藏

  推荐
• 

  第6页

  tom

  编程有一原则，就是用尽可能的办法去避免重复. (更多)

  编程有一原则，就是用尽可能的办法去避免重复. (收起)

  2011-07-25 20:47:31   回应

  收藏

  推荐
• 

  第16页

  onesuper (穷则独善其身，达则兼济姑娘)

  为了使各个运算符之间的耦合度达到最小，将运算符号（加减乘除）抽象成一个Operation类，然后在各个子类中分别实现GetResult方法。 为了不在主程序中用一个冗长的分支来实例化对象，需要使用简单工厂模式（像一个工厂一样制造出我们想要用的对象），其本质就是把分支写在一个factory类静态函数中。 /代码内容已省略/ 控制台代码 /代码内容已省略/ (更多)

  为了使各个运算符之间的耦合度达到最小，将运算符号（加减乘除）抽象成一个Operation类，然后在各个子类中分别实现GetResult方法。

  为了不在主程序中用一个冗长的分支来实例化对象，需要使用简单工厂模式（像一个工厂一样制造出我们想要用的对象），其本质就是把分支写在一个factory类静态函数中。

  #!/usr/bin/python
  # Filename: operation.py
  
  class Operation:
  	def __init__(self):
  		self.numberA = 0
  		self.numberB = 0
  	#implements GetResult in sublclass
  
  class OperationAdd(Operation):
  	def __init__(self):
  		Operation.__init__(self)
  	def GetResult(self):
  		result = self.numberA + self.numberB
  		return result
  
  class OperationSub(Operation):
  	def __init__(self):
  		Operation.__init__(self)		
  	def GetResult(self):
  		result = self.numberA - self.numberB
  		return result
  
  class OperationMul(Operation):
  	def __init__(self):
  		Operation.__init__(self)
  	def GetResult(self):
  		result = self.numberA * self.numberB
  		return result
  
  class OperationDiv(Operation):
  	def __init__(self):
  		Operation.__init__(self)
  	def GetResult(self):
  		try:
  			result = self.numberA / self.numberB
  			return result
  		except:
  			print 'divide by zero'
  
  class OperationFactory:
  	'''make out subclasses according to the
  	string given'''
  	@staticmethod
  	def createOperate(strOper):
  		if strOper == '+':    
  			oper = OperationAdd()   #create an instance of OperationAdd here
  			return oper
  		elif strOper == '-':
  			oper = OperationSub()
  			return oper
  		elif strOper == '*':
  			oper = OperationMul()
  			return oper
  		elif strOper == '/':
  			oper = OperationDiv()
  			return oper
  		else:
  			print 'the operation does not exist'
  

  控制台代码

  #!/usr/bin/python
  # Filename: simplefactory.py
  
  import operation
  import string
  
  numberA = raw_input('please input numberA\n')
  numberB = raw_input('please input numberB\n')
  strOper = raw_input('please input an operation\n')
  
  oper = operation.OperationFactory.createOperate(strOper)
  oper.numberA = string.atoi(numberA)
  oper.numberB = string.atoi(numberB)
  result = oper.GetResult()
  print 'the result is',result
  

  (收起)

  2011-04-18 19:49:08   回应

  收藏

  推荐

• 

  面向对象真的很重要

  秦萌

  自从看了这本书，真的好喜欢这本书，它让我意思到软件编程的重要性，每天都有个念头要翻开看一点，这是其它的书都没有过的感觉。 (更多)

  自从看了这本书，真的好喜欢这本书，它让我意思到软件编程的重要性，每天都有个念头要翻开看一点，这是其它的书都没有过的感觉。 (收起)

  2011-08-20 00:00:52   回应

  收藏

  推荐
• 

  第1页

  slfire

  工厂模式的理解 所谓的工厂模式，难道就是用一个工厂类将那些子类实例化，然后再客户端只要调运工厂类就可以实现客户端的要求，并且客户端不会看到子类的调用，从而实现了代码的封装性！！ (更多)

  工厂模式的理解

  所谓的工厂模式，难道就是用一个工厂类将那些子类实例化，然后再客户端只要调运工厂类就可以实现客户端的要求，并且客户端不会看到子类的调用，从而实现了代码的封装性！！ (收起)

  2011-08-15 09:46:08   回应

  收藏

  推荐
• 

  第6页

  tom

  编程有一原则，就是用尽可能的办法去避免重复. (更多)

  编程有一原则，就是用尽可能的办法去避免重复. (收起)

  2011-07-25 20:47:31   回应

  收藏

  推荐