SOLID原则：让你的代码更优雅，更易维护_solid原则优化代码-优快云博客

SOLID 原则是面向对象编程的五个设计原则的集合，用来指导程序员编写可维护、可扩展和灵活的代码。这些原则由 Robert C. Martin（Uncle Bob） 提出，是优秀软件设计的重要基础。

1. 单一职责原则（Single Responsibility Principle, SRP）

定义：一个类应该只有一个引起它变化的原因。
解释：每个类都应该只专注于一项职责。如果一个类承担了多个职责，就可能在其中一个职责发生变化时影响到其他职责。
好处：
- 降低耦合性，增强可读性和可维护性。
- 简化测试，因为每个类的行为更加单一。

示例：

class ReportGenerator {
    public void generateReport() {
        // 生成报告的逻辑
    }
}

class ReportPrinter {
    public void printReport() {
        // 打印报告的逻辑
    }
}

2. 开放封闭原则（Open/Closed Principle, OCP）

定义：软件实体（类、模块、函数等）应该对扩展开放，对修改封闭。
解释：当需求变化时，应该通过扩展已有的代码（新增功能）来实现，而不是修改已有代码。
好处：
- 减少对现有代码的风险，提高系统稳定性。
- 易于扩展和适应变化。

示例：

interface Shape {
    double calculateArea();
}

class Circle implements Shape {
    private double radius;
    public Circle(double radius) { this.radius = radius; }
    public double calculateArea() { return Math.PI * radius * radius; }
}

class Rectangle implements Shape {
    private double length, width;
    public Rectangle(double length, double width) { this.length = length; this.width = width; }
    public double calculateArea() { return length * width; }
}

class AreaCalculator {
    public double calculateTotalArea(List<Shape> shapes) {
        return shapes.stream().mapToDouble(Shape::calculateArea).sum();
    }
}

3. 里氏替换原则（Liskov Substitution Principle, LSP）

定义：子类对象必须能够替代父类对象，并确保程序的行为不变。
解释：子类在扩展父类时，不能破坏父类原有的功能或约定。
好处：
- 提高代码的复用性和扩展性。
- 防止继承滥用。

示例：

class Bird {
    public void fly() {
        System.out.println("I can fly");
    }
}

class Ostrich extends Bird {
    @Override
    public void fly() {
        throw new UnsupportedOperationException("Ostrich can't fly");
    }
}

问题：Ostrich 不能完全替代 Bird，违反了里氏替换原则。

改进：

interface Bird {
    void move();
}

class FlyingBird implements Bird {
    public void move() {
        System.out.println("I can fly");
    }
}

class Ostrich implements Bird {
    public void move() {
        System.out.println("I can run");
    }
}

4. 接口隔离原则（Interface Segregation Principle, ISP）

定义：不应该强迫一个类去实现它用不到的接口。
解释：将大接口拆分为多个小接口，使得类只需依赖它实际需要的接口。
好处：
- 减少类与接口的耦合，避免“胖接口”。
- 提高代码灵活性和可维护性。

示例：

interface Printer {
    void print();
}

interface Scanner {
    void scan();
}

class MultiFunctionPrinter implements Printer, Scanner {
    public void print() { System.out.println("Printing..."); }
    public void scan() { System.out.println("Scanning..."); }
}

class SimplePrinter implements Printer {
    public void print() { System.out.println("Printing..."); }
}

5. 依赖倒置原则（Dependency Inversion Principle, DIP）

定义：高层模块不应该依赖于低层模块，两者都应该依赖于抽象；抽象不应该依赖于细节，细节应该依赖于抽象。
解释：通过依赖抽象（接口或抽象类），降低模块之间的耦合。
好处：
- 提高代码的灵活性和可扩展性。
- 减少代码的耦合，方便进行模块替换。

示例：

interface NotificationService {
    void send(String message);
}

class EmailNotificationService implements NotificationService {
    public void send(String message) {
        System.out.println("Sending email: " + message);
    }
}

class SMSNotificationService implements NotificationService {
    public void send(String message) {
        System.out.println("Sending SMS: " + message);
    }
}

class NotificationManager {
    private final NotificationService notificationService;

    public NotificationManager(NotificationService notificationService) {
        this.notificationService = notificationService;
    }

    public void notify(String message) {
        notificationService.send(message);
    }
}