封装：封装的意义，在于明确标识出允许外部使用的所有成员函数和数据项，或者叫接口。（数据安全机制）

有了封装，就可以明确区分内外，使得类实现者可以修改封装内的东西而不影响外部调用者；而外部调用者也可以知道自己不可以碰哪里。这就提供一个良好的合作基础——或者说，只要接口这个基础约定不变，则代码改变不足为虑。

继承+多态：继承和多态必须一起说。一旦割裂，就说明理解上已经误入歧途了。

先说继承：继承同时具有两种含义：其一是继承基类的方法，并做出自己的改变和/或扩展——号称解决了代码重用问题；其二是声明某个子类兼容于某基类（或者说，接口上完全兼容于基类），外部调用者可无需关注其差别（内部机制会自动把请求派发[dispatch]到合适的逻辑）。（继承就是一种特殊的代码复用功能）

再说多态：基于对象所属类的不同，外部对同一个方法的调用，实际执行的逻辑不同。（简单的理解 多态 == 覆盖和调用虚函数 ）（多态比较复杂，各种骚操作都要用多态实现）

很显然，多态实际上是依附于继承的两种含义的：“改变”和“扩展”本身就意味着必须有机制去自动选用你改变/扩展过的版本，故无多态，则两种含义就不可能实现。

所以，多态实质上是继承的实现细节；那么让多态与封装、继承这两个概念并列，显然是不符合逻辑的。不假思索的就把它们当作可并列概念使用的人，显然是从一开始就被误导了——正是这种误导，使得大多数人把注意力过多集中在多态这个战术层面的问题上，甚至达到近乎恶意利用的程度；同时却忽略了战略层面的问题，这就致使软件很容易被他们设计成一滩稀屎（后面会详细谈论这个）。

image.png
image.png

  1. class Fish // base class 
  2. {    
  3.     // ... Fish's members 
  4. }; 
  6. class Carp:public Fish 
  7. // derived class 
  8. {    
  9.     // ... Carp's members 
  10. };

鱼类世界呈现的一种简单的继承层次结构 

  1. #include <iostream>
  2. #include <string>
  3. using namespace std;
  5. class Fish
  6. {
  7.     public:
  8.         bool is_fresh_water_fish;
  10.         void swim()
  11.         {
  12.             if (is_fresh_water_fish)
  13.             {
  14.                 cout  << "Swims in lake" << endl;
  15.             }
  16.             else
  17.             {
  18.                 cout << "Swims in sea" << endl;
  19.             }
  21.         }
  22. };
  25. class Tuna: public Fish
  26. {
  27.     public:
  28.         Tuna(){
  29.             is_fresh_water_fish = false;
  30.         }
  31. };
  33. class Carp: public Fish
  34. {
  35.     public:
  36.         Carp()
  37.         {
  38.             is_fresh_water_fish = true;
  39.         }
  40. };
  42. int main(){
  43.     Carp my_lunch;
  44.     Tuna my_dinner;
  45.     cout << "About my food: " << endl;
  46.     cout << "Lunch: ";
  48.     my_lunch.swim();
  49.     cout << "Dinner: ";
  50.     my_dinner.swim();
  52.     return 0;
  53. }

基类初始化—向基类传递参数

如果基类包含重载的构造函数，需要在实例化时给它提供实参，该如何办呢？创建派生对象时将 如何实例化这样的基类？方法是使用初始化列表，并通过派生类的构造函数调用合适的基类构造函数

  1. class Base 
  2. { 
  3.     public:  Base(int someNumber) // overloaded constructor    
  4.     {       
  5.         // Use someNumber    
  6.     } 
  7. }; 
  9. Class Derived: public Base { 
  10.     public:  Derived(): Base(25) // instantiate Base with argument 25    
  11.     {       
  12.         // derived class constructor code    
  13.     } 
  14. };

对 Fish 类来说，这种机制很有用。通过给 Fish 的构造函数提供一个布尔输入参数，以初始化 Fish::isFreshWaterFish，可强制每个派生类都指出它是淡水鱼还是海水鱼

  1. #include <iostream>
  2. #include <string>
  3. using namespace std;
  5. class Fish
  6. {
  7.     protected:
  8.         bool is_fresh_water_fish;
  9.     public:
  10.         Fish(bool is_fresh_water): is_fresh_water_fish(is_fresh_water){}
  12.         void swim()
  13.         {
  14.             if (is_fresh_water_fish){
  15.                 cout  << "Swims in lake" << endl;
  16.             }
  17.             else{
  18.                 cout << "Swims in sea" << endl;
  19.             }
  20.         }
  21. };
  23. class Tuna: public Fish
  24. {
  25.     public:
  26.         Tuna():Fish(false) {}
  27. };
  29. class Carp: public Fish
  30. {
  31.     public:
  32.         Carp():Fish(true){}
  33. };
  35. int main(){
  36.     Carp my_lunch;
  37.     Tuna my_dinner;
  38.     cout << "About my food: " << endl;
  39.     cout << "Lunch: ";
  41.     my_lunch.swim();
  42.     cout << "Dinner: ";
  43.     my_dinner.swim();
  45.     return 0;
  46. }

在派生类中覆盖基类的方法

如果派生类实现了从基类继承的函数，且返回值和特征标相同，就相当于覆盖了基类的这个方法， 如下面的代码所示： 

  1. class Base 
  2. {
  3.     public:    
  4.         void DoSomething()    
  5.         {       
  6.             // implementation code… Does something    
  7.         } 
  8. }; 
  10. class Derived:public Base 
  11. { 
  12.     public:    
  13.         void DoSomething()    
  14.         {       
  15.         // implementation code… Does something else    
  16.         } 
  17. };

因此，如果使用 Derived 类的实例调用方法 DoSomething( )，调用的将不是 Base 类中的这个方法。如果 Tuna 和 Carp 类实现了自己的 Swim( )方法，则在程序清单 10.3 的 main( )中下述代码将调用Tuna::Swim( )的实现，这相当于覆盖了基类 Fish 的方法 Swim( )：

在派生类中调用基类的方法

通常，Fish::Swim( )包含适用于所有鱼类（包括金枪鱼和鲤鱼）的通用实现。如果要在 Tuna::Swim( ) 和 Carp::Swim( )的实现中重用 Fish::Swim( )的通用实现，可使用作用域解析运算符（::），如下面的代码所示： 

  1. class Carp: public Fish
  2. { 
  3.     public:    
  4.          Carp(): Fish(true) {} 
  5.            void Swim()
  6.           {       
  7.               cout << "Carp swims real slow" << endl;
  8.               Fish::Swim(); // invoke base class function using operator::
  9.           } 
  10. };

在基类方法和 main( )中，使用作用域解析运算符（::）来调用基类方法 

  1. #include <iostream>
  2. #include <string>
  3. using namespace std;
  5. class Fish
  6. {
  7.     private:
  8.         bool is_fresh_water_fish;
  10.     public:
  11.         Fish(bool is_fresh_water): is_fresh_water_fish(is_fresh_water){}
  13.         void swim()
  14.         {
  15.             if (is_fresh_water_fish){
  16.                 cout  << "Swims in lake" << endl;
  17.             }
  18.             else{
  19.                 cout << "Swims in sea" << endl;
  20.             }
  21.         }
  22. };
  25. class Tuna: public Fish
  26. {
  27.     public:
  28.         Tuna():Fish(false) {}
  30.         void swim()
  31.         {
  32.             cout << "Tuna swims real fast, ";
  33.         }
  34. };
  36. class Carp: public Fish
  37. {
  38.     public:
  39.         Carp():Fish(true){}
  41.         void swim()
  42.         {
  43.             cout << "Carp swims real slow, ";
  44.             Fish::swim();
  45.         }
  46. };
  48. int main(){
  49.     Carp my_lunch;
  50.     Tuna my_dinner;
  51.     cout << "About my food: " << endl;
  52.     cout << "Lunch: ";
  54.     my_lunch.swim();
  55.     cout << "Dinner: ";
  56.     my_dinner.swim();
  57.     my_dinner.Fish::swim();
  59.     return 0;
  60. }

image.png