## 1.1 先来看开闭原则的定义： > Software entities like classes,modules and functions should be open for extension but closed for modifications > 一个软件实体, 如类, 模块, 函数等应该对扩展开放, 对修改封闭.

这也是开放封闭原则的核心思想：对扩展开放，对修改封闭.

## 1.2 这是什么含义呢?

* 对扩展开放，意味着有新的需求或变化时，可以对现有代码进行扩展，以适应新的情况。 * 对修改封闭，意味着类一旦设计完成，就可以独立完成其工作，而不要对已有代码进行任何修改

# 二. 如何实现开放封闭原则呢?

“需求总是变化”、“世界上没有一个软件是不变的”。这里投射出的意思是：需求总是变化的， 可是对于软件设计者来说, 如何才能做到不对原有系统修改的前提下, 实现灵活的扩展. 这就是开闭原则要实现的.

我们在设计系统的时候, 不可能设想一次性把需求确定后, 后面就不改变了.这不科学也不现实的. 既然需求是一定会变化的, 那么我们要如何优雅的面对这种变化呢? 如何设计可以使软件相对容易修改, 不至于需求一变, 就要把整个程序推到重来?

> 开封-封闭原则. 设计软件要容易维护且不容易出问题的最好办法, 就是多扩展, 少修改.

## 2.1 依赖与抽象 实现开放封闭的核心思想就是面对抽象编程，而不是面对具体编程，因为抽象相对稳定。 让类依赖于固定的抽象，所以对修改是封闭的；而通过面向对象的继承和多态机制，可以实现对抽象体的继承，通过覆写其方法来改变固有行为，实现新的扩展方法，所以对于扩展就是开放的。这是实施开放封闭原则的基本思路。

## 2.2 如何落地开闭原则 如果当前的设计不符合开放封闭原则，则必须进行重构。常用的设计模式主要有**模板方法（Template Method）设计模式**和**策略（Strategy）设计模式**。而封装变化，是实现这一原则的重要手段，将经常发生变化的部分封装为一个类。

## 2.3 开闭原则的重要性

### 1.开闭原则对测试的影响 开闭原则可是保持原有的测试代码仍然能够正常运行，我们只需要对扩展的代码进行测试就可以了。

### 2.开闭原则可以提高复用性 在面向对象的设计中，所有的逻辑都是从原子逻辑组合而来的，而不是在一个类中独立实现一个业务逻辑。只有这样代码才可以复用，粒度越小，被复用的可能性就越大。

### 3.开闭原则可以提高可维护性 面向对象开发的要求。

## 2.4 如何使用开闭原则 ### 1.抽象约束     第一，通过接口或者抽象类约束扩展，对扩展进行边界限定，不允许出现在接口或抽象类中不存在的public方法；     第二，参数类型、引用对象尽量使用接口或者抽象类，而不是实现类；     第三，抽象层尽量保持稳定，一旦确定即不允许修改。 ### 2.元数据（metadata）控制模块行为     元数据就是用来描述环境和数据的数据，通俗地说就是配置参数，参数可以从文件中获得，也可以从数据库中获得。     Spring容器就是一个典型的元数据控制模块行为的例子，其中达到极致的就是控制反转（Inversion of Control） ### 3.制定项目章程     在一个团队中，建立项目章程是非常重要的，因为章程中指定了所有人员都必须遵守的约定，对项目来说，约定优于配置。 ### 4.封装变化     对变化的封装包含两层含义：     第一，将相同的变化封装到一个接口或者抽象类中；     第二，将不同的变化封装到不同的接口或抽象类中，不应该有两个不同的变化出现在同一个接口或抽象类中。   # 三. 案例分析 ## 案例一: 画形状 需求: 有圆形, 有椭圆形, 根据要求画出相应的形状 ```java public class GraphicEditor {

    public void draw(Shape shape) {         if (shape.m_type == 1) {             drawRectangle();         } else if(shape.m_type == 2) {             drawCircle();         }     }

    public void drawRectangle() {         System.out.println("画长方形");     }

    public void drawCircle() {         System.out.println("画圆形");     }

    class Shape {         int m_type;     }

    class Rectangle extends Shape {         Rectangle() {             super.m_type=1;         }     }

    class Circle extends Shape {         Circle() {             super.m_type=2;         }     }

}

``` 我们来看看, 这个代码, 初看是符合要求了, 再想想, 要是我增加一种形状呢? 比如增加三角形.  首先, 要增加一个三角形的类, 继承***pe 第二, 要增加一个画三角形的方法drawTrriage() 第三, 在draw方法中增加一种类型type=3的处理方案. 这就违背了开闭原则-对扩展开发, 对修改关闭. 增加一个类型, 修改了三处代码.

我们来看看合适的设计 ```java public class GraphicEditor1 {

    public void draw(Shape shape) {         shape.draw();     }

    interface Shape {         void draw();     }

    class Rectangle implements Shape {

        @Override         public void draw() {             System.out.println("画矩形");         }     }

    class Circle implements Shape {

        @Override         public void draw() {             System.out.println("画圆形");         }     }

} ``` 各种类型的形状自己规范自己的行为, 而GraphicEditor.draw()只负责画出来. 当增加一种类型三角形. 只需要 第一: 增加一个三角形的类,实现Shape接口 第二, 调用draw方法,划出来就可以了.

整个过程都是在扩展, 而没有修改原来的类. 这个设计是符合开闭原则的.

## 案例二:  比如现在有一个银行业务, 存钱, 取钱和转账. 最初我们会怎么思考呢?  1. 首先有一个银行业务类, 用来处理银行的业务  2. 银行有哪些业务呢? 存钱,取钱,转账, 这都是银行要执行的操作  3. 那外部说我要存钱, 我要取钱,我要转账, 通过一个类型来告诉我们  代码就生成了  ```java package com.lxl.www.designPatterns.sixPrinciple.openclosePrinciple.bank;

/**  * 银行业务  */ public class BankBusiness {

    public void operate(int type) {         if (type == 1) {             save();         } else if(type == 2) {             take();         } else if(type == 3) {             transfer();         }     }

    public void save(){         System.out.println("存钱");     }

    public void take(){         System.out.println("取钱");     }

    public void transfer() {         System.out.println("转账");     } } ``` 咋一看已经实现了需求. 但是现在有新的需求来了, 银行要增加功能---理财. 理财是银行业务的一种, 自然是新增一个方法. 然后在operate()方法里增加一种类型. 这就是一个糟糕的设计, 增加新功能, 但是却修改了原来的代码

我们设计成接口抽象的形式, 上代码 ```java public interface Business {     public void operate(); }

public class Save implements Business{     @Override     public void operate() {         System.out.println("存钱业务");     } }

public class Take implements Business {     @Override     public void operate() {         System.out.println("取钱业务");     } }

public class Transfer implements Business {     @Override     public void operate() {         System.out.println("转账业务");     } }

/**  * 银行业务类  */ public class BankBusinesses {     /**      * 处理银行业务      * @param business      */     public void operate(Business business) {         System.out.println("处理银行业务");         business.operate();     } }

``` 通过接口抽象的形式方便扩展, 加入要新增理财功能. 只需新增一个理财类, 其他业务代码都不需要修改. 

其实, 在日常工作中, 经常会遇到这种情况. 因为我们平时写业务逻辑会更多一些, 而业务就像流水账, 今天一个明天一个一点一点的增加. 所以,当业务增加到3个的时候, 我们就要思考, 如何写能够方便扩展j

### 3.3 关于作答链路的思考 作答链路包括 拉题-->初始化-->答题-->订正-->加积分-->主观题批改-->主观题批改回传等流程. 那么这么一条链路是否可以通过接口抽象的形式规范代码,实现开闭原则呢? 不至于后面增加一种类型, 就需要新增一个方法. 其实, 我觉得是可以的.

# 四. 总结： 1. 遵守开闭原则可以提高软件扩展性和维护性。 2. 大部分的设计模式和设计原则都是在实现开闭原则。#Java开发##学习路径#