SOLID Principles in Java

2025年7月21日 | 阅读 12 分钟

在 Java 中，SOLID 原则代表了应用于软件结构设计的一种面向对象的方法。由 Robert C. Martin（也称为 Uncle Bob）构思的这五项原则彻底改变了面向对象编程的世界，并改变了软件的编写方式。

通过遵循 SOLID 原则，开发人员可以确保他们的软件是模块化的、易于理解、调试和重构的。SOLID 原则不仅提高了代码质量，还促进了更好的维护和可扩展性，最终实现了更健壮、更高效的软件系统。

SOLID 首字母缩写代表

单一职责原则 (SRP)
开闭原则 (OCP)
里氏替换原则 (LSP)
接口隔离原则 (ISP)
依赖倒置原则 (DIP)

下面我们逐一详细解释这些原则。

单一职责原则

单一职责原则指出，每个 Java 类都必须执行一个单一的功能。在一个类中实现多个功能会使代码混乱，如果需要进行任何修改，可能会影响整个类。它精简了代码，代码更容易维护。让我们通过一个例子来理解单一职责原则。

假设 Main 是一个类，它有三个方法：printDetails()、calculatePercentage() 和 addStudent()。因此，Main 类有三个职责：打印学生详细信息、计算百分比和数据库操作。通过使用单一职责原则，我们可以将这些功能分离到三个单独的类中，以实现该原则的目标。

示例

public class Main {
    // Method to print details
    public void printDetails() {
        System.out.println("Printing student details...");
        // Add actual implementation here
    }
    // Method to calculate percentage
    public void calculatePercentage() {
        System.out.println("Calculating percentage...");
        // Add actual implementation here
    }
    // Method to add a student
    public void addStudent() {
        System.out.println("Adding a new student...");
        // Add actual implementation here
    }
    public static void main(String[] args) {
        // Creating an object of the Main class
        Main obj = new Main();
        // Calling methods using the object
        obj.addStudent();
        obj.printDetails();
        obj.calculatePercentage();
    }
}

编译并运行

输出

Adding a new student...
Printing student details...
Calculating percentage...

上面的程序违反了单一职责原则。为了达到目标，我们应该实现单独的类（如下），它们只执行一个功能。

Student.java

public class Student {  
public void addStudent(); {  
//functionality of the method  
}  
}  

PrintStudentDetails.java

public class PrintStudentDetails{  
public void printDetails();  {  
//functionality of the method  
}  
}  

Percentage.java

public class Percentage {  
public void calculatePercentage();  {  
//functionality of the method  
}  
}  

因此，通过将功能分离到三个单独的类中，我们实现了单一职责原则的目标。

这种分离增强了模块化，使每个类更容易独立测试、维护和演进。

开闭原则

应用程序或模块实体（方法、函数、变量等）。开闭原则指出，根据新的需求，模块应该对扩展开放，对修改关闭。扩展允许我们在模块中实现新功能。让我们通过一个例子来理解这个原则。

public class VehicleInfo  {  
public double vehicleNumber(Vehicle vcl) {  
if (vcl instanceof Car)   {  
return vcl.getNumber();  
if (vcl instanceof Bike) {  
return vcl.getNumber();  
}  
}  

如果我们想添加一个名为 Truck 的新子类，只需添加另一个 if 语句，这会违反开闭原则。添加子类并实现该原则目标的唯一方法是重写 vehicleNumber() 方法，如下所示。

示例

public class Main {
	public static void main(String[] args) {
		VehicleInfo car = new Car();
		VehicleInfo truck = new Truck();
		System.out.println("Car Number: " + car.vehicleNumber());
		System.out.println("Truck Number: " + truck.vehicleNumber());
	}
}
class VehicleInfo {
	public int vehicleNumber() {
		return 0;
	}
	public int getValue() {
		return 7884;
	}
}
// Car class extending VehicleInfo
class Car extends VehicleInfo {
	@Override
	public int vehicleNumber() {
		return this.getValue(); // Use the method from VehicleInfo
	}
}
// Truck class extending VehicleInfo
class Truck extends VehicleInfo {
	@Override
	public int vehicleNumber() {
		return this.getValue();
	}
}

编译并运行

输出

Car Number: 7884
Truck Number: 7884

同样，我们可以通过创建一个从 vehicleInfo 类继承的子类来添加更多车辆。这种方法不会影响现有应用程序。

此原则有助于编写灵活且可扩展的代码，能够适应不断变化的需求。

里氏替换原则

Barbara Liskov 引入了里氏替换原则 (LSP)。它适用于继承，使得派生类必须能够完全替换其基类。换句话说，如果类 A 是类 B 的子类型，那么我们应该能够在不中断程序行为的情况下用 A 替换 B。

它扩展了开闭原则，并且还关注超类及其子类型的行为。我们应该设计类以保持其属性，除非有充分的理由不这样做。让我们通过一个例子来理解这个原则。

示例

class Main {
	public static void main(String[] args) {
		StudentBMI student = new StudentBMI();
		student.setDetails(1.8, 75); // 1.8 meters, 75 kg
		System.out.println("Height: " + student.getHeight());
		System.out.println("Weight: " + student.getWeight());
		System.out.println("BMI: " + student.calculateBMI());
	}
}
class Student {
	private double height;
	private double weight;
	public void setHeight(double h) {
		height = h;
	}
	public void setWeight(double w) {
		weight = w;
	}
	public double getHeight() {
		return height;
	}
	public double getWeight() {
		return weight;
	}
}
// Subclass
class StudentBMI extends Student {
	// Set both height and weight at once
	public void setDetails(double h, double w) {
		super.setHeight(h);
		super.setWeight(w);
	}
	// Calculate BMI
	public double calculateBMI() {
		double h = getHeight();
		double w = getWeight();
		if (h <= 0)
			return 0;
		return w / (h * h);
	}
}

编译并运行

输出

Height: 1.8
Weight: 75.0
BMI: 23.148148148148145

上面的类违反了里氏替换原则，因为 StudentBMI 类有额外的约束，即高度和体重必须相同。因此，Student 类（基类）不能被 StudentBMI 类（派生类）替换。

因此，用 StudentBMI 类替换 Student 类可能会导致意外行为。

遵循 LSP 可确保多态性无缝运行，允许对象互换使用而不会出现意外行为。

接口隔离原则

该原则指出，大型接口应拆分成更小的接口。因为实现类只使用所需的方法，所以我们不应该强迫客户端使用它们不想使用的技术。

接口隔离原则的目标与单一职责原则相似。让我们通过一个例子来理解这个原则。

假设我们创建了一个名为 Conversion 的接口，它有三个方法：intToDouble()、intToChar() 和 charToString()。

public interface Conversion  {  
public void intToDouble();  
public void intToChar();  
public void charToString();  
}  

上面的接口有三个方法。如果我们只想使用 intToChar() 方法，我们别无选择，只能实现这一个方法。为了解决这个问题，该原则允许我们将接口拆分成三个独立的接口。

public interface ConvertIntToDouble  {  
public void intToDouble();  
}   
public interface ConvertIntToChar  {  
public void intToChar();  
}  
public interface ConvertCharToString   {  
public void charToString();  
}  

现在，我们可以只使用所需的方法。假设我们要将整数转换为双精度，并将字符转换为字符串。那么，我们将只使用 intToDouble() 和 charToString() 方法。

public class DataTypeConversion implements ConvertIntToDouble, ConvertCharToString {  
public void intToDouble()  {  
//conversion logic  
}  
public void charToString()  {  
//conversion logic  
}  
}  

该原则促进了更清晰的接口设计，并通过仅公开真正必要的内容来减轻实现类的负担。

依赖倒置原则

该原则指出，我们必须使用抽象（抽象类和接口）而不是具体实现。高层模块不应该依赖于低层模块，而两者都应该依赖于抽象。因为抽象不依赖于细节，而细节依赖于抽象。它解耦了软件。让我们通过一个例子来理解这个原则。

public class WindowsMachine {  
//functionality   
}  

如果我们没有键盘和鼠标在 Windows 上工作，那也是值得的。为了解决这个问题，我们创建一个类的构造函数，并添加键盘和显示器的实例。添加实例后，类看起来如下。

public class WindowsMachine  {  
public final keyboard;  
public final monitor;  
public WindowsMachine()  {  
monitor = new monitor();  //instance of monitor class  
keyboard = new keyboard(); //instance of keyboard class  
}  
}  

现在我们可以通过键盘和鼠标在 Windows 机器上工作了。但我们仍然面临问题。因为我们使用 new 关键字将三个类紧密耦合在一起，所以很难测试 WindowsMachine 类。

为了使代码松耦合，我们通过使用 Keyboard 接口和此关键字来解耦 WindowsMachine 与键盘。

Keyboard.java

public interface Keyboard {   
//functionality  
} 

让我们通过一个例子来理解这个原则。

示例

public class Main {
	public static void main(String[] args) {
		Keyboard keyboard = new MechanicalKeyboard();
		Monitor monitor = new LEDMonitor();
		WindowsMachine windowsMachine = new WindowsMachine(keyboard, monitor);
		windowsMachine.run();
	}
}
// Interface for Keyboard
interface Keyboard {
	void type(String input);
}
// Interface for Monitor
interface Monitor {
	void display(String output);
}
// Concrete implementation of Keyboard
class MechanicalKeyboard implements Keyboard {
	@Override
	public void type(String input) {
		System.out.println("Typing on a Mechanical Keyboard: " + input);
	}
}
// Concrete implementation of Monitor
class LEDMonitor implements Monitor {
	@Override
	public void display(String output) {
		System.out.println("Displaying on LED Monitor: " + output);
	}
}
// WindowsMachine class using dependency injection
class WindowsMachine {
	private final Keyboard keyboard;
	private final Monitor monitor;
	public WindowsMachine(Keyboard keyboard, Monitor monitor) {
		this.keyboard = keyboard;
		this.monitor = monitor;
	}
	public void run() {
		keyboard.type("Hello World");
		monitor.display("Welcome to Windows");
	}
}

编译并运行

输出

Typing on a Mechanical Keyboard: Hello World
Displaying on LED Monitor: Welcome to Windows

在上面的代码中，我们使用了依赖注入将键盘依赖项添加到 WindowsMachine 类中。因此，我们解耦了类。

为什么我们应该使用 SOLID 原则？

它减少了依赖性，以便可以更改代码块而不会影响其他代码块。
这些原则旨在使设计更容易、更易于理解。
通过使用这些原则，系统是可维护、可测试、可扩展和可重用的。
它避免了软件的糟糕设计。

下次设计软件时，请牢记这五个原则。通过应用这些原则，代码将更加清晰、可测试和可扩展。

通过遵循 DIP，我们解耦了组件，提高了可重用性，并使系统更容易测试和维护。

SOLID 原则的优点

1. 增强的可维护性

更轻松的代码重构：遵循 SOLID 原则可产生更清晰、更模块化的代码。它使重构更容易、更安全，因为代码库的一个部分中的更改不太可能影响其他部分。随着需求的不断发展，这对于长期维护至关重要。
减少代码异味：通过遵循 SOLID 原则，开发人员可以避免常见的代码异味，如大型类、长方法和紧耦合的组件。这会产生更清晰、更易于理解的代码，从而更容易识别和修复错误。

2. 改进的可测试性

隔离单元测试：SOLID 原则促进了松耦合模块的开发。这使得隔离和测试单个组件更容易，从而实现了更有效、更可靠的单元测试。
模拟依赖项：通过松耦合的类和清晰的接口，模拟依赖项变得简单直接。它增强了独立测试组件的能力，而无需设置复杂的环境。

3. 可扩展性和灵活性

更轻松地添加新功能：遵循 SOLID 原则有助于添加新功能，而无需对现有代码库进行大量更改。这种灵活性对于适应新需求和扩展应用程序至关重要。
适应变化：符合 SOLID 的代码更易于适应变化。当业务需求发生变化时，可以在极小的干扰下调整代码，从而降低了修改相关的时间和成本。

4. 增强的可读性和理解性

更清晰的代码结构：通过鼓励定义明确的接口和职责，SOLID 原则有助于创建更清晰、更直观的代码结构。这使得新开发人员更容易理解代码库并有效地做出贡献。
改进的文档：通过定义明确的职责和模块化设计，文档可以更具重点性和清晰性。它增强了系统对当前团队成员和未来维护者的整体可理解性。

5. 提高可重用性

可重用组件：SOLID 原则鼓励创建可重用组件。这些组件可以在应用程序的不同部分甚至不同的项目中轻松重用，从而提高开发效率。
库开发：当组件遵循 SOLID 原则时，它们通常足够通用，可以提取到库或框架中，从而在多个项目中促进重用并缩短开发时间。

6. 减少技术债务

主动的代码质量管理：从一开始就遵循 SOLID 原则，开发人员可以减少技术债务的积累。这种主动的代码质量方法确保软件随着时间的推移保持可维护和可扩展。
长期的代码健康：维护遵循 SOLID 原则的代码库有助于其长期健康。这最大限度地减少了大量返工的需要，并使开发人员能够专注于通过新功能和改进来增加价值。

7. 协作和团队效率

实践标准化：应用 SOLID 原则有助于在团队中标准化开发实践。这种共同的理解带来了更有效的协作和更顺畅的系统各部分集成。
增强代码审查：当代码遵循 SOLID 原则时，代码审查会更有效。审阅者可以更容易地理解代码的结构和意图，从而获得更高质量的反馈和更快的审查周期。

8. 提高性能

优化组件：遵循 SOLID 原则的结构良好的代码可以更轻松地进行优化。由于组件具有清晰的职责且松耦合，因此可以更有效地识别和解决性能瓶颈。
更好的资源管理：通过清晰的关注点分离，可以更有效地处理资源管理（如内存和数据库连接）。这可以提高整个应用程序的性能和资源利用率。

9. 未来保障

为技术变革做好准备：遵循 SOLID 原则可确保代码库为技术进步做好更好的准备。无论是采用新框架、与不同系统集成还是扩展以满足增加的需求，符合 SOLID 的代码库都更具韧性和适应性。
平稳过渡：在迁移到新平台或重构系统的大部分时，拥有遵循 SOLID 原则的代码库可确保更平稳的过渡。这最大限度地减少了中断，并降低了大规模更改的风险。

要记住的重要事项

SOLID 首字母缩写包括单一职责、开闭、里氏替换、接口隔离和依赖倒置原则。
这些指南由 Robert C. Martin（通常称为 Uncle Bob）提出，以确保代码易于管理且能够应对增长。
根据 SRP，只有一个原因会导致类发生更改。它有助于增强团队，并减少维护工作。
OCP 的想法是允许向类添加新部分，但不要更改现有代码。
在任何情况下，都可以用子类替换其超类，而不会破坏软件的正确性。
让类仅实现它们真正使用的那些方法：设计系统时使用一系列小型接口而不是一个大型接口。
使用依赖倒置原则，使代码服从于抽象，因为它可以提高可测试性。

结论

这些原则是使面向对象的 Java 软件强大、易于维护和可扩展的基础。当使用这五项原则时，软件系统将变得更易于解释、测试和更新。

遵循这些原则的结果是，开发人员看到了改进的代码组织、更少的重复部分，以及为其软件和未来的活动带来了更好的结果。无论应用程序的大小如何，坚持 SOLID 原则都能确保代码库能够适应、保持稳定并符合当今的标准。

Java SOLID 原则选择题

1. 哪个 SOLID 原则规定一个类应该只有一个改变的原因？

单一职责原则
开闭原则
里氏替换原则
依赖倒置原则

答案：1

解释：单一职责原则 (SRP) 指出，一个类应该只有一个改变的原因，这意味着它应该只有一个工作或职责。

2. 开闭原则建议软件实体应该

对修改开放，对扩展关闭
对修改关闭，对扩展开放
对继承开放，对多态关闭
对继承关闭，对多态开放

答案：2

解释：开闭原则 (OCP) 指出，软件实体（如类、模块、函数）应该对扩展开放，但对修改关闭，允许在不更改现有代码的情况下添加新功能。

3. 根据里氏替换原则，子类应该 ______________。

从父类继承私有方法
能够替换父类而不影响功能
使用多重继承来增加功能
重载父类的方法

答案：2

解释：里氏替换原则 (LSP) 指出，子类的对象应该能够替换父类的对象，而不影响程序的正确性。

4. 哪个原则鼓励高层模块依赖于抽象而不是具体实现？

接口隔离原则
开闭原则
里氏替换原则
依赖倒置原则

答案：4

解释：依赖倒置原则 (DIP) 指出，高层模块应依赖于抽象（接口）而不是具体实现，从而促进代码的解耦和灵活性。

5. 以下哪项陈述最能描述接口隔离原则？

接口应为特定的客户端需求而设计，而不是通用目的
客户端不应被迫依赖他们不使用的接口
接口应从其他接口继承以增加功能
所有类都应实现多个接口以增强灵活性

答案：2

解释：接口隔离原则 (ISP) 指出，客户端不应被迫依赖他们不使用的接口，提倡使用更小、更具体的接口而不是大型、通用的接口。

下一主题Java 工厂设计模式的实际示例

SOLID Principles in Java

单一职责原则

示例

开闭原则

示例

里氏替换原则

示例

接口隔离原则

依赖倒置原则

示例

为什么我们应该使用 SOLID 原则？

SOLID 原则的优点

要记住的重要事项

结论

Java SOLID 原则选择题

联系信息

关注我们

教程

面试题

在线编译器

Python

Java

.Net Framework

AI, ML and Data Science

Cloud Technology

B.Tech and MCA

Web Technology

PHP

Software Testing

Technical Interview

Java Interview

Python

Web Interview

Database Interview

B.Tech / MCA

Important Interview

Software Testing Interview

Company Interviews

Online Compilers

Multiple Choice Questions

Java Conversion

Java Misc

SOLID Principles in Java

单一职责原则

示例

开闭原则

示例

里氏替换原则

示例

接口隔离原则

依赖倒置原则

示例

为什么我们应该使用 SOLID 原则？

SOLID 原则的优点

要记住的重要事项

结论

Java SOLID 原则选择题

相关帖子

Java 中不使用除法（/）运算符进行除法

Java Atomic

Pangram Checking in Java

Java 泛型的优点

Java 中的并发集合

Eclipse 主题更改

Java 程序查找未排序数组中缺失的最小正数

MVC Architecture in Java

Java 中的图像处理 - 创建随机像素图像

How to Get Value from JSON Object in Java Example

订阅 Tpoint Tech

联系信息

关注我们

教程

面试题

在线编译器