💫单一职责原则 (Single Responsibility Principle, SRP)

定义：一个类应该只有一个引起变化的原因。
含义：每个类只负责完成一种功能。如果一个类承担了多种职责，则这些职责之间可能会互相影响，导致代码难以维护。
优点：
降低类的复杂性。
提高代码的可读性和可维护性。
更容易进行单元测试。
示例：

// 违反单一职责原则
public class ReportManager {
    public void GenerateReport() { /* 生成报表逻辑 */ }
    public void PrintReport() { /* 打印报表逻辑 */ }
}

// 符合单一职责原则
public class ReportGenerator {
    public void GenerateReport() { /* 生成报表逻辑 */ }
}
public class ReportPrinter {
    public void PrintReport() { /* 打印报表逻辑 */ }
}

💫开放-封闭原则 (Open-Closed Principle, OCP)

定义：软件实体（类、模块、函数等）应该对扩展开放，对修改封闭。
含义：在不修改原有代码的情况下，通过扩展功能满足新的需求。
优点：
减少因为修改代码引发的错误。
提升代码的灵活性和可扩展性。
示例：

// 违反开放-封闭原则
public class PaymentProcessor {
    public void ProcessPayment(string paymentType) {
        if (paymentType == "CreditCard") { /* 信用卡支付逻辑 */ }
        else if (paymentType == "PayPal") { /* PayPal 支付逻辑 */ }
    }
}

// 符合开放-封闭原则
public interface IPayment {
    void Process();
}
public class CreditCardPayment : IPayment {
    public void Process() { /* 信用卡支付逻辑 */ }
}
public class PayPalPayment : IPayment {
    public void Process() { /* PayPal 支付逻辑 */ }
}
public class PaymentProcessor {
    public void ProcessPayment(IPayment payment) {
        payment.Process();
    }
}

💫依赖倒转原则 (Dependency Inversion Principle, DIP)

定义：高层模块不应该依赖于低层模块，二者都应该依赖于抽象。抽象不应该依赖于细节，细节应该依赖于抽象。
含义：通过依赖接口或抽象类，减少模块之间的耦合。
优点：
提高代码的灵活性和可测试性。
减少模块之间的依赖。
示例：

// 违反依赖倒转原则
public class Keyboard {
    public void Type() { /* 输入逻辑 */ }
}
public class Computer {
    private Keyboard _keyboard = new Keyboard();
}

// 符合依赖倒转原则
public interface IInputDevice {
    void Type();
}
public class Keyboard : IInputDevice {
    public void Type() { /* 输入逻辑 */ }
}
public class Computer {
    private IInputDevice _inputDevice;
    public Computer(IInputDevice inputDevice) {
        _inputDevice = inputDevice;
    }
}

💫里氏代换原则 (Liskov Substitution Principle, LSP)

定义：子类应该能够替换基类，并且在应用中表现一致。
含义：确保子类不会破坏基类的功能。在实现继承时，子类必须能够正确替代父类。
优点：
保证系统的行为一致性。
避免因继承引入错误。
示例：

// 违反里氏代换原则
public class Rectangle {
    public virtual void SetWidth(int width) { }
    public virtual void SetHeight(int height) { }
}
public class Square : Rectangle {
    public override void SetWidth(int width) { /* 改变行为，导致宽高不一致 */ }
}

// 符合里氏代换原则
public abstract class Shape {
    public abstract int Area();
}
public class Rectangle : Shape {
    public int Width { get; set; }
    public int Height { get; set; }
    public override int Area() => Width * Height;
}
public class Square : Shape {
    public int Side { get; set; }
    public override int Area() => Side * Side;
}

💫迪米特原则 (Law of Demeter, LoD)

定义：一个对象应该对其他对象有最少的了解。
含义：尽量减少类之间的直接耦合，通过中间类或方法传递信息。
优点：
降低对象之间的耦合性。
提高代码的模块化。
示例：

// 违反迪米特原则
public class Engine {
    public void Start() { }
}
public class Car {
    public Engine Engine { get; set; }
}
public class Driver {
    public void Drive(Car car) {
        car.Engine.Start(); // Driver 直接访问 Engine
    }
}

// 符合迪米特原则
public class Engine {
    public void Start() { }
}
public class Car {
    private Engine _engine = new Engine();
    public void StartEngine() {
        _engine.Start();
    }
}
public class Driver {
    public void Drive(Car car) {
        car.StartEngine(); // Driver 通过 Car 访问 Engine
    }
}