程序员应该遵守的开发原则之开闭原则

厚土燎原

已于 2024-09-04 17:06:39 修改

阅读量1.2k

点赞数 31

分类专栏：重构之路文章标签：开闭原则设计规范 java 设计模式重构

于 2024-08-31 20:30:25 首次发布

本文链接：https://blog.csdn.net/TP000/article/details/141757860

版权

重构之路专栏收录该内容

4 篇文章 0 订阅

订阅专栏

大家好！欢迎莅临厚土燎原的天地，深感荣幸能与您相遇在此，共同品读我的拙作。您的阅读如同春风化雨，对我而言意义非凡。衷心邀请您留下宝贵的评论与指点，每一字一句都是对我莫大的鼓励与鞭策。热烈欢迎，期待与您智慧碰撞，共绘思想的火花！

🌿🌿🌿 个人主页：厚土燎原

什么是开闭原则

开闭原则（Open-Closed Principle, OCP）是面向对象设计中的一个核心原则，它指导我们如何构建稳定且灵活的软件系统。

具体来说，开闭原则的定义是：一个软件实体（如类、模块和函数）应该对扩展开放，对修改关闭。这意味着在软件设计过程中，我们应该尽量通过扩展已有的软件实体来实现新的功能或需求，而不是通过修改其源代码来完成。

开闭原则的核心思想

开放-扩展：软件实体应该能够轻松地接受新的扩展和增加新的功能，而不需要对现有代码进行大规模的修改。

封闭-修改：一旦软件实体被设计并验证通过，其源代码应该被封闭起来，避免因为小的改动而引入新的错误或破坏现有的功能。

开闭原则的好处

提高软件的可维护性：由于减少了对已有代码的修改，降低了因修改引入错误的风险，从而提高了软件的可维护性。

增强软件的可复用性：通过抽象和模块化设计，软件实体之间的耦合度降低，使得软件中的各个部分更容易被复用。

促进软件的灵活性：软件能够更容易地适应未来的变化，因为新的功能或需求可以通过扩展来实现，而不是通过修改已有代码。

实现开闭原则的关键

抽象化：将系统中的复杂部分简化为一些简单的抽象接口，从而降低系统的耦合性和复杂性。

模块化：将系统划分为一些独立的模块，每个模块都具有明确的功能和接口，从而提高了系统的可重用性和可维护性。

依赖抽象：通过依赖抽象接口而不是具体实现来编程，这样可以在不修改现有代码的情况下扩展新的功能。

实际应用场景

开闭原则在软件开发中有着广泛的应用场景。

例如，在版本更新时，我们可以尽量不修改源代码，而是通过添加新的类或方法来增加新功能。 此外，在设计框架或库时，也会遵循开闭原则来确保框架或库的稳定性和可扩展性。

总之，开闭原则是面向对象设计中的一个重要原则，它指导我们如何构建稳定、灵活且易于维护的软件系统。通过遵循开闭原则，我们可以降低软件系统的耦合性和复杂性，提高代码的可重用性和可维护性。

实例

旧方法：

public Integer calculate(Integer type,Integer argA, Integer argB){
    int result = 0;
    if (type == 1) {
        result = argA + argB;
    }else if (type == 2) {
        result = argA - argB;
    }
    return result;
}
上述这段代码就违背了开闭原则，type覆盖了等于1和等于2两种情况，

如果新增一个type类型，我们就需要再加一个if判断，这样我们代码就无法封闭，

而一直处于被修改的状态。

新方法：

计算接口类：
public interface Calculator extends InitializingBean {
   Integer calculate(Integer argA, Integer argB);
}
type为1的具体计算类：
public class CalculatorA implements Calculator {
   @Override
   public Integer calculate(Integer argA, Integer argB){
      return argA + argB;
   }

   @Override
   public void afterPropertiesSet() throws Exception {
      CalculatorManager.addCalculator(1, this);
   }
}
type为2的具体计算类：
public class CalculatorB implements Calculator{
   @Override
   public Integer calculate(Integer argA, Integer argB){
      return argA - argB;
   }

   @Override
   public void afterPropertiesSet() throws Exception {
      CalculatorManager.addCalculator(2, this);
   }
}
计算类管理器：
public class CalculatorManager {
   private static final Map<Integer, Calculator> CALCULATOR_HASH_MAP = new HashMap<>();

   public static void addCalculator(Integer type, Calculator calculator) {
      CALCULATOR_HASH_MAP.put(type, calculator);
   }
   public static Calculator getCalculator(Integer type) {
      return CALCULATOR_HASH_MAP.get(type);
   }
}
重构后的计算方法：
public Integer calculate(Integer type,Integer argA, Integer argB){
   Calculator calculator = CalculatorManager.getCalculator(type);
   if (calculator == null) {
      return 0;
   }
   return calculator.calculate(argA, argB);
}
我们可以看到，重构后的方法是符合开闭原则的。如果有新的type，我们就新增一个计算类，然后实现相关接口并注入到计算管理类里面就可以了。

对比新旧代码片段，新方案展现出了显著的优势：它不仅大幅提升了代码的可读性，使逻辑更加清晰易懂，更重要的是，它极大地增强了代码的扩展性和可维护性。

总结

开闭原则作为软件设计的黄金法则之一，其目标在于塑造出既稳定又灵活的系统架构。这一原则强调系统应当对扩展保持开放的态度，同时对于修改则应当保持封闭，确保新增功能或变更需求时，既有的代码结构能够保持不变，从而减少潜在的错误与风险。

遵循开闭原则，我们能够在不触动系统核心稳定性的前提下，轻松融入新的功能特性。这不仅极大地提升了软件的可维护性，也确保了系统在未来面对变化时能够展现出更高的适应性和可扩展性。相反，若忽视了这一原则，频繁地修改既有代码以应对新需求，不仅会破坏系统的稳定性，还会增加引入错误的可能性，导致“改得多，错得多”的恶性循环，让系统越来越难以驾驭，bug频发。

因此，在开发过程中，我们应当时刻铭记开闭原则，通过精心的设计与规划，利用抽象、接口、继承和多态等面向对象的设计技术，构建出既灵活又稳固的软件架构。这样，无论是面对当前的需求还是未来的变化，我们的系统都能够游刃有余，持续稳定地运行并满足业务发展的需要。