六大设计原则：构建优雅、可维护和可扩展的软件

设计原则是在软件工程中用于指导和评估设计决策的基本准则。遵循这些原则有助于创建具有高内聚性、低耦合性和易于维护的软件系统。在本文中，我们将介绍六大常用的设计原则，分别是单一职责原则、开放封闭原则、里氏替换原则、依赖倒置原则、接口隔离原则和合成复用原则，并通过例子详细说明它们的应用和好处。

单一职责原则 (Single Responsibility Principle)

定义： 单一职责原则要求一个类应该只有一个引起变化的原因。换句话说，一个类应该只有一个职责。

应用场景： 单一职责原则有助于确保类的高内聚性，降低了修改一个类的复杂性。适用于将复杂类分解为更小、更易管理的部分。

示例： 一个日志类可以负责记录日志，但不应该负责处理配置。

class Logger {
    public void log(String message) {
        // 记录日志到文件
    }
}

class ConfigurationManager {
    public void loadConfig() {
        // 加载配置
    }

    public void saveConfig() {
        // 保存配置
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

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

定义： 开放封闭原则要求软件实体（类、模块、函数等）应该对扩展开放，但对修改封闭。也就是说，应该通过扩展现有代码来引入新功能，而不是修改现有代码。

应用场景： 开放封闭原则鼓励使用抽象、接口和多态来实现可扩展性，减少对现有代码的修改。适用于需求经常变化的系统。

示例： 使用抽象工厂模式来创建可扩展的图形用户界面。

interface Button {
    void click();
}

class WindowsButton implements Button {
    public void click() {
        System.out.println("Windows button clicked.");
    }
}

class MacButton implements Button {
    public void click() {
        System.out.println("Mac button clicked.");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

里氏替换原则 (Liskov Substitution Principle)

定义： 里氏替换原则要求子类能够替代其基类，而不会影响程序的正确性。也就是说，子类应该继承基类的行为，但可以扩展或修改该行为。

应用场景： 里氏替换原则有助于确保代码的一致性，可以通过继承和多态来实现。适用于创建抽象基类和具体子类。

示例： 使用里氏替换原则创建不同形状的图形。

class Shape {
    public void draw() {
        // 绘制图形
    }
}

class Circle extends Shape {
    public void draw() {
        // 绘制圆形
    }
}

class Rectangle extends Shape {
    public void draw() {
        // 绘制矩形
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

依赖倒置原则 (Dependency Inversion Principle)

定义： 依赖倒置原则要求高层模块不应该依赖于低层模块，二者都应该依赖于抽象。抽象不应该依赖于细节，细节应该依赖于抽象。

应用场景： 依赖倒置原则通过面向接口编程来实现松耦合，减少了模块之间的直接依赖。适用于使用接口、抽象类和依赖注入来实现。

示例： 使用依赖倒置原则创建通知系统，让发送者和接收者都依赖于通知接口。

interface Notification {
    void sendNotification(String message);
}

class EmailNotification implements Notification {
    public void sendNotification(String message) {
        // 发送电子邮件通知
    }
}

class SMSNotification implements Notification {
    public void sendNotification(String message) {
        // 发送短信通知
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

接口隔离原则 (Interface Segregation Principle)

定义： 接口隔离原则要求客户端不应该强制依赖它们不使用的接口。一个类不应该强制实现它不需要的接口。

应用场景： 接口隔离原则有助于避免庞大的接口，提高代码的可维护性和可读性

。适用于将大接口分解为多个小接口。

示例： 拆分大接口 Worker 为多个小接口，如 Worker、Eater 和 Sleeper。

interface Worker {
    void work();
    void eat();
    void sleep();
}

class Employee implements Worker {
    public void work() {
        // 员工工作
    }

    public void eat() {
        // 员工吃饭
    }

    public void sleep() {
        // 员工睡觉
    }
}

class Robot implements Worker {
    public void work() {
        // 机器人工作
    }

    public void eat() {
        // 机器人不需要吃饭
    }

    public void sleep() {
        // 机器人不需要睡觉
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

合成复用原则 (Composite Reuse Principle)

定义： 合成复用原则要求通过组合或聚合已有的类来实现新功能，而不是通过继承已有的类。

应用场景： 合成复用原则有助于减少继承的复杂性和耦合度，通过组合现有类来构建新功能。适用于创建可重用的模块。

示例： 使用合成复用原则创建一个通用的日志记录器，它可以记录到文件、数据库或控制台。

interface Logger {
    void log(String message);
}

class FileLogger implements Logger {
    public void log(String message) {
        // 记录日志到文件
    }
}

class DatabaseLogger implements Logger {
    public void log(String message) {
        // 记录日志到数据库
    }
}

class ConsoleLogger implements Logger {
    public void log(String message) {
        // 记录日志到控制台
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

这六大设计原则是构建高质量、可维护和可扩展软件的关键指导原则。通过理解和遵循这些原则，开发人员可以更轻松地创建健壮的软件系统。当这些原则结合在一起时，它们提供了一个强大的设计框架，有助于解决复杂的编程问题。

版权声明：
原创博主：牛哄哄的柯南
博主原文链接：https://keafmd.blog.csdn.net/
个人博客链接：https://www.keafmd.top/

看完如果对你有帮助，感谢点击下面的点赞支持！
[哈哈][抱拳]

加油！

共同努力！

Keafmd

感谢支持牛哄哄的柯南，期待你的三连+关注~~

keep accumulate for my dream【共勉】

                                                       ↓   ↓   ↓   ↓   ↓   ↓