1、简述
在软件开发中，设计模式是构建灵活、可维护代码的重要工具。而设计模式的六大原则则为我们提供了编写高质量代码的基础指南。理解并实践这些原则能够帮助开发者更轻松地应对复杂的设计问题。本文将介绍六大设计原则，并结合实际代码示例加深理解。
2、单一职责原则 (Single Responsibility Principle, SRP)
定义： 一个类应该只有一个引起其变化的原因，即一个类只负责一个功能。
优点： 降低类的复杂性，提高类的可读性和可维护性
// 不遵守单一职责原则的代码
class Employee {
public void calculateSalary() {
// 计算薪资逻辑
}
public void printPaySlip() {
// 打印薪资单逻辑
}
}
// 遵守单一职责原则的代码
class SalaryCalculator {
public void calculateSalary() {
// 计算薪资逻辑
}
}
class PaySlipPrinter {
public void printPaySlip() {
// 打印薪资单逻辑
}
}
3、开闭原则 (Open/Closed Principle, OCP)
定义： 软件实体（类、模块、函数等）应该对扩展开放，对修改关闭。
优点： 提高代码的扩展性，减少对现有代码的影响，降低出错风险
// 不符合开闭原则的代码
class PaymentService {
public void processPayment(String paymentType) {
if (paymentType.equals("CreditCard")) {
System.out.println("Processing Credit Card payment");
} else if (paymentType.equals("Paypal")) {
System.out.println("Processing PayPal payment");
}
}
}
// 遵守开闭原则的代码
interface Payment {
void process();
}
class CreditCardPayment implements Payment {
@Override
public void process() {
System.out.println("Processing Credit Card payment");
}
}
class PayPalPayment implements Payment {
@Override
public void process() {
System.out.println("Processing PayPal payment");
}
}
class PaymentService {
public void processPayment(Payment payment) {
payment.process();
}
}
4、里氏替换原则 (Liskov Substitution Principle, LSP)
定义： 子类对象可以替换父类对象，且程序行为不变。
优点： 保证子类的行为符合父类的预期，提高代码的健壮性
// 不符合里氏替换原则的代码
class Rectangle {
private int width;
private int height;
public int getWidth() { return width; }
public void setWidth(int width) { this.width = width; }
public int getHeight() { return height; }
public void setHeight(int height) { this.height = height; }
}
class Square extends Rectangle {
@Override
public void setWidth(int width) {
super.setWidth(width);
super.setHeight(width); // 正方形强制将高度和宽度同步
}
@Override
public void setHeight(int height) {
super.setHeight(height);
super.setWidth(height); // 同步宽度和高度
}
}
// 遵守里氏替换原则的代码
interface Shape {
int getArea();
}
class Rectangle implements Shape {
private int width;
private int height;
public Rectangle(int width, int height) {
this.width = width;
this.height = height;
}
@Override
public int getArea() {
return width * height;
}
}
class Square implements Shape {
private int side;
public Square(int side) {
this.side = side;
}
@Override
public int getArea() {
return side * side;
}
}
5、依赖倒置原则 (Dependency Inversion Principle, DIP)
定义： 高层模块不应该依赖于低层模块，它们都应该依赖于抽象。
优点： 提高代码的灵活性和可扩展性
// 不符合依赖倒置原则的代码
class Keyboard {
public void type() {
System.out.println("Typing...");
}
}
class Computer {
private Keyboard keyboard;
public Computer() {
this.keyboard = new Keyboard(); // 直接依赖具体类
}
public void work() {
keyboard.type();
}
}
// 遵守依赖倒置原则的代码
interface InputDevice {
void input();
}
class Keyboard implements InputDevice {
@Override
public void input() {
System.out.println("Typing...");
}
}
class Computer {
private InputDevice inputDevice;
public Computer(InputDevice inputDevice) {
this.inputDevice = inputDevice; // 依赖抽象
}
public void work() {
inputDevice.input();
}
}
6、接口隔离原则 (Interface Segregation Principle, ISP)
定义： 一个类不应该强迫实现它不使用的接口。
优点： 避免代码臃肿，提高灵活性
// 不符合接口隔离原则的代码
interface Worker {
void code();
void design();
void test();
}
class Programmer implements Worker {
@Override
public void code() {
System.out.println("Coding...");
}
@Override
public void design() {
// 空实现
}
@Override
public void test() {
// 空实现
}
}
// 遵守接口隔离原则的代码
interface Coder {
void code();
}
interface Designer {
void design();
}
interface Tester {
void test();
}
class Programmer implements Coder {
@Override
public void code() {
System.out.println("Coding...");
}
}
7、迪米特原则 (Law of Demeter, LoD)
定义： 一个对象应该对其他对象有最少的了解。
优点： 降低系统耦合性，提高模块的独立性
// 不符合迪米特原则的代码
class Engine {
public void start() {
System.out.println("Engine started");
}
}
class Car {
private Engine engine;
public Car(Engine engine) {
this.engine = engine;
}
public void drive() {
engine.start();
System.out.println("Car is driving");
}
}
// 遵守迪米特原则的代码
class Engine {
public void start() {
System.out.println("Engine started");
}
}
class Car {
private Engine engine;
public Car(Engine engine) {
this.engine = engine;
}
public void drive() {
startEngine();
System.out.println("Car is driving");
}
private void startEngine() {
engine.start();
}
}
8、总结
设计模式的六大原则是编写高质量代码的核心指南。通过单一职责、开闭原则等原则的实践，我们可以构建灵活、可扩展的系统。在实际开发中，理解每个原则的意义，并结合实际需求合理运用，能够显著提升项目的质量和可维护性。
评论区