solid 原则是一组指导原则，可帮助软件开发人员设计健壮、可扩展且可维护的系统。这些原则由 robert c. martin（bob 叔叔）提出，对于面向对象编程创建灵活且可重用的代码至关重要。
在这篇文章中，我们将深入研究每个 solid 原则，解释其目的，并提供 java 示例来演示其应用程序。
1.单一职责原则（srp）
定义：一个类应该只有一个改变的理由。这意味着一个类应该只有一项工作或职责。
为什么建议零售价很重要
当一个类具有多个职责时，对一项职责的更改可能会影响或破坏代码的其他部分。通过遵守 srp，我们确保了更好的可维护性和可测试性。
例子
// violating srp: a class that handles both user authentication and database operations.
class usermanager {
public void authenticateuser(string username, string password) {
// authentication logic
}
public void saveusertodatabase(user user) {
// database logic
}
}
// following srp: separate responsibilities into distinct classes.
class authservice {
public void authenticateuser(string username, string password) {
// authentication logic
}
}
class userrepository {
public void saveusertodatabase(user user) {
// database logic
}
}
在此示例中，authservice 处理身份验证，userrepository 管理数据库操作。每个类都有一个职责，使代码更干净、更模块化。
2. 开闭原理（ocp）
定义：类应该对扩展开放，但对修改关闭。这意味着您应该能够在不更改现有代码的情况下添加新功能。
为什么 ocp 很重要
当您修改现有代码时，您有引入错误的风险。 ocp 通过继承或组合来促进功能扩展，而不是改变原始实现。
例子
// violating ocp: adding a new discount type requires modifying the existing code.
class discountcalculator {
public double calculatediscount(string discounttype, double amount) {
if ("newyear".equals(discounttype)) {
return amount * 0.10;
} else if ("blackfriday".equals(discounttype)) {
return amount * 0.20;
}
return 0;
}
}
// following ocp: use polymorphism to add new discount types without changing existing code.
interface discount {
double apply(double amount);
}
class newyeardiscount implements discount {
public double apply(double amount) {
return amount * 0.10;
}
}
class blackfridaydiscount implements discount {
public double apply(double amount) {
return amount * 0.20;
}
}
class discountcalculator {
public double calculatediscount(discount discount, double amount) {
return discount.apply(amount);
}
}
现在，添加新的折扣类型只需创建一个实现 discount 接口的新类。
3.里氏替换原理（lsp）
定义：子类型必须可以替换其基本类型，而不改变程序的正确性。
为什么 lsp 很重要
使用多态性时，违反 lsp 可能会导致意外的行为和错误。派生类必须遵守其基类定义的契约。
例子
// violating lsp: a subclass changes the behavior of the parent class in an unexpected way.
class bird {
public void fly() {
system.out.println("flying...");
}
}
class penguin extends bird {
@override
public void fly() {
throw new unsupportedoperationexception("penguins can't fly!");
}
}
// following lsp: refactor the hierarchy to honor substitutability.
abstract class bird {
public abstract void move();
}
class flyingbird extends bird {
public void move() {
system.out.println("flying...");
}
}
class penguin extends bird {
public void move() {
system.out.println("swimming...");
}
}
通过重新设计层次结构，flyingbird 和 penguin 在替换 bird 时都能正确运行。
4. 接口隔离原则（isp）
定义：不应强迫客户端实现他们不使用的接口。相反，创建更小、更具体的界面。
为什么 isp 很重要
大型接口强制实现类包含它们不需要的方法。这会导致代码臃肿和不必要的依赖关系。
例子
// violating isp: a large interface with unrelated methods.
interface worker {
void work();
void eat();
}
class robot implements worker {
public void work() {
system.out.println("working...");
}
public void eat() {
// robots don't eat, but they're forced to implement this method.
throw new unsupportedoperationexception("robots don't eat!");
}
}
// following isp: split the interface into smaller, focused interfaces.
interface workable {
void work();
}
interface eatable {
void eat();
}
class robot implements workable {
public void work() {
system.out.println("working...");
}
}
class human implements workable, eatable {
public void work() {
system.out.println("working...");
}
public void eat() {
system.out.println("eating...");
}
}
现在，robot 只实现了 workable 接口，避免了不必要的方法。
5. 依赖倒置原则（dip）
定义：高层模块不应该依赖于低层模块。两者都应该依赖于抽象。
为什么 dip 很重要
对具体实现的直接依赖使代码变得僵化且难以测试。 dip 提倡使用抽象（接口）来解耦组件。
例子
// Violating DIP: High-level class depends on a low-level implementation.
class MySQLDatabase {
public void connect() {
System.out.println("Connecting to MySQL...");
}
}
class UserService {
private MySQLDatabase database;
public UserService() {
this.database = new MySQLDatabase(); // Tight coupling
}
public void performDatabaseOperation() {
database.connect();
}
}
// Following DIP: High-level class depends on an abstraction.
interface Database {
void connect();
}
class MySQLDatabase implements Database {
public void connect() {
System.out.println("Connecting to MySQL...");
}
}
class UserService {
private Database database;
public UserService(Database database) {
this.database = database; // Depend on abstraction
}
public void performDatabaseOperation() {
database.connect();
}
}
// Usage
Database db = new MySQLDatabase();
UserService userService = new UserService(db);
userService.performDatabaseOperation();
通过这种设计，您可以轻松地交换数据库实现（例如 postgresql、mongodb），而无需修改 userservice 类。
结论
solid 原则是创建可维护、可扩展且强大的软件的强大工具。快速回顾一下：
- srp：一个班级，一种责任。
- ocp：在不修改现有代码的情况下扩展功能。
- lsp：子类型必须可替换其基本类型。
- isp：更喜欢较小的、集中的界面。
- dip：依赖于抽象，而不是具体实现。
通过应用这些原则，您的代码将更容易理解、测试并适应不断变化的需求。从小处开始，根据需要进行重构，并逐渐将这些原则融入到您的开发过程中！
