场景
餐饮店的账单由多个部分组成，需要为每一桌客人计算账单总价。王叔叔要给这个店做一个结账系统，由于这很简单，于是他上来就设计一个类来计算总价，每计算一桌就新建一个对象。
小王觉得这个方案有问题，他就提出了几点想法：
- 每次计算都需要实例化，计算次数越多，创建的实例就越多。造成了效率低，内存占用高的结果
- 我们需要自己创建对象和销毁对象。
考虑到这些问题，小王重新设计一个类来计算总价，实例化这个类，每次都只使用同一个对象。
- 私有变量，引用对象实例
- 一个公共方法，实例化对象或者返回已有的对象
- 绕过静态构造函数机制。
以下是伪代码：
class CalculatePayment:
drink = None
meal = None
dessert = None
fruit = None
__payment_instance = None
def get_payment_instance(self):
if self.__payment_instance:
return self.__payment_instance
else:
payment = CalculatePayment()
self.__payment_instance = payment
def set_bill(self, drink, meal, dessert, fruit):
self.drink = drink
self.meal = meal
self.fruit = fruit
self.dessert = dessert
def _calculate_drink_bill(self):
if not self.drink:
return 0
drink_price_list = price_list['drink']
payment = drink_price_list[self.drink]
return payment
def _calculate_meal_bill(self):
if not self.meal:
return 0
meal_price_list = price_list['meal']
payment = meal_price_list[self.meal]
return payment
def _calculate_dessert_bill(self):
if not self.dessert:
return 0
dessert_price_list = price_list['dessert']
payment = dessert_price_list[self.dessert]
return payment
def _calculate_fruit_bill(self):
if not self.fruit:
return 0
fruit_price_list = price_list['fruit']
payment = fruit_price_list[self.fruit]
return payment
def total_payment(self):
fruit_payment = self._calculate_fruit_bill()
meal_payment = self._calculate_meal_bill()
drink_payment = self._calculate_drink_bill()
dessert_payment = self._calculate_dessert_bill()
return fruit_payment + meal_payment + drink_payment + dessert_payment
for bill in bill_list:
calculator = CalculatePayment.get_payment_instance()
calculator.set_bill(bill['drink'], bill['meal'], bill['fruit'], bill['dessert'])
bill['amount'] = calculator.total_payment()
总结
意图：希望对象只有一个实例，但没有控制对象实例化的的全局对象。还希望确保所有实体使用该对象相同的实例，而无需将引用传给它们。
问题：多个不同客户对象要引用同一个对象，希望这个对象的实例只有一个。
解决方案：确保只有一个实例。
好处：
- 一次实例化，多次使用
- 不用关心该对象是不是已经被实例化了，该对象自己负责。
- 不需要考虑对实例的销毁。
- 配合Adapter模式可以起到很好的效果
