软件开发中的 DRY、KISS 和 SOLID 原则

程序浅谈后端 2024-07-21

软件开发中的 DRY、KISS 和 SOLID 原则

DRY (Don't Repeat Yourself)

含义: "不要重复自己"
解释: 每一piece of knowledge在系统中应该只有一个明确的、权威的表示。
目的: 减少重复代码,提高可维护性。
示例: 使用函数或类来封装重复使用的代码逻辑。

代码示例python

 代码解读
复制代码
# DRY (Don't Repeat Yourself) 原则示例

# 违反DRY原则的代码
def get_area_circle(radius):
    return 3.14 * radius * radius

def get_area_cylinder(radius, height):
    return 2 * 3.14 * radius * height + 2 * 3.14 * radius * radius

# 遵循DRY原则的代码
import math

def get_circle_area(radius):
    return math.pi * radius ** 2

def get_cylinder_area(radius, height):
    circle_area = get_circle_area(radius)
    return 2 * math.pi * radius * height + 2 * circle_area

KISS (Keep It Simple, Stupid)

含义: "保持简单,傻瓜"
解释: 系统应该尽可能简单,避免不必要的复杂性。
目的: 提高代码可读性和可维护性,减少错误。
示例: 使用清晰、直接的代码实现,而不是过度设计的复杂解决方案。

代码示例python

 代码解读
复制代码
# 违反KISS原则的代码
def is_even(num):
    if num % 2 == 0:
        return True
    else:
        return False

# 遵循KISS原则的代码
def is_even(num):
    return num % 2 == 0

SOLID

SOLID 是面向对象编程和设计的五个基本原则的首字母缩写:

S - 单一职责原则 (Single Responsibility Principle)
- 一个类应该只有一个引起它变化的原因。
- 目的: 提高内聚性,降低耦合度。
O - 开放封闭原则 (Open-Closed Principle)
- 软件实体应该对扩展开放,对修改关闭。
- 目的: 增加新功能时不影响现有代码。
L - 里氏替换原则 (Liskov Substitution Principle)
- 子类型必须能够替换它们的基类型。
- 目的: 确保继承正确使用,维护系统的一致性。
I - 接口隔离原则 (Interface Segregation Principle)
- 客户端不应该依赖它不使用的接口。
- 目的: 避免"胖"接口,提高代码的灵活性和可维护性。
D - 依赖倒置原则 (Dependency Inversion Principle)
- 高层模块不应该依赖低层模块,两者都应该依赖于抽象。
- 目的: 降低模块间的耦合度,提高系统的灵活性。

SOLID 原则示例python

 代码解读
复制代码
# 单一职责原则 (SRP)
class Report:
    def generate_report(self, data):
        # 生成报告逻辑
        pass

class ReportPrinter:
    def print_report(self, report):
        # 打印报告逻辑
        pass

# 开放封闭原则 (OCP)
from abc import ABC, abstractmethod

class Shape(ABC):
    @abstractmethod
    def area(self):
        pass

class Rectangle(Shape):
    def __init__(self, width, height):
        self.width = width
        self.height = height

    def area(self):
        return self.width * self.height

class Circle(Shape):
    def __init__(self, radius):
        self.radius = radius

    def area(self):
        return math.pi * self.radius ** 2

# 里氏替换原则 (LSP)
class Bird:
    def fly(self):
        pass

class Sparrow(Bird):
    def fly(self):
        print("Sparrow flying")

class Ostrich(Bird):
    def fly(self):
        raise NotImplementedError("Ostriches can't fly")

# 更好的设计
class Bird:
    pass

class FlyingBird(Bird):
    def fly(self):
        pass

class Sparrow(FlyingBird):
    def fly(self):
        print("Sparrow flying")

class Ostrich(Bird):
    pass

# 接口隔离原则 (ISP)
from abc import ABC, abstractmethod

class Printer(ABC):
    @abstractmethod
    def print(self, document):
        pass

class Scanner(ABC):
    @abstractmethod
    def scan(self, document):
        pass

class ModernPrinter(Printer, Scanner):
    def print(self, document):
        print("Printing:", document)

    def scan(self, document):
        print("Scanning:", document)

# 依赖倒置原则 (DIP)
class LightBulb:
    def turn_on(self):
        print("LightBulb: turned on")

    def turn_off(self):
        print("LightBulb: turned off")

class ElectricPowerSwitch:
    def __init__(self, device):
        self.device = device
        self.on = False

    def press(self):
        if self.on:
            self.device.turn_off()
            self.on = False
        else:
            self.device.turn_on()
            self.on = True

# 使用
bulb = LightBulb()
switch = ElectricPowerSwitch(bulb)
switch.press()
switch.press()