单一职责原则介绍

一.概念介绍

单一职责原则(Single Responsibility Principle, SRP)是面向对象设计中的五大根本原则之一,它是指一个类或者模块应该仅有一个引起它变化的缘故原由。
具体来说,单一职责原则有以下几个特点:

• 职责集中:一个类或模块应该专注于完成一种特定的功能或职责,而不应该承担过多的职责。
  
• 职责分离:假如一个类或模块承担了多个职责,那么当其中一个职责发生变化时,就会影响到其他职责,导致代码难以维护。
  
• 可测试性:单一职责的类或模块更轻易编写单位测试,由于它们的功能更加集中和明确。
  
• 可复用性:单一职责的类或模块更轻易被其他代码复用,由于它们的功能更加独立和通用。
  
• 可读性:单一职责的类或模块更轻易被开发人员理解和修改,由于它们的功能更加清晰和简单。
  

遵循单一职责原则的长处包括:

• 提高代码的可维护性:当一个类或模块只负责一个职责时,代码的布局更加清晰,修改时不会影响到其他无关的功能。
  
• 提高代码的可测试性:单一职责的类或模块更轻易编写单位测试,由于它们的功能更加集中和明确。
  
• 提高代码的可复用性:单一职责的类或模块更轻易被其他代码复用,由于它们的功能更加独立和通用。
  
• 提高代码的可读性:单一职责的类或模块更轻易被开发人员理解和修改,由于它们的功能更加清晰和简单。
  

总之,单一职责原则是面向对象设计中非常紧张的一个原则,它可以帮助我们编写出更加高质量、可维护和可扩展的代码。在现实开发中,我们应该积极遵循这一原则,尽量将类或模块的职责划分得更加清晰和集中。
二.具体例子

假设我们有一个 Employee 类,它负责管理员工的根本信息,如姓名、工号、部分等。
不遵循单一职责原则的例子:

1. class Employee {  
2. public:  
3.     Employee(const std::string& name, int id, const std::string& department)  
4.         : m_name(name), m_id(id), m_department(department) {}  
6.     void setName(const std::string& name) { m_name = name; }  
7.     void setId(int id) { m_id = id; }  
8.     void setDepartment(const std::string& department) { m_department = department; }  
10.     std::string getName() const { return m_name; }  
11.     int getId() const { return m_id; }  
12.     std::string getDepartment() const { return m_department; }  
14.     void giveRaise(double percentage) { /* 计算并更新工资 */ }  
15.     void fireEmployee() { /* 执行解雇流程 */ }  
16.     void printEmployeeInfo() { /* 打印员工信息 */ }  
18. private:  
19.     std::string m_name;  
20.     int m_id;  
21.     std::string m_department;  
22. };  

复制代码

在这个例子中,Employee 类承担了太多的职责,包括管理员工根本信息、盘算工资、执行解雇流程、打印员工信息等。这违反了单一职责原则,由于当其中一个职责发生变化时,就会影响到其他职责,导致代码难以维护。
遵循单一职责原则的例子:

1. class Employee {  
2. public:  
3.     Employee(const std::string& name, int id, const std::string& department)  
4.         : m_name(name), m_id(id), m_department(department) {}  
6.     std::string getName() const { return m_name; }  
7.     int getId() const { return m_id; }  
8.     std::string getDepartment() const { return m_department; }  
10. private:  
11.     std::string m_name;  
12.     int m_id;  
13.     std::string m_department;  
14. };  
16. class EmployeeCompensation {  
17. public:  
18.     void giveRaise(Employee& employee, double percentage) {  
19.         // 计算并更新工资  
20.     }  
21. };  
23. class EmployeeManagement {  
24. public:  
25.     void fireEmployee(Employee& employee) {  
26.         // 执行解雇流程  
27.     }  
28. };  
30. class EmployeeReporting {  
31. public:  
32.     void printEmployeeInfo(const Employee& employee) {  
33.         // 打印员工信息  
34.     }  
35. };  

复制代码

在这个例子中,我们将 Employee 类的职责划分为三个不同的类:

• Employee 类负责管理员工的根本信息。
  
• EmployeeCompensation 类负责处理员工的工资相关操作。
  
• EmployeeManagement 类负责处理员工的解雇流程。
  
• EmployeeReporting 类负责打印员工信息。
  

这样做的长处是:

• 每个类都只负责一个明确的职责,代码更加清晰和可维护。
  
• 当某个职责发生变化时,只需要修改相应的类,不会影响到其他无关的功能。
  
• 各个类都可以独立地进行单位测试,提高了代码的可测试性。
  
• 各个类都可以被其他代码复用,提高了代码的可复用性。
  

总之,这个例子展示了如何遵循单一职责原则来设计代码,从而提高代码的质量和可维护性。

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。