设计模式原则——开放封闭原则

设计模式一共有六大原则：

单一原则、开放封闭原则、接口分离原则、里氏替换原则、最少知识原则、依赖倒置原则。

这篇博客是自己对开放封闭设计原则的一些拙见，有何不对欢迎大家指出。

开放封闭原则：

软件实体（类，模块，函数等）应该可以扩展，但是不可修改。

（解释：其原则就是，设计一个类的时候时刻考虑，尽量要这个类足够的好，写好了就不要去修改了，如果有了新的需求变化，增加一个类就完事！原来的代码就不动了。）

开放封闭原则是面向对象的核心所在。遵循这个原则可以带来面向对象的四个好处（可维护，可扩展，可复用，灵活性好）。开发中，对频繁变化的那部分做出抽象的处理。

特征：

1，对扩展是开放的。

2，对修改是封闭的。

Demo：

我们来创建一个计算器。

1，不遵守开放封闭原则

UML：

/**
 * 计算器的实现（无设计模式）
 * @author tujietg
 *
 */
public class Calculator {
    public static void main(String[] args) throws Exception {
        Scanner scanner;
        System.out.println("输入a：");
        scanner = new Scanner(System.in);
        int a = scanner.nextInt();
        System.out.println("输入b：");
        scanner = new Scanner(System.in);
        int b = scanner.nextInt();
        System.out.println("输入：sign");
        scanner = new Scanner(System.in);
        String sign = scanner.nextLine();

        System.out.println(Operation(a, b, sign));
    }

    public static int Operation(int a, int b, String sign) throws Exception {
        int sum = 0;

        switch (sign) {
        case "+":
            sum = a + b;
            break;
        case "-":
            sum = a - b;
            break;
        case "*":
            sum = a * b;
            break;
        case "/":
            if (b == 0) {
                throw new Exception("被除数不能为0");
            }
            sum = a / b;
            break;
        }
        return sum;
    }

}

如果现在增加一个平方的运算。需要修改原本写好的类（calculator），这违背了开放封闭原则。

2，遵循开放原则

UML：

通过UML图可以看出，遵循开放封闭原则的实现多了一个抽象的运算类。

运算抽象类：

public abstract class Operation {
    int FirstNum;
    int SecondNum;
 
    public int getFirstNum() {
        return FirstNum;
    }
 
    public void setFirstNum(int firstNum) {
        FirstNum = firstNum;
    }
 
    public int getSecondNum() {
        return SecondNum;
    }
 
    public void setSecondNum(int secondNum) {
        SecondNum = secondNum;
    }
 
    public abstract int getResult() throws Exception;
}

运算实现类：

//加法
class OperationAddImpl extends Operation {
    @Override
    public int getResult() {
        return FirstNum + SecondNum;
    }
 
}
 
//除法
class OperationDivImpl extends Operation {
    @Override
    public int getResult() throws Exception {
        if (SecondNum == 0) {
            throw new Exception("被除数不能为0");
        } else {
            return FirstNum / SecondNum;
        }
    }
 
}
 
//减法
class OperationSubImpl extends Operation {
 
    @Override
    public int getResult() {
        return FirstNum - SecondNum;
    }
 
}
 
//乘法
class OperationMulDivImpl extends Operation {
    @Override
    public int getResult() {
        return FirstNum * SecondNum;
    }
 
}

当我们的代码设计遵循了开放封闭原则时，这时，如果我们需要增加一个平方的需求，我们只需要创建一个平方的类（extends抽象类）。

这样做，我们保持了原有代码的封闭效果，同时，实现了对扩展的开放。

总结：

对业务中经常变化的模块进行抽象。

拒绝滥用抽象，业务中变化频率高的才考虑用抽象的方式。