七大软件设计原则之一|开闭原则

开闭原则是指一个软件实体（模块、类、方法等）应该对扩展开放，对修改关闭

我举一个例子，陀螺是个程序喵，创办了一个生产猫粮的公司——跑码场，手下有个小徒弟叫招财，写了一个下单的逻辑。

/** * @author 蝉沐风 * @description 原始代码 * @date 2022/2/8 */public class PaoMaChangV1 {?    public void order(String flavor) {?        if (flavor.equals("毛血旺")) {            orderMaoXueWangCatFood();        } else if (flavor.equals("鱼香肉丝")) {            orderFishCatFood();        }    }?    private void orderMaoXueWangCatFood() {        System.out.println("售卖一袋「毛血旺」风味猫粮");    }?    private void orderFishCatFood() {        System.out.println("售卖一袋「鱼香肉丝」风味猫粮");    }?}

逻辑本身很简单，核心业务逻辑主要是order()函数，客户需要传入相应的猫粮口味flavor进行下单。

现在跑码场扩展了业务，新增了一种「大肠刺身」口味的猫粮，而且支持用户自定义猫粮购买数量（毕竟这种口味可能会供不应求）。在以上代码的基础上，招财做了如下修改：

/** * @author 蝉沐风 * @description 原始代码功能扩展 * @date 2022/2/8 */public class PaoMaChangV1Expand {?    public void order(String flavor, Integer count) {?        if (flavor.equals("毛血旺")) {            orderMaoXueWangCatFood(count);        } else if (flavor.equals("鱼香肉丝")) {            orderFishCatFood(count);        }        // 更改1：添加口味的逻辑判断        else if (flavor.equals("大肠刺身")) {            orderDaChangFood(count);        }    }?    private void orderMaoXueWangCatFood(Integer count) {        System.out.println("售卖" + count + "袋「毛血旺」风味猫粮");    }?    private void orderFishCatFood(Integer count) {        System.out.println("售卖" + count + "袋「鱼香肉丝」风味猫粮");    }?    // 更改2：添加售卖逻辑    private void orderDaChangFood(Integer count) {        System.out.println("售卖" + count + "一袋「大肠刺身」风味猫粮");    }}

这种修改方式确实能解决目前的业务问题，但同时也存在很多问题。

首先，修改了order()方法，添加了一个参数，相应的客户端调用必须修改；其次，每当有新的口味猫粮产品诞生时，都必须在order()方法中添加口味的判断，同时需要添加该产品的售卖逻辑。这些操作都是通过「修改」来实现新功能的，不符合「开闭原则」。

如果我们要遵循「开闭原则」，必须对修改关闭，对扩展开放。

我们重构一下初始代码，主要做以下两方面的修改：

1. 创建CatFood基类，然后创建对应口味的猫粮继承基类；
2. 将每种口味猫粮的售卖逻辑写在具体类中。
3. 修改客户调用的order方法

/** * @author 蝉沐风 * @description 猫粮基类 * @date 2022/2/8 */public abstract class CatFood {       public abstract void order();?}?/** * @author 蝉沐风 * @description 「毛血旺」猫粮 * @date 2022/2/8 */public class MaoXueWangCatFood extends CatFood {?    @Override    public void order() {        System.out.println("售卖一袋「毛血旺」风味猫粮");    }}??/** * @author 蝉沐风 * @description 「鱼香肉丝」猫粮 * @date 2022/2/8 */public class FishCatFood extends CatFood {?    @Override    public void order() {        System.out.println("售卖一袋「鱼香肉丝」风味猫粮");    }?}

order()方法修改如下

/** * @author 蝉沐风 * @description 遵循「开闭原则」之后的代码 * @date 2022/2/8 */public class PaoMaChangV2 {?    public void order(CatFood catFood) {       catFood.order();    }?}

重构之后的客户端调用方式如下

/** * @author 蝉沐风 * @description 客户端调用 * @date 2022/2/8 */public class ClientV2 {    public static void main(String[] args) {        PaoMaChangV2 paoMaChang  = new PaoMaChangV2();?        // 创建对应口味的猫粮        FishCatFood fish = new FishCatFood();        paoMaChang.order(fish);    }}

现在我们再来看，基于重构之后的代码，我们要实现刚才讲到的业务需求，我们需要进行怎样的改动。主要的修改内容有如下：

1. CatFood基类中添加属性count，为子类添加构造函数；
2. 添加新类DaChangCatFood；

扩展之后的代码如下

/** * @author 蝉沐风 * @description 猫粮类 * @date 2022/2/8 */public abstract class CatFood {        //订购数量    private Integer count;?    public abstract void order();?    public Integer getCount() {        return count;    }?    public void setCount(Integer count) {        this.count = count;    }?    public CatFood(Integer count) {        this.count = count;    }?    public CatFood() {    }}?/** * @author 蝉沐风 * @description 「毛血旺」猫粮 * @date 2022/2/8 */public class MaoXueWangCatFood extends CatFood {?    public MaoXueWangCatFood(Integer count) {        this.setCount(count);    }?    @Override    public void order() {        System.out.println("售卖" + this.getCount() + "袋「毛血旺」风味猫粮");    }}?/** * @author 蝉沐风 * @description 「鱼香肉丝」猫粮 * @date 2022/2/8 */public class FishCatFood extends CatFood {?    public FishCatFood(Integer count) {        this.setCount(count);    }?    @Override    public void order() {        System.out.println("售卖" + this.getCount() + "袋「鱼香肉丝」风味猫粮");    }?}?/** * @author 蝉沐风 * @description 「大肠刺身」猫粮 * @date 2022/2/8 */public class DaChangCatFood extends CatFood {?    public DaChangCatFood(Integer count) {        this.setCount(count);    }?    @Override    public void order() {        System.out.println("售卖" + this.getCount() + "袋「大肠刺身」风味猫粮");    }?}

客户端调用方式变为

public class ClientV2 {    public static void main(String[] args) {        PaoMaChangV2 paoMaChang  = new PaoMaChangV2();?        // 创建对应口味的猫粮        DaChangCatFood dachang = new DaChangCatFood(2);        paoMaChang.order(dachang);    }}

重构之后的代码在扩展上更加的灵活

1. 如果有了新口味的猫粮产品，只需创建新的class对象，重写order()方法就可以了，不需要改动其他的代码；
2. 如果order方法中需要其他参数，可以根据实际情况，在CatFood中添加相关属性。

是不是修改代码就违背开闭原则？

你可能会有疑问，我们为了完成新业务功能，不仅在CatFood类中添加了count属性，而且还添加了getter/setter方法，这难道不算修改代码吗？

首先我们需要认识到，添加新功能的时候，我们不可能一点代码都不修改！其次，「开闭原则」的定义是软件实体（模块、类、方法等）应该对扩展开放，对修改关闭。对于count属性的添加而言，在模块或类的粒度下，可以被认为是修改，但是在方法的粒度下，我们并没有修改之前存在的方法和属性，因此可以被认为是扩展。

实际编码过程中怎么遵守开闭原则？

我的理解是不需要刻意遵守。

你只需要头脑中有这个印象就行了，你需要知道的就是你的代码需要具有一定的扩展性。所有的设计原则都只有一个最终归宿——不破坏原有代码的正常运行，方便扩展。

随着你的理论知识和实战经验的提高，同时对业务有了足够了解，你在设计代码结构时会很自然地向未来靠拢（这需要稍加练习，这种技能不是单纯靠工作时长就能获得的），识别出未来可能会发生的扩展点。

但是想识别出所有可能的扩展点既不可能也没必要，最合理的做法是对一些比较确定的、短期内可能会发生的需求进行扩展设计。

还是那句话，设计原则和设计模式不是金科玉律，只要适合当前需求，并具备一定弹性的设计就是好设计。要平衡代码扩展性和可读性，切勿滥用设计原则和设计模式，牺牲代码的可读性。