数据封装，继承，多态

• 数据封装

#include <iostream>
using namespace std;

class Adder{
   public:
      // 构造函数
      Adder(int i = 0)
      {
        total = i;
      }
      // 对外的接口
      void addNum(int number)
      {
          total += number;
      }
      // 对外的接口
      int getTotal()
      {
          return total;
      };
   private:
      // 对外隐藏的数据
      int total;
};
int main( )
{
   Adder a;

   a.addNum(10);
   a.addNum(20);
   a.addNum(30);

   cout << "Total " << a.getTotal() <<endl;
   return 0;
}

• 继承
  

#include <iostream>

using namespace std;

// 基类
class Shape 
{
   public:
      void setWidth(int w)
      {
         width = w;
      }
      void setHeight(int h)
      {
         height = h;
      }
   protected:
      int width;
      int height;
};

// 派生类
class Rectangle: public Shape
{
   public:
      int getArea()
      { 
         return (width * height); 
      }
};

int main(void)
{
   Rectangle Rect;

   Rect.setWidth(5);
   Rect.setHeight(7);

   // 输出对象的面积
   cout << "Total area: " << Rect.getArea() << endl;

   return 0;
}

• 多态
  参学：http://www.runoob.com/cplusplus/cpp-polymorphism.html
  如：
  draw（）；recu（）；circle（）；tri（）；
  当发出指令“画”，不同的对象会有不同的操作，圆形，矩形，三角形

1.) 静多态
前面学习的函数重载，也是一种多态现象，通过命名倾轧在编译阶段决定，故称为静多态。

2.)动多态
动多态，不是在编译器阶段决定，而是在运行阶段决定，故称为动多态。动多态行成的条件如下:
a，父类中有虚函数。
b，子类 override(覆写)父类中的虚函数。
c，通过己被子类对象赋值的父类指针或引用，调用共用接口。

3.)格式

class 类名
{
  virtual 函数声明；//虚函数
}

class 类名
{
  virtual 函数声明=0；//纯虚函数
}

4.)虚函数小结
a，在基类中用 virual 声明成员函数为虚函数。类外实现虚函数时，不必再加 virtual.
b，在派生类中重新定义此函数称为覆写，要求函数名，返值类型，函数参数个数及类型全部匹配。并根据派生类的需要重新定义函数体。
c，当一个成员函数被声明为虚函数后，其派生类中完全相同的函数（显示的写出）也为虚函数。 可以在其前加 virtual 以示清晰。
d，定义一个指基类对象的指针，并使其指向其子类的对象，通过该指针调用虚函数，此时调用的就是指针变量指向对象的同名函数。
e，子类中的覆写的函数，可以为任意访问类型，依子类需求决定。

#include<bits/stdc++.h>
using namespace std;
class Base
{
  public:
    virtual void func()//基类中用virtual声明成员函数为虚函数 
    {
      cout<<"Base"<<endl;
    }
};
class Derive:public Base
{
  private://子类中的覆写的函数，可以为任意访问类型，依子类需求决定 
  //派生类中重新定义func函数称为“覆写”，函数名，返值类型，函数参数个数以及类型全部匹配，根据派生类的需要重新定义函数体 ,virtual可要可不要 
    virtual void func()
    {
      cout<<"Derive"<<endl;
    }
};
int main()
{
    Derive d;
    //d.func();
    Base*p = &d;
    p->func();//输出：Derive 
    return 0;
}