七大设计模式原则

**七大设计模式原则**

在软件开发领域，设计模式是一种反复出现的解决方案，针对特定类型的问题。七大设计模式是最常见、最重要的设计模式，它们为我们提供了一个框架来构建高质量、可维护性和扩展性的代码。

**1. 单一责任原则 (Single Responsibility Principle, SRP)**单一责任原则指出，每个类或模块应该只负责一种功能。也就是说，一个类不应该承担多种职责，这样可以使其更容易维护、测试和理解。

java// Bad example:一个类同时负责数据存储和业务逻辑public class User {
 private String name;
 private int age;

 public void save() { // 数据存储功能 }
 public void calculateScore() { //业务逻辑功能 }
}

// Good example: 分离出单独的类来处理不同的职责public class UserRepository {
 public void save(User user) { /*数据存储功能*/ }
}

public class UserBusinessLogic {
 public int calculateScore(User user) { /*业务逻辑功能*/ }
}

**2. 开放-闭合原则 (Open-Closed Principle, OCP)**开放-闭合原则指出，一个软件组件应该对扩展开放，对修改关闭。也就是说，当需要添加新功能时，可以通过扩展而不是修改现有代码来实现。

java// Bad example: 需要修改现有代码来添加新功能public class PaymentProcessor {
 public void processPayment(Payment payment) { /*处理支付逻辑*/ }
}

// Good example:通过扩展来添加新功能public interface PaymentProcessor {
 void processPayment(Payment payment);
}

public class CreditCardPaymentProcessor implements PaymentProcessor {
 @Override public void processPayment(Payment payment) { /*处理信用卡支付逻辑*/ }
}

public class PayPalPaymentProcessor implements PaymentProcessor {
 @Override public void processPayment(Payment payment) { /*处理PayPal支付逻辑*/ }
}

**3. 接口隔离原则 (Interface Segregation Principle, ISP)**接口隔离原则指出，一个类不应该实现多个接口，它们之间没有共同点。也就是说，每个接口应该专注于一种特定的功能。

java// Bad example:一个类同时实现两个接口public class User implements Loginable, Registerable {
 public void login() { /*登录逻辑*/ }
 public void register() { /*注册逻辑*/ }
}

// Good example: 分离出单独的接口来处理不同的功能public interface Loginable {
 void login();
}

public interface Registerable {
 void register();
}

**4.依赖倒置原则 (Dependency Inversion Principle, DIP)**依赖倒置原则指出，高层次模块不应该依赖于低层次模块，而是两者都应该依赖于抽象接口或第三方库。

java// Bad example: 高层次模块直接依赖于低层次模块public class Controller {
 private Service service;

 public void handleRequest() { /*处理请求逻辑*/ }
}

public class Service {
 public void processRequest() { /*处理请求逻辑*/ }
}

// Good example:通过抽象接口来实现依赖倒置public interface RequestProcessor {
 void processRequest();
}

public class Controller {
 private RequestProcessor requestProcessor;

 public void handleRequest() { /*处理请求逻辑*/ }
}

public class Service implements RequestProcessor {
 @Override public void processRequest() { /*处理请求逻辑*/ }
}

**5.命令模式 (Command Pattern)**命令模式指出，将一个请求或操作封装在一个对象中，使得可以参数化、队列化和日志记录这些请求。

java// Bad example: 直接执行命令public class Light {
 public void turnOn() { /*打开灯*/ }
}

public class Button {
 private Light light;

 public void press() { /*按下按钮*/ }
}

// Good example: 使用命令对象来封装和执行命令public interface Command {
 void execute();
}

public class TurnOnLightCommand implements Command {
 @Override public void execute() { /*打开灯*/ }
}

public class Button {
 private Command command;

 public void press(Command command) { /*按下按钮*/ }
}

**6.观察者模式 (Observer Pattern)**观察者模式指出，定义一个一对多的关系，使得当一个对象改变时，它的依赖者都能收到通知。

java// Bad example: 直接修改被观察者public class WeatherStation {
 public void updateWeather() { /*更新天气*/ }
}

public class Forecast {
 private WeatherStation weatherStation;

 public void receiveForecast() { /*接收预报*/ }
}

// Good example: 使用观察者对象来实现一对多的关系public interface Observer {
 void update();
}

public class WeatherStation {
 private List observers;

 public void addObserver(Observer observer) { /*添加观察者*/ }
 public void notifyObservers() { /*通知观察者*/ }
}

**7.状态模式 (State Pattern)**状态模式指出，允许一个对象在其内部状态改变时改变它的行为。

java// Bad example: 直接修改状态public class Light {
 private boolean isOn;

 public void turnOn() { /*打开灯*/ }
}

public class Button {
 private Light light;

 public void press() { /*按下按钮*/ }
}

// Good example: 使用状态对象来实现状态的改变和行为的变化public interface State {
 void handleEvent();
}

public class OnState implements State {
 @Override public void handleEvent() { /*打开灯*/ }
}

public class OffState implements State {
 @Override public void handleEvent() { /*关闭灯*/ }
}

以上就是七大设计模式原则的总结。这些原则对于构建高质量、可维护性和扩展性的代码至关重要。