面向对象基本原则 - SOLID原则

SOLID原则

SOLID原则包含五条原则，每条原则取首字母即SOLID。

Single Responsibility Principle 单一责任原则

定义：一个类只应该做一件事情
一个类如果需要做多个事情，那么就要拆分这个类。

public class User {  
    private String username;  
    private String password;  
  
    public User(String username, String password) {  
        this.username = username;  
        this.password = password;  
    }  
  
    public void setUsername(String username) {  
        this.username = username;  
    }  
  
    public void setPassword(String password) {  
        this.password = password;  
    }  
}

Open Closed Principle 开放封闭原则

定义：实体对扩展应该是开放的，对修改应该是封闭的
通过继承和接口实现多态，而不是直接修改现有类的代码。

interface Animal {  
    void makeSound();  
}  
  
class Dog implements Animal {  
    @Override  
    public void makeSound() {  
        System.out.println("Woof!");  
    }  
}  
  
class Cat implements Animal {  
    @Override  
    public void makeSound() {  
        System.out.println("Meow!");  
    }  
}

Liskov Substitution Principle 里氏替换原则

定义：子类必须能够替换其父类而不会引发错误。

描述：子类必须能够替换其父类，且程序的当功能前不会改变。

例子：如果有一个父类的方法返回一个对象的类型，那么任何使用这个返回值的代码在子类替换后也应该正常工作。

class Sms {  
    public void sendSms(double phoneNo) {   
        // ...
    }   
}   
    
class TencentSms extends Sms {   
   public void sendSms(double phoneNo) {   
        // ...
    }   
}

class AliSms extends Sms {   
   public void sendSms(double phoneNo) {   
        // ...
    }   
}

class Run {
	private Sms sms = new Sms();
	
	public void run(double phoneNo) {
	    sms.sendSms(phoneNo);
	}
} 

The Interface Segregation Principle 接口分离原则

定义：客户端不应该被强制依赖于它们不使用的接口。多个专门的接口比复合的单一接口好。

// 大的接口，包含了很多方法  
public interface LargeInterface {  
    void method1();  
    void method2();  
    void method3();  
    // ...更多方法...  
}  
  
// 拆分后的接口1，只包含客户端需要的方法1  
public interface SmallInterface1 {  
    void method1();  
}  
  
// 拆分后的接口2，只包含客户端需要的方法2和3  
public interface SmallInterface2 {  
    void method2();  
    void method3();  
}  
  
// 具体实现类，实现了拆分后的接口  
public class ConcreteClass implements SmallInterface1, SmallInterface2 {  
    @Override  
    public void method1() { // 实现方法1 }  
    @Override  
    public void method2() { // 实现方法2 }  
    @Override  
    public void method3() { // 实现方法3 }  
}

The Dependency Inversion Principle 依赖倒置原则

定义：高层模块不应该依赖于低层模块，它们都应该依赖于抽象；抽象不应该依赖于细节，具体实现应该依赖于抽象。

// 定义一个抽象接口  
public interface MessageService {  
    void sendMessage(String message);  
}  
  
// 实现抽象接口的具体类  
public class EmailMessageService implements MessageService {  
    @Override  
    public void sendMessage(String message) {  
        // 实现发送电子邮件的逻辑  
    }  
}  
  
// 实现抽象接口的具体类  
public class SmsMessageService implements MessageService {  
    @Override  
    public void sendMessage(String message) {  
        // 实现发送短信的逻辑  
    }  
}  
  
// 高层模块，依赖于抽象接口MessageService，而不是具体类  
public class NotificationSystem {  
    private MessageService messageService;  
      
    public NotificationSystem(MessageService messageService) {  
        this.messageService = messageService;  
    }  
      
    public void notifyUser(String message, String recipient) {  
        messageService.sendMessage(message);  
    }  
}