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)父类出现的地方可以被子类替换
释放器存储影响效果列表,实际可以将各种子类存入进来.
迪米特法则：所有类之间的耦合度都很低.
