设计原则Python

设计原则

开闭原则（目标、总的指导思想）

Open Closed Principle

对扩展开放，对修改关闭。

增加新功能，不改变原有代码。

类的单一职责（一个类的定义）

Single Responsibility Principle

一个类有且只有一个改变它的原因。

依赖倒置（依赖抽象）

Dependency Inversion Principle

客户端代码(调用的类)尽量依赖(使用)抽象的组件。

抽象的是稳定的。实现是多变的。

组合复用原则（复用）

Composite Reuse Principle

如果仅仅为了代码复用优先选择组合复用，而非继承复用。

继承的方法是父亲与儿子有关系，是两种相似类型

组合的方法是用另一个类中的某些方法，但两者关系不大，更灵活

组合的耦合性相对继承低。

里氏替换（继承后的重写，指导继承的设计）

Liskov Substitution Principle

父类出现的地方可以被子类替换，在替换后依然保持原功能。

子类要拥有父类的所有功能。

子类在重写父类方法时，尽量选择扩展重写，防止改变了功能。

迪米特法则（类与类交互的原则）

Law of Demeter

不要和陌生人说话。

类与类交互时，在满足功能要求的基础上，传递的数据量越少越好。因为这样可能降低耦合度。

类与类的关系

泛化：子类与父类的关系，概念的复用，耦合度最高；

B类泛化A类，意味B类是A类的一种；

做法：B类继承A类

关联(聚合/组合)：部分与整体的关系，功能的复用，变化影响一个类；

A与B关联，意味着B是A的一部分；

做法：在A类中包含B类型成员。

依赖：合作关系，一种相对松散的协作，变化影响一个方法；

A类依赖B类，意味A类的某些功能靠B类实现；

做法：B类型作为A类中方法的参数，并不是A的成员。

父亲类一定是高度抽象的，所有子类都能符合，只要有一点特殊化的方法就需要在子类中构建

 设计原则
            开闭原则：允许增加新功能，不允许修改客户端代码.
            单一职责：一个有且只有一个改变的原因.
            依赖倒置：调用抽象(父)，不要调用具体(子);
                    抽象不要依赖具体.
            组合复用：如果仅仅是代码的复用，优先使用组合.

 类与类关系
            泛化[继承](做成爸爸)
            关联(做成成员变量)
            依赖(做成方法参数)

实例

"""
    技能系统
    练习:指出下列代码哪里体现了三大特征/六大原则。

    三大特征：
        封装：将每种影响效果单独做成类.
        继承：将各种影响效果抽象为SkillImpactEffect
              隔离技能释放器与各种影响效果的变化。
        多态：各种影响效果在重写SkillImpactEffect类中impact方法.
             释放器调用SkillImpactEffect执行各种效果。
    六大原则：
        开闭原则：增加新(技能/影响效果)，不修改释放器代码.
        单一职责：SkillImpactEffect 负责 隔离变化
                 DamageEffect.. 负责定义具体的效果
                 SkillDeployer 负责释放技能
        依赖倒置：(1)释放器没有调用具体影响效果，而是调用SkillImpactEffect。
                (2)抽象的不依赖于具体的。
                  具体做法：释放器通过"依赖注入"(读取配置文件，用eval方法创建影响效果对象),
                          使释放器不依赖具体影响效果.
        组合复用：释放器与影响效果是组合关系.
                可以灵活的选择各种影响效果。
        里氏替换：(1)父类出现的地方可以被子类替换
                 释放器存储影响效果列表,实际可以将各种子类存入进来.
        迪米特法则：所有类之间的耦合度都很低.
"""


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 LowerDeffenseEffect(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 SkillDeployer:
    """
        技能释放器
    """

    def __init__(self, name):
        self.name = name
        # 加载配置文件 {技能名称:[效果1,效果2...],...}
        self.__dict_skill_config = self.__load_config_file()
        # 创建效果对象
        self.__effect_objects = self.__create_effect_objects()

    def __load_config_file(self):
        # 加载文件.....
        return {
            "降龙十八掌": ["DamageEffect(200)", "LowerDeffenseEffect(-10,5)", "DizzinessEffect(6)"],
            "六脉神剑": ["DamageEffect(100)", "DizzinessEffect(6)"]
        }

    def __create_effect_objects(self):
        # 根据name创建相应的技能对象
        #    降龙十八掌 -> ["技能1"，"技能2"]
        list_effect_name = self.__dict_skill_config[self.name]
        list_effect_object = []
        for item in list_effect_name:
            # "技能1" --> 技能1的对象
            # 对象 = eval("DamageEffect(200)")
            effect_object = eval(item)
            list_effect_object.append(effect_object)
        return list_effect_object

    # 生成技能(执行效果)
    def generate_skill(self):
        print(self.name, "技能释放啦")
        for item in self.__effect_objects:
            # 调用父类，执行子类.
            item.impact()


xlsbz = SkillDeployer("降龙十八掌")
xlsbz.generate_skill()

lmsj = SkillDeployer("六脉神剑")
lmsj.generate_skill()

输出结果：

降龙十八掌 技能释放啦
扣你200血
降低-10防御力,持续5秒
眩晕6秒
六脉神剑 技能释放啦
扣你100血
眩晕6秒