开闭原则（Open Closed Principle）

超、凢脫俗 2021-11-23 08:06 203阅读 0赞

**目录**

1、基本介绍

2、应用实例

2.1、需求

2.2、传统方式实现

2.2.1、问题分析

2.2.2、类图

2.2.3、代码

2.2.4、传统方式实现分析

2.3、遵循开闭原则实现

2.3.1、问题分析

2.3.2、类图

2.3.3、代码

2.3.4、遵循开闭原则实现分析

--------------------

# 1、基本介绍 #

*  开闭原则（Open Closed Principle）是编程中**最基础、最重要**的设计原则。
 *  一个软件实体如：类、模块和函数，应该**对扩展开放**（对提供方来说），**对修改关闭**（对使用方来说）。**用抽象构建框架，用实现扩展细节。**
 *  当软件需要变化时，尽量**通过扩展**软件实体的行为来实现变化，而不是**通过修改**已有的代码来实现变化。
 *  编程中遵循其他原则，以及使用设计模式的目的就是遵循**开闭原则**（核心）。

# 2、应用实例 #

## 2.1、需求 ##

有一个制门的加工厂，可以生产玻璃门、木门、铁门等门。

编程实现生产细节。

## 2.2、传统方式实现 ##

### 2.2.1、问题分析 ###

每个门可以设计为一个类，用一个属性type来区分是什么门。

加工厂也是一个类，加工厂中更据type来制作不同的门。

### 2.2.2、类图 ###

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjQyNTk3MA_size_16_color_FFFFFF_t_70][]

### 2.2.3、代码 ###

/**
     * 客户端
     */
    public class Client {
        public static void main(String[] args) {
            DoorFactory factory = new DoorFactory();
            factory.makeDoor(new IronDoor());
            factory.makeDoor(new TimberDoor());
        }
    }
    
    /**
     * 门
     */
    class Door{
        int type;
    }
    
    /**
     * 铁门
     */
    class IronDoor extends Door{
        public IronDoor() {
            type = 1;
        }
    }
    
    /**
     * 木门
     */
    class TimberDoor extends Door{
        public TimberDoor(){
            type = 2;
        }
    }
    
    /**
     * 制门工厂
     */
    class DoorFactory{
        /**
         * 制作门
         */
        public void makeDoor(Door door){
            if(1 == door.type){
                makeIronDoor();
            }else if(2 == door.type){
                makeTimberDoor();
            }
        }
    
        public void makeTimberDoor(){
            System.out.println("制作木门");
        }
        public void makeIronDoor(){
            System.out.println("制作铁门");
        }
    }

运行结果：

![20190726103043870.png][]

### 2.2.4、传统方式实现分析 ###

这种方式达到了需求，但是扩展性不好。

比如：现在要制门工厂生产玻璃门，那该怎么做呢？

*  首先要新建一个玻璃门类。
 *  然后再制门工厂中加入制作玻璃门的方法。
 *  最后要修改制门工厂中的制作门方法，在方法中添加if-else来判断玻璃门。

问题就来了，我们在新加入一种或者减少一种门的时候，都要去修改制门工厂类，这严重违反了**[开闭原则（OCP）][OCP]。**

解决方式：将具体实现交给实现层（类），引用的时候使用抽象层（接口/抽象类）

## 2.3、遵循开闭原则实现 ##

### 2.3.1、问题分析 ###

将门设计成一个抽象类或者接口，提供一个抽象方法：制作；

具体的各个门（木门、铁门...）实现或继承门；

制门工厂中不用考虑要制作什么门，只需要调用制门方法即可，具体细节让门的实例自己去实现；

### 2.3.2、类图 ###

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjQyNTk3MA_size_16_color_FFFFFF_t_70 1][]

### 2.3.3、代码 ###

/**
     * 客户端
     */
    public class Client {
        public static void main(String[] args) {
            DoorFactory factory = new DoorFactory();
            factory.makeDoor(new IronDoor());
            factory.makeDoor(new TimberDoor());
        }
    }
    
    /**
     * 门
     */
    interface Door{
        void make();
    }
    
    /**
     * 铁门
     */
    class IronDoor implements Door{
        @Override
        public void make() {
            System.out.println("制作铁门");
        }
    }
    
    /**
     * 木门
     */
    class TimberDoor implements Door{
        @Override
        public void make() {
            System.out.println("制作木门");
        }
    }
    
    /**
     * 制门工厂
     */
    class DoorFactory{
        /**
         * 制作门
         */
        public void makeDoor(Door door){
            door.make();
        }
    }

运行结果与上面一种方式的一样。

### 2.3.4、遵循开闭原则实现分析 ###

遵循开闭原则设计的程序，虽然运行起来和前面的方式一模一样，但是：遵循开闭原则，从根本上提高了程序的扩展性、维护性和可靠性。

如果现在要制作玻璃门，只需要在新增一个玻璃门类并实现Door的make方法即可，不用再做任何的修改。

这也就是：**对扩展**（新增门）**开放**，**对修改**（制门工厂）**关闭。**

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjQyNTk3MA_size_16_color_FFFFFF_t_70]: /images/20211122/e9c73279c9b04c8ca5754a33c1f87ada.png
[20190726103043870.png]: /images/20211122/cb2e5255f86541809f744e858cf092d3.png
[OCP]: https://baike.baidu.com/item/%E5%BC%80%E9%97%AD%E5%8E%9F%E5%88%99
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjQyNTk3MA_size_16_color_FFFFFF_t_70 1]: /images/20211122/022b3dd05285476ca7f725583a06addc.png