程序设计方法（一）：结构化、基于对象、面向对象、基于接口

公司接到一个项目，实现1个加法器，在项目开发的不同阶段，用户又会提出各种新的要求（即变化点）

版本1:实现一个加法器，加法器中已经保存了被加数，使用加法器的时候，要给他传递一个加数，然后加法器计算并返回相加后的结果；

版本2:（1）被加数在使用时需要乘上权重值，再和加数进行运算；(2）以前的加法器还要保留，因为有部分老用户还会使用老的代码

版本3: 老加法器必须规定被加数是非负的整数，而新加法器被加数可以是正数也可以是负数

一、结构化程序设计

（1）实现版本1

struct SAugend{  int iAugend;};int Add(struct SAugend * pSAugend,int iAddend){  return pSAugend->iAugend + iAddened;}

（2）实现版本2

struct SWeightingAugend{  int iAugend;  int iWeight;};int WeightingAdd(struct SWeightingAugend *pSWeightingAugend, int iAddend){  return pSWeightingAugend->iWeight * pSWeightingAugend->iAugend + iAddend;} 

用户接口，需要在用户的代码中修改函数的调用方式：

void  func(...){  ...  // 修改之前的函数调用  //Add();  WeightingAdd();  ...}

结构化程序设计的缺点分析：

(1)、在实际应用中，通常我们会把struct结构体放到.h文件中，而方法放到其他文件中； 这样本来Add函数就是处理SAugend结构体的（他们俩本是密不可分的），却要被分到两个文件中；这就是所谓的没有封装

(2)、在新版本中，引入变化点后，需要对老代码进行修改；这就失去了代码的封闭性； 所谓代码的封闭性就是说：当项目中扩展了新的功能时，用户代码可以不用修改，就体验到新功能带来的好处（当然，如果用户不想使用新功能，也要允许他使用之前的版本）

二、基于对象的程序设计（不考虑继承，但遵循所有东西都是对象）

（1）版本1

class CAdder{public :  CAdder(int iAugend)  {    m_iAugend = iAugend;   }    int Add(int iAddend)  {    return m_iAugend + iAddend;  }private:  int m_iAugend;};

(2)版本2

class CWeightingAdder{public:  CWeightingAdder(int iAugend, int iWeight)  {    m_iAugend = iAugend;    m_iWeight = iWeight;  }  int Add(int iAddend)  {    return m_iAugend * m_iWeight + iAddend;  }private :  int m_iAugend;  int m_iWeight;};

用户接口：

int func(...){   ...  // 使用新方法时，要修改之前的类定义和方法的调用  // CAdder ca(3);  //int result = ca.Add(2);  CWeightingAdder cwa(3,10);  int result cwa.Add(2);}

分析：

(1)、基于对象的设计，得到的改进是：变量和相关方法实现了封装

(2)、但可以看出，当变化点出现时，用户的接口还是需要修改，即还是没有封装变化点；

三、面向对象的程序设计（面向对象的设计与基于对象的设计的区别是：面向对象多了继承和虚函数）

(1)、版本1

class CAdder{public :  CAdder(int iAugend)  {    m_iAugend = iAugend;  }  virtual ~CAdder()  {  }   virtual int Add(int iAddend)  {   return m_iAugend + iAddend;  }protected:  int m_iAugend;};

(2）版本2

class  CWeightingAdder : public CAdder{public :  CWeightingAdder(int iAugend,int iWeight):CAdder(iAugend)  {    m_iWeight = iWeight;  }  virtual ~CWeightingAdder()  {  }  virtual int Add(int iAddend)  {    return m_iAugend * m_iWeight + iAddend;  }   protected：  int m_iWeight;};

用户接口:

int func(CAdder * pAdder)
{

  ...

  //不需要修改，同一种调用方式（父类指针指向子类对象）

  int result = pAdder->Add(5);

}

分析：

面向对象的程序设计，已经能很好的封装变化点1了，即新功能的引用不影响用户的的程序接口；

关于变化点2:

先在变化点2来了，新问题是，父类的成员变量要改变，而子类的变化点不能改变，而我们使用的是子类直接继承父类成员变量的方法,父类的改变必将牵连子类；所以对于变化点2 ,面向对象的程序设计是不能实现的；

所以从这我们就知道了：继承带来的问题是，父类和子类有强藕合关系，他们失去了独立性

四、基于接口的程序设计(子类和父类之间又继承关系，变成兄弟关系；他们共同继承自他们的抽象或者说他们的共同点---都是加法器)

class IAdder{public:  IAdder()  {  }  virtual  ~IAdder()  {  }  virtual int Add(int iAddend) = 0;}

(1）、版本1

class CAdder : public IAdder{public :  CAdder(unsigned int iAugend)  {  m_iAugend = iAugend;  }  virtual ~CAdder()  {  }  virtual int Add(int iAddend)  {  return m_iAugend+iAddend;  }private:unsigned int m_iAugend;};

(2)版本2

class CWeightingAdder : public IAdder{public :CWeightingAdder (int iAugend,int iWeight){  m_iWeight = iWeight;  m_iAugend = iAugend;}virtual ~CWeightingAdder(){}virtual int Add(int iAddend){  return m_iAugend * m_iWeight + iAddend;}private:int m_iAugend;int m_iWeight;}

用户接口：

int func(IAdder * pAdder){  ...  int result = pAdder->Adder(5);  ...}

用户接口不需要做任何变化，所有的变化点都被封装到实现类中去了。