开闭原则(Open Closed Principle)

  • Post author:
  • Post category:其他



目录


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、类图

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("制作铁门");
    }
}

运行结果:

2.2.4、传统方式实现分析

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

比如:现在要制门工厂生产玻璃门,那该怎么做呢?

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

问题就来了,我们在新加入一种或者减少一种门的时候,都要去修改制门工厂类,这严重违反了


开闭原则(OCP)


解决方式:将具体实现交给实现层(类),引用的时候使用抽象层(接口/抽象类)

2.3、遵循开闭原则实现

2.3.1、问题分析

将门设计成一个抽象类或者接口,提供一个抽象方法:制作;

具体的各个门(木门、铁门…)实现或继承门;

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

2.3.2、类图

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方法即可,不用再做任何的修改。

这也就是:

对扩展

(新增门)

开放



对修改

(制门工厂)

关闭。



版权声明:本文为weixin_42425970原创文章,遵循 CC 4.0 BY-SA 版权协议,转载请附上原文出处链接和本声明。