资深程序员揭秘：七个设计原则助你写出高质量代码，代码审查必备！

2023-01-26 00:16:42

七大设计原则：编写高品质代码的指导方针

在软件开发领域，遵循特定的设计原则至关重要，这些原则指导我们编写高品质代码，提升其可维护性和可扩展性。七大设计原则作为代码审查的基准，为我们提供了判断代码质量的标准。

单一职责原则

想象一下你的朋友莎拉，她是一位才华横溢的艺术家。莎拉能够创作出精美的油画，但同时也负责做饭、打扫卫生和其他家务。现在，当莎拉专注于绘画时，她可以尽情发挥她的创意，创造出杰作。然而，当她同时兼顾多种任务时，她的注意力就会分散，这可能会影响她艺术的质量。

单一职责原则与莎拉的情况类似。它指出每个类或函数应该只负责一个特定的任务。如果一个类负责多个任务，它就会变得难以维护和扩展。就像莎拉专注于绘画时创作出更好的艺术一样，代码模块也应该专注于执行特定的职责，以确保代码的清晰度和效率。

代码示例：

# 违反单一职责原则
class Employee:
    def calculate_salary(self):
        # 计算工资
    def print_details(self):
        # 打印员工详细信息

# 遵循单一职责原则
class SalaryCalculator:
    def calculate_salary(self):
        # 计算工资
class EmployeeDetailsPrinter:
    def print_details(self):
        # 打印员工详细信息

开闭原则

想象一下你的手机。你最近购买了一款新的手机，但是你希望将来能够添加新的功能，比如无线充电或指纹扫描。开闭原则就是在这个时候发挥作用。它规定软件应该对扩展开放，对修改关闭。

这意味着你可以通过添加新的代码来扩展软件的功能，而无需修改现有的代码。就像你的手机可以通过软件更新获得新功能一样，代码也可以通过添加新模块来扩展，而无需重写整个代码库。

代码示例：

# 违反开闭原则
class Shape:
    def draw(self):
        # 绘制形状

# 遵循开闭原则
class Shape:
    def draw(self):
        pass

class Circle(Shape):
    def draw(self):
        # 绘制圆形
class Square(Shape):
    def draw(self):
        # 绘制正方形

里氏替换原则

想象一下你的宠物狗史努比。史努比是一只非常聪明的狗，但它毕竟不是一只猫。如果我们希望史努比像猫一样爬树，我们会遇到问题，因为这只狗没有这个能力。

里氏替换原则也遵循类似的理念。它指出派生类应该能够替换其基类，而不会破坏程序的正确性。换句话说，派生类可以添加新的功能，但不能改变基类的行为。就像史努比永远无法像猫一样爬树一样，派生类也应该保持与基类一致的行为。

代码示例：

# 违反里氏替换原则
class Animal:
    def eat(self):
        # 吃东西

class Dog(Animal):
    def eat(self):
        # 吃狗粮

# 遵循里氏替换原则
class Animal:
    def eat(self):
        # 吃东西

class Dog(Animal):
    def eat(self):
        # 吃狗粮
    def bark(self):
        # 吠叫

依赖倒转原则

想象一下你的厨房。你有一台烤面包机，你需要它来烤面包。现在，如果烤面包机的插头只兼容特定的电源插座，你会遇到问题。为了让厨房更灵活，你应该使用一个适配器，让烤面包机可以连接到任何电源插座。

依赖倒转原则遵循类似的思路。它指出高层模块不应该依赖低层模块，两者的耦合应该通过抽象来实现。这样，当低层模块发生变化时，高层模块就不会受到影响。就像适配器使你的烤面包机能够连接到任何电源插座一样，抽象使高层代码能够独立于低层代码的变化。

代码示例：

# 违反依赖倒转原则
class HighLevelModule:
    def do_something(self, low_level_module):
        # 使用低层模块

# 遵循依赖倒转原则
class HighLevelModule:
    def do_something(self, abstraction):
        # 使用抽象

class Abstraction:
    def low_level_operation(self):
        # 执行低层操作

接口隔离原则

想象一下你的朋友玛丽是一个多才多艺的人。她会说多种语言，会弹钢琴，还会做美味的蛋糕。现在，如果你要求玛丽做一顿饭，她可能很容易做到。但是，如果你要求她用德语写一首诗，她可能会遇到困难，因为德语不是她的强项。

接口隔离原则与玛丽的情况类似。它指出一个接口应该只包含与它相关的操作。换句话说，一个接口不应该包含不相关的操作，否则会增加接口的复杂性。就像玛丽应该专注于她的语言技能和音乐天赋一样，接口也应该只包含相关的操作，以保持其清晰度和可管理性。

代码示例：

# 违反接口隔离原则
interface IAnimal {
    void eat();
    void run();
    void fly();
}

# 遵循接口隔离原则
interface IEater {
    void eat();
}

interface IRunner {
    void run();
}

interface IFlyer {
    void fly();
}

合成复用原则

想象一下你正在组装一辆自行车。你可以购买一辆预制的自行车，或者你可以自己组装一辆，使用不同的部件，比如车架、车轮、刹车等。合成复用原则提倡使用合成的方式来复用代码，而不是继承。

通过合成，你可以将不同的代码模块组合在一起，创建更复杂的功能。就像你可以通过组装不同的部件来创建一辆自行车一样，你也可以通过合成不同的代码模块来创建可重用的代码。

代码示例：

# 违反合成复用原则
class Bicycle:
    def __init__(self):
        self.frame = Frame()
        self.wheels = Wheels()
        self.brakes = Brakes()

# 遵循合成复用原则
class Bicycle:
    def __init__(self, frame, wheels, brakes):
        self.frame = frame
        self.wheels = wheels
        self.brakes = brakes

迪米特法则

想象一下你的朋友约翰正在组织一场聚会。约翰邀请了他的朋友玛丽和凯蒂，而玛丽又邀请了她的朋友苏珊。现在，如果苏珊想要知道聚会的地址，她应该直接询问约翰，而不是通过玛丽询问。

迪米特法则与苏珊的情况类似。它指出一个类或函数只应该与它直接相关的其他类或函数进行交互。换句话说，一个类或函数不应该访问它不必要的信息或方法。就像苏珊应该直接询问约翰聚会的地址一样，代码模块也应该只与它们直接相关的模块交互。

代码示例：

# 违反迪米特法则
class ClassA:
    def do_something(self, classB):
        # 使用类 B
        classB.do_something_else()

# 遵循迪米特法则
class ClassA:
    def do_something(self, classB):
        # 使用类 B 的接口
        classB.interface.do_something_else()