开闭原则、里氏更换与单一职责：软件计划的核心原则

 接待来到我的主页：【一只认真写代码的步伐猿】
假如这篇文章对你有资助，渴望点赞收藏加关注啦~

目次

1 开闭原则内容引出
1.1 开闭原则
1.2 开闭原则示例
2 里氏更换原则
3 单一职责内容引出
​编辑3.1 单一职责
3.2 类的单一
3.3 方法单一
3.4 接口单一

---

1 开闭原则内容引出

 

1.1 开闭原则

界说：一个软件实体，类，函数，模块；对扩展开放，对修改关闭。用抽象构建框架，用实现扩展细节。可以进步软件的可复用性和可维护性。
开发新功能时，只管不修改原有代码，只管使用扩展来增长新功能。
实现开闭原则的焦颔首脑是：面向抽象编程，而不是面向实现编程。
界说的对象范例是：抽象or接口；调用的是抽象类or接口中的方法。抽象是稳固的，让一个类依靠于抽象，实现对修改关闭。再通过面向对象的继续与多态，实现对抽象的继续，通过重写方法or实现新的扩展方法。
1.2 开闭原则示例

1. /**
2. * 商品接口
3. */
4. public interface IGood {
5.     Integer getId();
6.     String getName();
7.     Double getPrice();
8. }

复制代码

1. /**
2. * 普通商品
3. */
4. public class NormalGood implements IGood {
5.     private Integer id;
6.     private String name;
7.     private Double price;
9.     public NormalGood(Integer id, String name, Double price) {
10.         this.id = id;
11.         this.name = name;
12.         this.price = price;
13.     }
15.     @Override
16.     public Integer getId() {
17.         return this.id;
18.     }
20.     @Override
21.     public String getName() {
22.         return this.name;
23.     }
25.     @Override
26.     public Double getPrice() {
27.         return this.price;
28.     }
30.     @Override
31.     public String toString() {
32.         return "...普通商品信息"
33.     }
34. }

复制代码

1. /**
2. 添加打折功能
3. 根据开闭原则 , 对修改关闭 , 对扩展开放;
4. 定义子类,在继承普通商品的基础上,扩展的新功能;
5. 不用实现接口，而是继承普通类。
6. 站在会员卡角度如下：
7. card接口；普通用户类；银卡继承普通用户；金卡继承银卡
8. */
9. public class DiscountGood extends NormalGood {
11.     public DiscountGood(Integer id, String name, Double price) {
12.         super(id, name, price);
13.     }
15.     @Override
16.     public Double getPrice() {
17.         return super.getPrice() * 0.8;//折扣位置
18.     }
19. }

复制代码

---

2 里氏更换原则

子类可以扩展父类的功能，但不能改变父类原有的功能。
是开闭原则的告急方式之一，由于使用父类对象的地方都可以使用子类对象，因此在步伐中只管使用父类范例来对对象举行界说，而在运行时再确定其子类范例，用子类对象来更换父类对象。

1. public class FatherClass {
2.     public void method(HashMap map) {
3.         System.out.println("执行父类 void method(HashMap map) 方法");
4.     }
5. }
7. public class ChildClass extends FatherClass {
8.     /**
9.      * 重写
10.      * 重写 ( 返回值 严格 ) : 当 子类的方法 重写 / 重载 / 实现 父类的方法时
11.      *      方法的 后置条件 ( 返回值 ) 要 比父类更严格或相等;
12.      */
13.     @Override
14.     public void method(HashMap map) {
15.         System.out.println("执行子类重写的 void method(HashMap map) 方法");
16.     }
18.     /**
19.      * 重载
20.      * 重载 ( 输入参数 宽松 ) : 子类的方法 重载 父类的方法 时
21.      *      方法的前置条件 ( 输入参数 ) , 要比 父类方法的输入参数更宽松 ;
22.      *
23.      * 如果在父类中参数类型是 Map
24.      *      在子类中重载参数类型是 HashMap
25.      *      这样就会出现混乱的问题
26.      * 客户端调用时 , 可能不清楚情况 , 加入传入了 HashMap 参数
27.      *      此时就有可能出现混乱 , 无法调用到 父类/子类的 正常重写方法
28.      *      方法调用被重载方法拦截的情况
29.      *
30.      * 如果 重载的方法 的参数 比父类的方法参数更严格
31.      *      那么这就不是重载方法 , 而是重写方法
32.      */
33.     public void method(Map map) {
34.         System.out.println("执行子类重载的 void method(Map map) 方法");
35.     }
37. }

复制代码

---

3 单一职责内容引出

3.1 单一职责

界说：不要存在多余一个导致类变动的缘故起因。
假设有一个类，负责“A”和“B”；一旦需求变动，如A功能改变，修改该类A功能时，有大概导致B功能发生故障。对于该环境，应该对于AB各自创建独立的类，包管体系的稳固性。
开发方法：一个类只负责一项职责（类、接口、方法）
长处：可读性高、进步体系可维护性、低沉类的复杂度、低沉需求变动导致的风险。
模块化的体系中，都适当使用单一职责。

1. //以下代码均违反了单一职责原则
2. public class Dog{
3.     public void mainDogs(String name) {
4.         if ("小狗".equals(name)) {
5.             System.out.println("puppy's name is "+name);
6.         } else {
7.             System.out.println("Dog's name is "+name);
8.         }
9.     }
10. }
12. //-----------------------------------------------------------------
14. public class Order {
15.     private String orderId;
16.     private String userId;
17.     private String productId;
18.     private double amount;
19.     private OrderStatus status;
21.     public void createOrder(String userId, String productId, double amount) {
22.         // 创建订单  
23.     }
25.     public void payOrder() {
26.         // 支付订单  
27.     }
29.     public void shipOrder() {
30.         // 发货
31.     }
33.     public void completeOrder() {
34.         // 完成订单
35.     }
36. }

复制代码

3.2 类的单一

1. /**
2. *本类的职责单一，只负责puppy
3. */
4. public class Puppy{
5.     public void IsPuppy(String name) {
6.         System.out.println("Puppy's name is "+name);
7.     }
8. }
9. public class Dog{
10.     public void IsDog(String name) {
11.         System.out.println("Dogs's name is "+name);
12.     }
13. }
15. //--------------------------------------------------
16. // 订单接口
17. public interface Order {
18.     void create();
20.     void pay();
22.     void ship();
24.     void complete();
25. }
27. // 创建类
28. public class OrderCreator implements Order {
29.     @Override
30.     public void create() {
31.     // 创建订单的业务逻辑
32.     }
33. }
35. ...其他业务类
38. // 订单完成类
39. public class OrderCompleter implements Order {
40.     @Override
41.     public void complete() {
42. // 完成订单的逻辑
43.     }
44. }

复制代码

3.3 方法单一

假如方法中存在大片的if-else阐明是不完满的代码，而我们在开发中着实应该制止如is-else大概switch等条件语句。

1. //违反单一原则的代码
2. //如果只针对价格or名字or描述进行修改，会连带修改另外两个，存在一定风险
3. public class Good {
4.     public void updateGoodInfo(String name, double price,String description) {
5.             //更新商品信息逻辑
6.     }
7. }
10. //修改后：
11. public class Good{
12.     public void updateGoodName(String Name){
13.             //修改名字
14.     }
16.     public void updateGoodPrice(String Name){
17.             //修改价格
18.     }
19.     public void updateGoodDescription(String Name){
20.             //修改商品描述
21.     }
23. }

复制代码

3.4 接口单一

1. public interface IGood {
2.     //获取名称
3.     String getName();
5.     //获取价格
6.     double getPrice();
8.     //获取商品描述
9.     String getDescription();
11.     //购买
12.     void buyGood();
13. }
15. //-----------------------拆分------------------------
16. public interface IGoodInfo{//接口1，商品信息接口
17.     String getName();
18.     String getDescription();
19.     double getPrice();
20. }
22. public interface IGoodManage{
23.     void buyGood();//接口2，商品操作接口
24.     //退换等其他逻辑
25. }
27. //商品实现
28. publci class IGoodImpl implements IGoodInfo,IGoodManage{
29.     @Override
30.     //.....
31. }

复制代码

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！qidao123.com:ToB企服之家，中国第一个企服评测及软件市场,开放入驻,技术点评得现金