SOLID设计原则

最新推荐文章于 2026-01-01 15:45:23 发布

原创最新推荐文章于 2026-01-01 15:45:23 发布 · 985 阅读

CC 4.0 BY-SA版权

文章标签：

SOLID 设计原则是面向对象编程和设计的五项基本原则，由罗伯特·C·马丁（Robert C. Martin）提出，这五项原则分别是单一职责原则（SRP）、开闭原则（OCP）、里氏替换原则（LSP）、接口隔离原则（ISP）和依赖倒置原则（DIP）。下面为你详细介绍：

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

描述：一个类应该只有一个引起它变化的原因。也就是说，一个类应该只负责一项职责。
类比：就像医院里的医生，每个医生只负责一个特定的科室，如眼科医生只看眼科疾病，骨科医生只处理骨科问题。
解决的问题：避免一个类承担过多职责，导致代码的复杂性增加，维护困难。如果一个类承担了多个职责，当其中一个职责发生变化时，可能会影响到其他职责的正常运行。
案例：设计一个 User 类，该类只负责用户信息的管理，如用户的姓名、年龄等。
Java 代码示例：

// 单一职责原则示例
class User {
    private String name;
    private int age;

    public User(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

开闭原则（Open-Closed Principle, OCP）

描述：软件实体（类、模块、函数等）应该对扩展开放，对修改关闭。即当需要添加新功能时，应该通过扩展现有代码来实现，而不是修改已有的代码。
类比：像手机的接口，我们可以通过外接不同的设备（如耳机、充电器等）来扩展手机的功能，而不需要对手机本身进行修改。
解决的问题：提高代码的可维护性和可扩展性，减少因修改代码而引入的风险。
案例：设计一个图形绘制程序，有一个 Shape 抽象类和具体的图形类（如 Circle、Rectangle），通过扩展 Shape 类来添加新的图形，而不需要修改原有的代码。
Java 代码示例：

// 开闭原则示例
abstract class Shape {
    abstract double area();
}

class Circle extends Shape {
    private double radius;

    public Circle(double radius) {
        this.radius = radius;
    }

    @Override
    double area() {
        return Math.PI * radius * radius;
    }
}

class Rectangle extends Shape {
    private double width;
    private double height;

    public Rectangle(double width, double height) {
        this.width = width;
        this.height = height;
    }

    @Override
    double area() {
        return width * height;
    }
}

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

描述：子类可以替换其父类并且出现在父类能够出现的任何地方，而不会影响程序的正确性。也就是说，子类应该能够完全替代父类，并且不会改变程序的行为。
类比：正方形是长方形的一种特殊情况，在任何需要长方形的地方，都可以用正方形来替代，而不会影响整体的布局。
解决的问题：确保子类的行为符合父类的预期，提高代码的可复用性和可维护性。
案例：设计一个 Bird 类和其子类 Sparrow、Ostrich，Sparrow 可以继承 Bird 的飞行方法，而 Ostrich 虽然是 Bird 的子类，但它不能飞行，需要重写飞行方法。
Java 代码示例：

// 里氏替换原则示例
class Bird {
    public void fly() {
        System.out.println("I can fly");
    }
}

class Sparrow extends Bird {
    @Override
    public void fly() {
        System.out.println("Sparrow can fly");
    }
}

class Ostrich extends Bird {
    @Override
    public void fly() {
        System.out.println("Ostrich can't fly");
    }
}

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

描述：客户端不应该依赖它不需要的接口。一个类对另一个类的依赖应该建立在最小的接口上。
类比：去餐厅点菜，我们只需要关注我们想吃的菜，而不需要关注餐厅所有的菜品。
解决的问题：避免接口过于庞大，导致客户端依赖了一些不必要的方法，增加了代码的耦合度。
案例：设计一个 Worker 接口，将不同的工作职能拆分成多个小接口，如 Coder 接口、Tester 接口，让不同的类实现不同的接口。
Java 代码示例：

// 接口隔离原则示例
interface Coder {
    void code();
}

interface Tester {
    void test();
}

class Programmer implements Coder {
    @Override
    public void code() {
        System.out.println("Coding...");
    }
}

class QualityAssurance implements Tester {
    @Override
    public void test() {
        System.out.println("Testing...");
    }
}

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

描述：高层模块不应该依赖低层模块，两者都应该依赖抽象。抽象不应该依赖细节，细节应该依赖抽象。
类比：我们使用手机时，只需要关注手机的接口和功能，而不需要关注手机内部的具体实现。
解决的问题：降低代码的耦合度，提高代码的可维护性和可扩展性。
案例：设计一个 Computer 类和 CPU、Memory 等组件类，Computer 类依赖于 CPU 和 Memory 的抽象接口，而不是具体的实现类。
Java 代码示例：

// 依赖倒置原则示例
interface CPU {
    void process();
}

interface Memory {
    void store();
}

class IntelCPU implements CPU {
    @Override
    public void process() {
        System.out.println("Intel CPU is processing");
    }
}

class SamsungMemory implements Memory {
    @Override
    public void store() {
        System.out.println("Samsung Memory is storing");
    }
}

class Computer {
    private CPU cpu;
    private Memory memory;

    public Computer(CPU cpu, Memory memory) {
        this.cpu = cpu;
        this.memory = memory;
    }

    public void work() {
        cpu.process();
        memory.store();
    }
}