通过实施角色扮演游戏的课程来演示
目录
介绍
大多数现代编程语言都支持并鼓励面向对象编程（OOP）。虽然最近我们似乎看到了一点点偏离，因为人们开始使用不受OOP 严重影响的语言（例如Go，Rust，Elixir，Elm，Scala），大多数仍然有对象。我们将在此概述的设计原则也适用于非OOP语言。
为了成功编写清晰，高质量，可维护和可扩展的代码，您需要了解经过数十年经验证明自己有效的设计原则。
披露：我们将要进行的示例将使用Python。这方面的例子证明了一点，并且可能以其他明显的方式草率。
对象类型
由于我们将围绕对象建模代码，因此区分它们的不同职责和变体会很有用。
有三种类型的对象：
1.实体对象
该对象通常对应于问题空间中的一些现实世界实体。假设我们正在构建角色扮演游戏（RPG），实体对象将是我们的简单Hero类：
class Hero:
def __init__(self, health, mana):
self._health = health
self._mana = mana
def attack(self) -> int:
"""
Returns the attack damage of the Hero
"""
return 1
def take_damage(self, damage: int):
self._health -= damage
def is_alive(self):
return self._health > 0这些对象通常包含关于它们自身的属性（例如health或mana），并且可以通过某些规则进行修改。
2.控制对象
控制对象（有时也称为Manager对象）负责协调其他对象。这些是控制 和使用其他对象的对象。我们的RPG类比中的一个很好的例子就是这个Fight类，它控制着两个英雄并使它们战斗。
class Fight:
class FightOver(Exception):
def __init__(self, winner, *args, **kwargs):
self.winner = winner
super(*args, **kwargs)
def __init__(self, hero_a: Hero, hero_b: Hero):
self._hero_a = hero_a
self._hero_b = hero_b
self.fight_ongoing = True
self.winner = None
def fight(self):
while self.fight_ongoing:
self._run_round()
print(f'The fight has ended! Winner is #{self.winner}')
def _run_round(self):
try:
self._run_attack(self._hero_a, self._hero_b)
self._run_attack(self._hero_b, self._hero_a)
except self.FightOver as e:
self._finish_round(e.winner)
def _run_attack(self, attacker: Hero, victim: Hero):
damage = attacker.attack()
victim.take_damage(damage)
if not victim.is_alive():
raise self.FightOver(winner=attacker)
def _finish_round(self, winner: Hero):
self.winner = winner
self.fight_ongoing = False在这样的类中封装战斗的逻辑可以为您提供多种好处：其中之一是操作的简单可扩展性。只要它暴露相同的API，您就可以非常轻松地传入非玩家角色（NPC）类型以供英雄战斗。您还可以非常轻松地继承该类并覆盖某些功能以满足您的需求。
3.边界对象
这些是位于系统边界的对象。从另一个系统获取输入或产生输出的任何对象 - 无论该系统是用户，互联网还是数据库 - 都可以归类为边界对象。
class UserInput:
def __init__(self, input_parser):
self.input_parser = input_parser
def take_command(self):
"""
Takes the user's input, parses it into a recognizable command and returns it
"""
command = self._parse_input(self._take_input())
return command
def _parse_input(self, input):
return self.input_parser.parse(input)
def _take_input(self):
raise NotImplementedError()
class UserMouseInput(UserInput):
pass
class UserKeyboardInput(UserInput):
pass
class UserJoystickInput(UserInput):
pass这些边界对象负责将信息转换为我们的系统。在我们采用用户命令的示例中，我们需要边界对象将键盘输入（如空格键）转换为可识别的域事件（例如字符跳转）。
奖励：值对象
值对象表示域中的简单值。它们是不变的，没有身份。
如果我们将它们融入到我们的游戏中，那么一个Money或一个Damage类将非常适合。所述对象让我们可以轻松地区分，查找和调试相关功能，而使用原始类型（一个整数数组或一个整数）的天真方法则不然。
class Money:
def __init__(self, gold, silver, copper):
self.gold = gold
self.silver = silver
self.copper = copper
def __eq__(self, other):
return self.gold == other.gold and self.silver == other.silver and self.copper == other.copper
def __gt__(self, other):
if self.gold == other.gold and self.silver == other.silver:
return self.copper > other.copper
if self.gold == other.gold:
return self.silver > other.silver
return self.gold > other.gold
def __add__(self, other):
return Money(gold=self.gold + other.gold, silver=self.silver + other.silver, copper=self.copper + other.copper)
def __str__(self):
return f'Money Object(Gold: {self.gold}; Silver: {self.silver}; Copper: {self.copper})'
def __repr__(self):
return self.__str__()
print(Money(1, 1, 1) == Money(1, 1, 1))
# => True
print(Money(1, 1, 1) > Money(1, 2, 1))
# => False
print(Money(1, 1, 0) + Money(1, 1, 1))
# => Money Object(Gold: 2; Silver: 2; Copper: 1)它们可以归类为Entity 对象的子类别。
关键设计原则
设计原则是软件设计中的规则，多年来已被证明是有价值的。严格遵循它们将帮助您确保您的软件具有一流的质量。
抽象化
抽象是在某些情况下将概念简化为其基本要素的想法。它允许您通过将其简化为简化版本来更好地理解概念。
上面的例子说明了抽象 - 看看Fight类的结构。你使用它的方式尽可能简单 - 你在实例化中给它两个英雄作为参数并调用fight()方法。没有更多，没有更少。
代码中的抽象应该遵循最少的惊喜规则。你的抽象不应该让任何有不必要和不相关的行为/属性的人感到惊讶。换句话说 - 它应该是直观的。
请注意，我们的Hero#take_damage()功能不会出现意外情况，例如在死亡时删除我们的角色。但如果他的健康状况低于零，我们可以预期它会杀死我们的角色。
封装
封装可以被认为是将一些东西放在胶囊内 - 你限制它暴露在外面的世界。在软件中，限制对内部对象和属性的访问有助于数据完整性。
封装黑盒内部逻辑，使您的类更容易管理，因为您知道其他系统使用哪个部分，哪些不是。这意味着您可以轻松地修改内部逻辑，同时保留公共部分并确保您没有破坏任何内容。作为一种副作用，使用外部封装的功能变得更简单，因为您需要考虑的事情较少。
在大多数语言中，这是通过所谓的访问修饰符（私有，受保护等）来完成的。Python不是最好的例子，因为它缺少运行时内置的显式修饰符，但我们使用约定来解决这个问题。_变量/方法的前缀表示它们是私有的。
例如，假设我们改变我们的Fight#_run_attack方法以返回一个布尔变量，该变量指示战斗是否结束而不是引发异常。我们将知道我们可能已经破坏的唯一代码是在Fight类中，因为我们将该方法设为私有。
请记住，代码更改频繁而不是重新编写。能够以尽可能明显的影响更改代码是您希望作为开发人员的灵活性。
分解
分解是将对象分成多个单独的较小部分的动作。所述部件更易于理解，维护和编程。
想象一下，我们希望在我们的基础上加入更多RPG功能，如增益，库存，设备和角色属性Hero：
class Hero:
def __init__(self, health, mana):
self._health = health
self._mana = mana
self._strength = 0
self._agility = 0
self._stamina = 0
self.level = 0
self._items = {}
self._equipment = {}
self._item_capacity = 30
self.stamina_buff = None
self.agility_buff = None
self.strength_buff = None
self.buff_duration = -1
def level_up(self):
self.level += 1
self._stamina += 1
self._agility += 1
self._strength += 1
self._health += 5
def take_buff(self, stamina_increase, strength_increase, agility_increase):
self.stamina_buff = stamina_increase
self.agility_buff = agility_increase
self.strength_buff = strength_increase
self._stamina += stamina_increase
self._strength += strength_increase
self._agility += agility_increase
self.buff_duration = 10 # rounds
def pass_round(self):
if self.buff_duration > 0:
self.buff_duration -= 1
if self.buff_duration == 0: # Remove buff
self._stamina -= self.stamina_buff
self._strength -= self.strength_buff
self._agility -= self.agility_buff
self._health -= self.stamina_buff * 5
self.buff_duration = -1
self.stamina_buff = None
self.agility_buff = None
self.strength_buff = None
def attack(self) -> int:
"""
Returns the attack damage of the Hero
"""
return 1 + (self._agility * 0.2) + (self._strength * 0.2)
def take_damage(self, damage: int):
self._health -= damage
def is_alive(self):
return self._health > 0
def take_item(self, item: Item):
if self._item_capacity == 0:
raise Exception('No more free slots')
self._items[item.id] = item
self._item_capacity -= 1
def equip_item(self, item: Item):
if item.id not in self._items:
raise Exception('Item is not present in inventory!')
self._equipment[item.slot] = item
self._agility += item.agility
self._stamina += item.stamina
self._strength += item.strength
self._health += item.stamina * 5缺乏分解
我假设你可以告诉这段代码变得非常混乱。我们的Hero目标是同时做太多的东西，这个代码变得非常脆弱。
例如，一个耐力点值5健康。如果我们希望将来改变它以使其值得健康，我们需要在多个地方更改实施。
答案是将Hero对象分解为多个较小的对象，每个对象都包含一些功能。
更清洁的架构
from copy import deepcopy
class AttributeCalculator:
@staticmethod
def stamina_to_health(self, stamina):
return stamina * 6
@staticmethod
def agility_to_damage(self, agility):
return agility * 0.2
@staticmethod
def strength_to_damage(self, strength):
return strength * 0.2
class HeroInventory:
class FullInventoryException(Exception):
pass
def __init__(self, capacity):
self._equipment = {}
self._item_capacity = capacity
def store_item(self, item: Item):
if self._item_capacity < 0:
raise self.FullInventoryException()
self._equipment[item.id] = item
self._item_capacity -= 1
def has_item(self, item):
return item.id in self._equipment
class HeroAttributes:
def __init__(self, health, mana):
self.health = health
self.mana = mana
self.stamina = 0
self.strength = 0
self.agility = 0
self.damage = 1
def increase(self, stamina=0, agility=0, strength=0):
self.stamina += stamina
self.health += AttributeCalculator.stamina_to_health(stamina)
self.damage += AttributeCalculator.strength_to_damage(strength) + AttributeCalculator.agility_to_damage(agility)
self.agility += agility
self.strength += strength
def decrease(self, stamina=0, agility=0, strength=0):
self.stamina -= stamina
self.health -= AttributeCalculator.stamina_to_health(stamina)
self.damage -= AttributeCalculator.strength_to_damage(strength) + AttributeCalculator.agility_to_damage(agility)
self.agility -= agility
self.strength -= strength
class HeroEquipment:
def __init__(self, hero_attributes: HeroAttributes):
self.hero_attributes = hero_attributes
self._equipment = {}
def equip_item(self, item):
self._equipment[item.slot] = item
self.hero_attributes.increase(stamina=item.stamina, strength=item.strength, agility=item.agility)
class HeroBuff:
class Expired(Exception):
pass
def __init__(self, stamina, strength, agility, round_duration):
self.attributes = None
self.stamina = stamina
self.strength = strength
self.agility = agility
self.duration = round_duration
def with_attributes(self, hero_attributes: HeroAttributes):
buff = deepcopy(self)
buff.attributes = hero_attributes
return buff
def apply(self):
if self.attributes is None:
raise Exception()
self.attributes.increase(stamina=self.stamina, strength=self.strength, agility=self.agility)
def deapply(self):
self.attributes.decrease(stamina=self.stamina, strength=self.strength, agility=self.agility)
def pass_round(self):
self.duration -= 0
if self.has_expired():
self.deapply()
raise self.Expired()
def has_expired(self):
return self.duration == 0
class Hero:
def __init__(self, health, mana):
self.attributes = HeroAttributes(health, mana)
self.level = 0
self.inventory = HeroInventory(capacity=30)
self.equipment = HeroEquipment(self.attributes)
self.buff = None
def level_up(self):
self.level += 1
self.attributes.increase(1, 1, 1)
def attack(self) -> int:
"""
Returns the attack damage of the Hero
"""
return self.attributes.damage
def take_damage(self, damage: int):
self.attributes.health -= damage
def take_buff(self, buff: HeroBuff):
self.buff = buff.with_attributes(self.attributes)
self.buff.apply()
def pass_round(self):
if self.buff:
try:
self.buff.pass_round()
except HeroBuff.Expired:
self.buff = None
def is_alive(self):
return self.attributes.health > 0
def take_item(self, item: Item):
self.inventory.store_item(item)
def equip_item(self, item: Item):
if not self.inventory.has_item(item):
raise Exception('Item is not present in inventory!')
self.equipment.equip_item(item)现在，分解我们的英雄对象的功能集成到后HeroAttributes，HeroInventory，HeroEquipment和HeroBuff对象，添加未来的功能会更容易，更封装和更好的抽象。您可以告诉我们的代码更清晰，更清晰。
有三种类型的分解关系：
- association - 定义两个组件之间的松散关系。两个组件不相互依赖，但可以一起工作。
示例： Hero和一个Zone对象。
- 聚合 - 定义整体及其各部分之间的弱“has-a”关系。认为很弱，因为零件可以存在而不是整体。
示例： HeroInventory和Item。
A HeroInventory可以有许多Items，并且Item可以属于任何HeroInventory（例如交易项目）。
- 构成 - 一种强烈的“有一种”关系，其中整体和部分不能彼此存在。部件不能共享，因为整体取决于那些确切的部分。
示例： Hero和HeroAttributes。
这些是英雄的属性 - 你不能改变他们的主人。
泛化
泛化可能是最重要的设计原则 - 它是提取共享特征并将它们组合在一个地方的过程。我们所有人都知道函数和类继承的概念 - 两者都是一种泛化。
比较可能会让事情变得清晰：虽然抽象通过隐藏不必要的细节来降低复杂性，但泛化通过用单个构造替换执行类似功能的多个实体来降低复杂性。
# Two methods which share common characteristics
def take_physical_damage(self, physical_damage):
print(f'Took {physical_damage} physical damage')
self._health -= physical_damage
def take_spell_damage(self, spell_damage):
print(f'Took {spell_damage} spell damage')
self._health -= spell_damage
# vs.
# One generalized method
def take_damage(self, damage, is_physical=True):
damage_type = 'physical' if is_physical else 'spell'
print(f'Took {damage} {damage_type} damage')
self._health -= damage功能实例
class Entity:
def __init__(self):
raise Exception('Should not be initialized directly!')
def attack(self) -> int:
"""
Returns the attack damage of the Hero
"""
return self.attributes.damage
def take_damage(self, damage: int):
self.attributes.health -= damage
def is_alive(self):
return self.attributes.health > 0
class Hero(Entity):
pass
class NPC(Entity):
pass广义对象示例
在给定的示例中，我们将公共Hero和NPC 类的功能概括为一个名为的共同祖先Entity。这总是通过继承来实现的。
在这里，而不是我们NPC和Hero类实现所有的方法两次，违反了DRY原则，我们通过移动他们共同的功能集成到一个基类降低了复杂性。
作为预警 - 不要过度继承。许多有经验的人建议你喜欢组合而不是继承。
业余程序员经常滥用继承，可能是因为它是由于其简单性而首先掌握的OOP技术之一。
组成
组合是将多个对象组合成更复杂的对象的原则。实际上说 - 它创建对象的实例并使用它们的功能而不是直接继承它。
使用合成的对象可以称为复合对象。重要的是，这种复合比其对等的总和更简单。当将多个类组合成一个时，我们希望提高抽象级别并使对象更简单。
复合对象的API必须隐藏其内部组件以及它们之间的交互。想想一个机械时钟，它有三只手显示时间和一个旋钮进行设置 - 但内部包含许多移动和相互依赖的部分。
正如我所说，组合比继承更受欢迎，这意味着你应该努力将常用功能移动到一个单独的对象中，然后使用这些类 - 而不是将它存放在你继承的基类中。
让我们举例说明过度继承功能可能存在的问题：
我们刚刚为游戏添加了动作。
class Entity:
def __init__(self, x, y):
self.x = x
self.y = y
raise Exception('Should not be initialized directly!')
def attack(self) -> int:
"""
Returns the attack damage of the Hero
"""
return self.attributes.damage
def take_damage(self, damage: int):
self.attributes.health -= damage
def is_alive(self):
return self.attributes.health > 0
def move_left(self):
self.x -= 1
def move_right(self):
self.x += 1
class Hero(Entity):
pass
class NPC(Entity):
pass正如我们所知，不是复制代码，而是使用泛化将函数move_right和move_left函数放入Entity类中。
好的，现在如果我们想在游戏中引入坐骑怎么办？
一个很好的坐骑:)
坐骑也需要左右移动，但没有攻击能力。想一想 - 他们甚至可能没有健康！
我知道你的解决方案是什么：
只需将move逻辑移动到仅具有该功能的单独MoveableEntity或MoveableObject类中。然后Mount该类可以继承它。
那么，如果我们想要有健康却无法攻击的坐骑，我们该怎么办？更多分裂为子类？我希望你能看到我们的类层次结构如何开始变得复杂，即使我们的业务逻辑仍然非常简单。
一种更好的方法是将移动逻辑抽象为Movement类（或更好的名称），并在可能需要它的类中实例化它。这将很好地打包功能，并使其可以在不限于的各种对象中重复使用Entity。
万岁，作文！
批判性思维免责声明
尽管这些设计原则是通过数十年的经验形成的，但在盲目地将原则应用于代码之前，能够批判性思考仍然非常重要。
像所有事情一样，太多可能是一件坏事。有时原则可能会走得太远，你可能会对它们过于聪明，并最终得到一些实际上更难处理的东西。
作为一名工程师，您的主要特点是批判性地评估针对您的独特情况的最佳方法，而不是盲目地遵循和应用任意规则。
关注的凝聚，耦合和分离
凝聚
凝聚力代表了模块内部责任的清晰度，换句话说 - 复杂性。
如果你的班级执行一项任务而没有其他任务，或者有明确的目的 - 该班级具有很高的凝聚力。另一方面，如果它在做什么或者有多个目的有些不清楚 - 它具有低凝聚力。
你希望你的课程具有很高的凝聚力。他们应该只有一个责任，如果你抓住他们有更多 - 可能是分开它的时候了。
耦合
耦合捕获了连接不同类之间的复杂性。您希望您的类与其他类具有尽可能少的简单连接，以便您可以在将来的事件中交换它们（例如更改Web框架）。目标是松耦合。
在许多语言中，这是通过大量使用接口来实现的 - 它们抽象出处理逻辑的特定类，并表示任何类可以插入其中的适配器层。
关注点分离
关注点分离（SoC）是指软件系统必须分成不与功能重叠的部分。或者正如名称所说的那样 - 关注 - 关于能够解决问题的任何事物的一般术语 - 必须分成不同的地方。
网页就是一个很好的例子 - 它有三个层（信息，演示和行为）分为三个地方（分别是 HTML，CSS和JavaScript）。
如果你再看一下RPG的Hero例子，你会发现它在一开始就有很多顾虑（应用buff，计算攻击伤害，处理库存，装备物品，管理属性）。我们通过分解将这些问题分解为更具凝聚力的类，这些类抽象并封装了它们的细节。我们的Hero类现在充当复合对象，比以前简单得多。
结束语
对于如此小的代码，应用这些原则可能看起来过于复杂。事实上，您计划在未来开发和维护的任何软件项目都是必须的。编写这样的代码在开始时会有一些开销，但从长远来看会多次付出代价。
这些原则确保我们的系统更多：
- 可扩展：高内聚性使得更容易实现新模块而无需考虑不相关的功能。低耦合意味着新模块连接的东西较少，因此更容易实现。
- 可维护：低耦合确保一个模块的更改通常不会影响其他模块。高内聚性确保系统要求的变化将需要尽可能少地修改类。
- 可重复使用：高内聚性可确保模块的功能完整且定义明确。低耦合使模块较少依赖于系统的其余部分，从而更容易在其他软件中重复使用。
概要
我们首先介绍了一些基本的高级对象类型（实体，边界和控制）。
然后，我们学习了构造所述对象的关键原则（抽象，泛化，组合，分解和封装）。
为了跟进，我们引入了两个软件质量指标（耦合和内聚），并了解了应用所述原则的好处。
我希望本文对一些设计原则提供了有用的概述。如果您希望进一步了解这方面的知识，我建议您使用以下资源。
进一步阅读
设计模式：可重复使用的面向对象软件的元素 - 可以说是该领域最具影响力的书籍。在其示例（C ++ 98）中有点过时，但模式和想法仍然非常相关。
以测试为指导的不断发展的面向对象软件 - 一本伟大的书，通过一个项目来展示如何实际应用本文中概述的原则（以及更多）。
有效的软件设计 - 一个包含远远超过设计见解的顶级博客。
软件设计和架构专业化 - 一系列4个视频课程，在整个项目中为您提供有效的设计，涵盖所有四门课程。
如果这个概述对您有所帮助，请考虑给予它您认为应得的拍手数量，以便更多人可以偶然发现并从中获取价值。
原文：https://medium.freecodecamp.org/a-short-overview-of-object-oriented-software-design-c7aa0a622c83