C++ 复习 -- 多态

多态的基本概念(polymorphic)

想象一下，你有一个遥控器（这就像是一个基类的指针），这个遥控器可以控制不同的电子设备这些设备就像是派生类）。无论是电视、音响还是灯光，遥控器上的“开/关”按钮（这个按钮就像是一个虚函数）都能控制它们，但具体的操作（打开电视、播放音乐、开灯）则取决于你指向的设备。

如何实现多态

1. 使用虚函数（Virtual Function）：
我们在基类中定义一个虚函数，这个函数可以在任何派生类中被“重写”或者说“定制”。
使用关键字 virtual 来声明。

2. 创建派生类并重写虚函数：
在派生类中，我们提供该虚函数的具体实现。这就像是告诉遥控器，“当你控制我的这个设备
时，这个按钮应该这样工作”。

3. 通过基类的引用或指针调用虚函数：
当我们使用基类类型的指针或引用来调用虚函数时，实际调用的是对象的实际类型（派生类）中的函数版本

=======================================

case

#include <iostream>

using namespace std;


class RemoteCon{
public:
    void virtual openUtils(){
       cout<<"遥控器的开关呗按下"<<endl;
    }

};

class TVRemoteCon: public RemoteCon{
public:
    void openUtils() override{
    cout<<"电视遥控器的开呗按下"<<endl;
    }
    void test(){};

};

class RoundspeakCon: public RemoteCon{
public:
    void openUtils() override{
    cout<<"音响遥控器的开呗按下"<<endl;
    }

};


class LightCon: public RemoteCon{
public:
    void openUtils() override{
    cout<<"灯光遥控器的开呗按下"<<endl;
    }

};

void  testY(RemoteCon& r)
{
r.openUtils();
}

int main()
{
  RemoteCon * remoteCon =  new TVRemoteCon;
  remoteCon->openUtils();
  //remoteCon->test(); // 调用不到 --> 没实现多态 -->子类对基类的函数重载

  RemoteCon * remoteCon2 =  new RoundspeakCon;
  remoteCon2->openUtils();


  RemoteCon * remoteCon3 =  new LightCon;
  remoteCon3->openUtils();
  TVRemoteCon tvRemote;
  testY(tvRemote);

    return 0;
}

 

为什么使用多态

灵活性：允许我们编写可以处理不确定类型的对象的代码。
可扩展性：我们可以添加新的派生类而不必修改使用基类引用或指针的代码。
接口与实现分离：我们可以设计一个稳定的接口，而将具体的实现留给派生类去处理。

========================================

抽象类:

纯虚函数: -->不能被调用
 void virtual openUtils()=0;

抽象类的基本概念

想象一下，你有一个“交通工具”的概念。这个概念告诉你所有交通工具都应该能做什么，比如移动（move），但它并不具体说明怎么移动。对于不同的交通工具，比如汽车和自行车，它们的移动方式是不同的。在这个意义上，“交通工具”是一个抽象的概念，因为它本身并不能直接被使用。你需要一个具体的交通工具，比如“汽车”或“自行车”，它们根据“交通工具”的概念具体实现了移动的功能。

在 C++ 中，抽象类就像是这样的一个抽象概念。它定义了一组方法（比如移动），但这些方法可能没有具体的实现。这意味着，抽象类定义了派生类应该具有的功能，但不完全实现这些功能

抽象类的特点

1. 包含至少一个纯虚函数：
抽象类至少有一个纯虚函数。这是一种特殊的虚函数，在抽象类中没有具体实现，而是留给派生类去实现。纯虚函数的声明方式是在函数声明的末尾加上 = 0 。

2. 不能直接实例化：
由于抽象类不完整，所以不能直接创建它的对象。就像你不能直接使用“交通工具”的概念去任何地方，你需要一个具体的交通工具。

3. 用于提供基础结构：
抽象类的主要目的是为派生类提供一个共同的基础结构，确保所有派生类都有一致的接口和行为。

case

// 注意:  继承抽象类的子类必须全部 初始化基类的纯虚函数  ，不然也不能被实例化

#include <iostream>
//#include<string>

using namespace std;

class Teacher{
public:
 string name;
 int age;
 string subject;
 virtual void goInClass() =0;
 virtual void startTeaching() =0;
 virtual void overTeaching() =0;
};

class EnglishTeacher :public Teacher{
public:
    void goInClass()override{
        cout<<"英语老师快乐的进入教室"<<endl;
    }

    void startTeaching()override{
        cout<<"英语老师开始上课"<<endl;
    }

    void overTeaching()override{

    }

};

class MathTeacher :public Teacher{
public:
    void goInClass()override{
        cout<<"数学老师严肃的进入教室"<<endl;
    }

    void startTeaching()override{
        cout<<"数学老师开始算数"<<endl;
    }

    void overTeaching()override{
     cout<<"数学老师要拖堂了"<<endl;
    }

};

int main()
{
EnglishTeacher e;
e.goInClass();

//抽象类也支持多天
Teacher *t = new MathTeacher;
t->overTeaching();
    return 0;
}

 

接口:

概念

纯虚函数-接口
在 C++ 中，虽然没有像其他编程语言（比如 Java 中的接口Interface）一样直接定义接口的关键字，但可以通过抽象类和纯虚函数的方式来实现接口的概念。
接口通常用于定义类应该实现的方法，但不提供具体实现。这样的实现方式允许多个类共享相同的接口，同时让每个类根据需要去实现这些接口。

实现步骤

一个类作为接口可以通过以下步骤来实现：

1. 定义抽象类：创建一个包含纯虚函数的抽象类，这些函数构成了接口的一部分。这些函数在抽象类中只有声明而没有具体的实现。
2. 派生类实现接口：派生类继承抽象类，并实现其中的纯虚函数，以具体实现接口定义的方法。

// 其实接口还是 抽象类 --> 针对行为实现

#include <iostream>
using namespace std;
class BasketBallMove{
public:
virtual void passTheBall() = 0;
};
class LiveMove{
public:
virtual void eat() = 0;
virtual void bite() = 0;
virtual void drink() = 0;
virtual void la() = 0;
};
class Human : public LiveMove,BasketBallMove{
public:
void eat() override{};
void bite() override{};
void drink() override{};
void la() override{};
void passTheBall() override{};
};
class Dog : public LiveMove{
public:
void eat() override{};
void bite() override{};
void drink() override{};
void la() override{};
};
int main()
{
Human h;
Dog g;
// LiveMove *l = new LiveMove;
return 0;
}