设计原则-开放关闭原则

核心思想

开放-封闭原则：是指软件实体（类、模块、函数等等）应该可以扩展，但是不可修改。

对扩展开放，意味着有新的需求或变化时，可以对先有代码进行扩展，以适应新的情况。

对修改封闭，意味着类一旦设计完成，就可以独立完成其工作，而不要对类进行任何修改。

开放-封闭原则的意思是说，你设计的时候，时刻要考虑，尽量让这个类足够好，写好了就不要去修改了，如果新需求来，我们增加一个类就完事了，原来的代码能不动则不动。

但是，我们在做任何系统的时候，都不要指望系统一开始时需求确定，就再也不会变化，这是不显示也不科学的想法，而既然需求是一定会变化的，那么如何在面对需求的变化时，设计的软件可以相对容易修改，不至于说，新需求以来，就要把整个程序推倒重来。怎样的设计才能面对需求的改变却可以保持相对稳定，从而使得系统可以在第一个版本以后不断推出新的版本呢？开放-封闭给我们答案

例子：

下面的这个小程序为计算两个数的和，只有着一个功能（在windows窗体应用程序）

部分代码展示

[csharp]  view plain  copy

1. private void button1_Click(object sender, EventArgs e)  
2. {  
3.     string str1 = textBox1.Text;  
4.     string str2 = textBox2.Text;  
5.     int num1 = Convert.ToInt32(str1);  
6.     int num2 = Convert.ToInt32(str2);  
7.     int result = num1 + num2;  
8.     textBox3.Text  = Convert.ToString(result);  
9.   
10.   
11. }  

如果现在我需要让这个程序能够实现加法、减法、乘法、除法运算，那对于这个程序来说再添加一种运算程序需要对整体的代码都要修动，所以最好的办法便是重构。

需求改变，改动后代码(在控制台）

客户端代码

[csharp]  view plain  copy

1. Operation oper;   
2. oper = OperationFactory.createOperate("-");  //运算符号  
3. oper.NumberA = 8;   //假设的NumberA为8  
4. oper.NumberB = 2;   //假设的NumberB为2  
5. double result = oper.GetResult();  
6. Console.WriteLine("结果是{0}",result );  
7. Console.ReadKey();  

运算类

[csharp]  view plain  copy

1. public class Operation  
2. {  
3.     private double _numberA = 0;  
4.     private double _numberB = 0;  
5.   
6.     public double NumberA  
7.     {  
8.         get { return _numberA; }  
9.         set { _numberA = value; }  
10.     }  
11.     public double NumberB  
12.     {  
13.         get { return _numberB; }  
14.         set { _numberB = value; }  
15.     }  
16.     public virtual double GetResult()  
17.     {  
18.         double result = 0;  
19.         return result ;  
20.     }  
21. }  

加、减、乘、除代码

[csharp]  view plain  copy

1. class OperationAdd : Operation  
2.  {  
3.      public override double GetResult()  
4.      {  
5.          double result = 0;  
6.   
7.          result = NumberA + NumberB;  
8.          return result;  
9.      }  
10.  }//加法类，继承运算类  
11.   
12.  class OperationSub : Operation  
13.  {  
14.      public override double GetResult()  
15.      {  
16.          double result = 0;  
17.          result = NumberA - NumberB;  
18.          return result  ;  
19.            
20.      }  
21.  }//减法类，继承运算类  
22.   
23.  class OperationMul : Operation  
24.  {  
25.      public override double GetResult()  
26.      {  
27.          double result = 0;  
28.          result = NumberA * NumberB;  
29.          return result;  
30.            
31.      }  
32.  }//乘法类，继承运算类  
33.   
34.  class OperationDiv : Operation  
35.  {  
36.      public override double GetResult()  
37.      {  
38.          double result = 0;  
39.          if (NumberB == 0)  
40.              throw new Exception("除数不能为0");  
41.          result = NumberA / NumberB;  
42.          return result;  
43.            
44.            
45.      }  
46.  }//除法类，继承运算类  

简单工厂运算类

[csharp]  view plain  copy

1. public class OperationFactory  
2.         {  
3.             public static Operation createOperate(string operate)  
4.             {  
5.                 Operation oper = null;  
6.                 switch (operate)  
7.                 {  
8.                     case "+":  
9.                         oper = new OperationAdd();  
10.                         break;  
11.                     case"-":  
12.                         oper = new OperationSub();  
13.                         break;  
14.                     case "*":  
15.                         oper = new OperationMul();  
16.                         break;  
17.                     case "/":  
18.                         oper = new OperationDiv();  
19.                         break;  
20.                 }  
21.                 return oper;  
22.             }  
23.         }  

这样如果需求再次改变，需要可以计算平方的算法，那么只需要在加上一个平方类便可。

图解

小结：

这样既能保证了开放-封闭原则，有能体现之前所说的简单工厂模式

开放-封闭原则是面向对象设计的核心所在。遵循这个原则可以带来面向对象技术所生成的巨大好处，也就是可维护、可扩展、可复用、灵活性好。开发人员应该仅对程序中呈现出频繁变化的那些部分做出抽象，然而，对于应用程序中的每个部分都刻意地进行抽象同样不是一个好主意。拒绝不成熟的抽象和抽象本身一样重要。