Java编程中必知必会的五条SOLID原则(Java编程必备：深入理解SOLID五大原则)

原创

ithorizon 7个月前 (10-20) 阅读数 24 #后端开发

Java编程必备：深入领会SOLID五大原则

一、SOLID原则简介

在面向对象编程中，SOLID原则是一组用于指导软件设计和开发的五大原则。这些原则分别是：单一职责原则（Single Responsibility Principle）、开闭原则（Open/Closed Principle）、里氏替换原则（Liskov Substitution Principle）、接口隔离原则（Interface Segregation Principle）和依赖性倒置原则（Dependency Inversion Principle）。下面我们将详细探讨这五大原则。

二、单一职责原则（Single Responsibility Principle）

单一职责原则指的是一个类应该只负责一项职责。如果类需要承担多项职责，那么这些职责应该分离到不同的类中。这样做的好处是，每个类都可以自由变化，不会考虑到一个职责的变化而影响到其他职责。

例如，一个类同时负责数据存储和日志记录，当数据存储方案变化时，日志记录的逻辑也或许受到影响。以下是遵循单一职责原则的代码示例：


public class Journal {
    private List entries = new ArrayList<>();
    private static int count = 0;
    public void addEntry(String text) {
        entries.add(text);
        count++;
    }
    public void removeEntry(int index) {
        entries.remove(index);
        count--;
    }
}
public class JournalEntry {
    private int index;
    private String text;
    public JournalEntry(int index, String text) {
        this.index = index;
        this.text = text;
    }
}
public class FilePersistence {
    public void saveToFile(Journal journal, String filename) throws IOException {
        try (BufferedWriter writer = new BufferedWriter(new FileWriter(filename))) {
            for (String entry : journal.getEntries()) {
                writer.write(entry);
            }
        }
    }
}

三、开闭原则（Open/Closed Principle）

开闭原则指的是软件实体（类、模块、函数等）应该对扩展开放，对修改封闭。这意味着实体应该允许其功能通过添加新的代码来扩展，而不是通过修改已有代码来扩展。这样做可以降低代码的维护成本，节约代码的可复用性。

以下是一个遵循开闭原则的代码示例，其中使用了策略模式来扩展行为，而不是修改类：


public abstract class Strategy {
    public abstract void execute();
}
public class ConcreteStrategyA extends Strategy {
    @Override
    public void execute() {
        System.out.println("执行策略A");
    }
}
public class ConcreteStrategyB extends Strategy {
    @Override
    public void execute() {
        System.out.println("执行策略B");
    }
}
public class Context {
    private Strategy strategy;
    public Context(Strategy strategy) {
        this.strategy = strategy;
    }
    public void setStrategy(Strategy strategy) {
        this.strategy = strategy;
    }
    public void executeStrategy() {
        strategy.execute();
    }
}

四、里氏替换原则（Liskov Substitution Principle）

里氏替换原则是面向对象设计中的一个基本原则，它指出子类应该能够替换其基类，而不会影响到程序的正确性。这意味着任何使用基类的地方都可以替换为子类，而不需要修改原有代码。

以下是一个违反里氏替换原则的例子：


public class Rectangle {
    private int width;
    private int height;
    public Rectangle(int width, int height) {
        this.width = width;
        this.height = height;
    }
    public void setWidth(int width) {
        this.width = width;
    }
    public void setHeight(int height) {
        this.height = height;
    }
    public int getWidth() {
        return width;
    }
    public int getHeight() {
        return height;
    }
}
public class Square extends Rectangle {
    public Square(int size) {
        super(size, size);
    }
    @Override
    public void setWidth(int width) {
        super.setWidth(width);
        super.setHeight(width);
    }
    @Override
    public void setHeight(int height) {
        super.setHeight(height);
        super.setWidth(height);
    }
}

在这个例子中，Square类继承了Rectangle类，并重写了setWidth和setHeight方法。但是，如果使用Square类替换Rectangle类，将会造成预期外的行为，考虑到Square的宽度和高度总是相等的。这违反了里氏替换原则。

五、接口隔离原则（Interface Segregation Principle）

接口隔离原则指出，多个特定客户端接口要好于一个宽泛用途的接口。这意味着接口应该足够小，客户端不应该被迫依赖性于它们不需要的接口。这样做可以降低系统间的依赖性，节约系统的灵活性和可维护性。

以下是一个违反接口隔离原则的例子：


public interface Machine {
    void start();
    void stop();
    void print();
    void fax();
    void scan();
}
public class MultiFunctionDevice implements Machine {
    public void start() {
        // 实现开机逻辑
    }
    public void stop() {
        // 实现关机逻辑
    }
    public void print() {
        // 实现打印逻辑
    }
    public void fax() {
        // 实现传真逻辑
    }
    public void scan() {
        // 实现扫描逻辑
    }
}

在这个例子中，Machine接口包含了许多方法，但是并不是所有的设备都需要实现这些方法。例如，一个明了的打印机或许只需要实现start、stop和print方法。如果强制所有的设备实现Machine接口，就会造成不必要的依赖性和冗余实现。

六、依赖性倒置原则（Dependency Inversion Principle）

依赖性倒置原则指出，高层模块不应该依赖性于低层模块，两者都应该依赖性于抽象。抽象不应该依赖性于细节，细节应该依赖性于抽象。这样做可以降低模块间的耦合，节约系统的灵活性和可维护性。

以下是一个遵循依赖性倒置原则的代码示例：


public interface Service {
    void operate();
}
public class ConcreteServiceA implements Service {
    @Override
    public void operate() {
        System.out.println("服务A的操作");
    }
}
public class ConcreteServiceB implements Service {
    @Override
    public void operate() {
        System.out.println("服务B的操作");
    }
}
public class HighLevelModule {
    private Service service;
    public HighLevelModule(Service service) {
        this.service = service;
    }
    public void performAction() {
        service.operate();
    }
}