编辑“︁设计模式原则”︁（章节）

== SOLID原则 ==

SOLID是五个重要设计原则的首字母缩写：

=== 单一职责原则（Single Responsibility Principle, SRP） ===
一个类应该只有一个引起它变化的原因，即一个类只负责一项职责。

<syntaxhighlight lang="java">
// 违反SRP的例子
class User {
    void login() { /* 登录逻辑 */ }
    void sendEmail() { /* 发送邮件逻辑 */ }
}

// 遵循SRP的改进
class User {
    void login() { /* 登录逻辑 */ }
}

class EmailService {
    void sendEmail() { /* 发送邮件逻辑 */ }
}
</syntaxhighlight>

=== 开闭原则（Open-Closed Principle, OCP） ===
软件实体（类、模块、函数等）应该对扩展开放，对修改关闭。

<syntaxhighlight lang="java">
// 违反OCP的例子
class Shape {
    String type;
    
    void draw() {
        if (type.equals("circle")) {
            drawCircle();
        } else if (type.equals("square")) {
            drawSquare();
        }
    }
}

// 遵循OCP的改进
interface Shape {
    void draw();
}

class Circle implements Shape {
    void draw() { /* 画圆 */ }
}

class Square implements Shape {
    void draw() { /* 画方形 */ }
}
</syntaxhighlight>

=== 里氏替换原则（Liskov Substitution Principle, LSP） ===
子类必须能够替换它们的基类而不引起程序错误。

<syntaxhighlight lang="java">
// 违反LSP的例子
class Bird {
    void fly() { /* 飞行 */ }
}

class Penguin extends Bird {
    void fly() {
        throw new UnsupportedOperationException("企鹅不会飞！");
    }
}

// 遵循LSP的改进
interface Bird {
    void move();
}

class FlyingBird implements Bird {
    void move() { fly(); }
    void fly() { /* 飞行 */ }
}

class Penguin implements Bird {
    void move() { swim(); }
    void swim() { /* 游泳 */ }
}
</syntaxhighlight>

=== 接口隔离原则（Interface Segregation Principle, ISP） ===
客户端不应该被迫依赖它们不使用的接口。

<syntaxhighlight lang="java">
// 违反ISP的例子
interface Worker {
    void work();
    void eat();
}

class Human implements Worker {
    void work() { /* 工作 */ }
    void eat() { /* 吃饭 */ }
}

class Robot implements Worker {
    void work() { /* 工作 */ }
    void eat() { throw new UnsupportedOperationException(); }
}

// 遵循ISP的改进
interface Workable {
    void work();
}

interface Eatable {
    void eat();
}

class Human implements Workable, Eatable {
    void work() { /* 工作 */ }
    void eat() { /* 吃饭 */ }
}

class Robot implements Workable {
    void work() { /* 工作 */ }
}
</syntaxhighlight>

=== 依赖倒置原则（Dependency Inversion Principle, DIP） ===
高层模块不应该依赖低层模块，二者都应该依赖抽象。

<syntaxhighlight lang="java">
// 违反DIP的例子
class LightBulb {
    void turnOn() { /* 开灯 */ }
}

class Switch {
    private LightBulb bulb;
    
    void operate() {
        bulb.turnOn();
    }
}

// 遵循DIP的改进
interface Switchable {
    void turnOn();
}

class LightBulb implements Switchable {
    void turnOn() { /* 开灯 */ }
}

class Switch {
    private Switchable device;
    
    void operate() {
        device.turnOn();
    }
}
</syntaxhighlight>