1. 许多程序员对面向对象的思想都很了解，并且也能说得头头是道，但是在工作运用中却用的并不顺手。
当然，我也是其中之一。
不过最近我听了我们老师的讲课，对于面向对象的思想有了更深的理解，今天决定用一个实例跟大家分享一下。
欢迎各位前辈评论指正。
2.面向对象的三大特征：封装、继承、多态
六大原则： 开闭原则，单一职责，依赖倒置，组合复用，里氏替换，迪米特法则
3. 可是这三大特征和六大原则具体如何运用，又从哪里才能体现出我应用到了呢？
下面我就以一个游戏技能项目的代码实例，来讨论一下。
4. 首先，抛出题目：
写一个技能系统，具体技能效果如下：
降龙十八掌：1.伤害：造成100点伤害，2.眩晕：使对方眩晕3秒，3.降低防御：降低对方30点防御力，持续时间3,秒
六脉神剑： 1.伤害：造成90点伤害，2.震退：震退对方3丈以外， 3.减速：减速30，持续2秒
北冥神功： 1.伤害：造成99点伤害， 2.降低防御：降低对方20点防御力，持续时间2秒， 3 减速：减速20，持续2秒
可能有些朋友会说，这很简单，按照每个技能创建一个类就行了，这就是面向对象的思想嘛。事实上却是很错误的。
明眼人都能看到，每个技能虽有不同，但其效果都大同小异，如果每个技能创建一个类，就会产生大量的重复代码，
比如伤害这个效果，上面三个技能都有。
还有，若是项目经理告诉你，眩晕这个效果不行，改成在眩晕的同时，降低10点防御力，
那岂不是每个包含眩晕效果的技能，都要改一遍？
5.事实上，以面向对象思想编写以上代码的话，我们完全可以把每个效果提取出来，单独做成一个类，而每个技能含有多少效果，
在技能类的下面直接调用效果类就可以了。
6.废话不多说，直接上代码：
```
sikll_file = { ‘降龙十八掌‘: [‘DamageEffect(100)‘,‘DizzinessEffect(3)‘, ‘LowerDeffence(30,3)‘], ‘六脉神剑‘: [‘DamageEffect(90)‘, ‘Knockback(3)‘, ‘LowerSpeed(30, 2)‘], ‘北冥神功‘: [‘DamageEffect(99)‘, ‘LowerDeffence(20,2)‘, ‘LowerSpeed(20,2)‘] }
class SkillImpactEffect: """ 效果父类 作为父类，供技能调取，具体实现靠子类重写方法 """ def impact(self): raise NotImplementedError()
class DamageEffect(SkillImpactEffect): """ 效果：伤害 """ def __init__(self,value): self.value = value def impact(self): print(‘减少血量%d点‘%self.value)
class LowerDeffence(SkillImpactEffect): """ 效果：降低防御力 """ def __init__(self, value, time): self.value = value self.time = time def impact(self): print("降低%d防御力，持续%d秒"%(self.value, self.time))
class DizzinessEffect(SkillImpactEffect): """ 效果： 眩晕 """ def __init__(self, time): self.time = time def impact(self): print(‘眩晕%d秒‘% self.time)
class Knockback(SkillImpactEffect): """ 效果：震退 """ def __init__(self, value): self.value = value def impact(self): print(‘震退敌人到%d丈之外！‘)
class LowerSpeed(SkillImpactEffect): """ 效果：减速 """ def __init__(self, value, time): self.value = value self.time = time def impact(self): print(‘减速%d,持续时间%d‘ % (self.value, self.time))
class SkillDeployer: """ 技能释放器 """ # 生成技能（执行效果） def __init__(self,name): self.name = name # 加载配置文件{技能：[效果1，效果2.。。]} self.__dict_skill_config = self.load_config_file() # 创建效果对象 self.__effect_object = self.create_effect_objects() def load_config_file(self): # 加载技能文件。 return sikll_file
def create_effect_objects(self): # 根据name创建相应的技能对象 list_effect_name = self.__dict_skill_config[self.name] list_effect_object = [] for item in list_effect_name: # 效果对象，加入技能列表 effect_object = eval(item) list_effect_object.append(effect_object) return list_effect_object
def generate_skill(self): print(‘%s释放‘%self.name) for item in self.__effect_object: item.impact()
xlsbz = SkillDeployer(‘降龙十八掌‘)xlsbz.generate_skill()lmsj = SkillDeployer(‘六脉神剑‘)lmsj.generate_skill()bmsg = SkillDeployer(‘北冥神功‘)bmsg.generate_skill()
```
7.有了上面这种形式的代码，再也不怕项目经理随便改东西了，把skill_file作为一个静态文件，要添加技能的时候，只需在技能文件sikll_file里添加就可以了，完全不用改代码。
要修改增加效果，也只需把对应效果的类修改一下，操作十分简单。
8.接下来，分析一下以上代码的面向对象思想：
三大特征： 封装：将每种影响效果单独封装成类. 继承：将各种影响效果抽象为SkillImpactEffect 隔离技能释放器与各种影响效果的变化。 多态：各种影响效果在重写SkillImpactEffect类中impact方法. 释放器调用SkillImpactEffect执行各种效果。六大原则： 开闭原则：增加新(技能/影响效果)，不修改释放器代码. 单一职责：SkillImpactEffect 负责 隔离变化 DamageEffect.. 负责定义具体的效果 SkillDeployer 负责释放技能 依赖倒置：(1)释放器没有调用具体影响效果，而是调用SkillImpactEffect。 (2)抽象的不依赖于具体的。 具体做法： 释放器通过"依赖注入"(读取配置文件， 创建影响效果对象),使释放器不依赖具体影响效果. 组合复用：释放器与影响效果是组合关系. 可以灵活的选择各种影响效果。 里氏替换：(1)父类出现的地方可以被子类替换 释放器存储影响效果列表,实际可以将各种子类存入进来. 迪米特法则：所有类之间的耦合度都很低.
原文地址：https://www.cnblogs.com/jeffrey04118110/p/11770555.html