最新多态练习题

合集下载

多态练习题

1、生成表示学生的类XS，提供成员函数dispXM（）、dispXB（）和dispNL（）分别用来显示姓名、性别和年龄，并将他们全部定义为纯虚函数；生成CZS类表示初中生，包含数据成员xm、xb和nl表示学生的姓名、性别和年龄，提供成员函数dispXM（）、dispXB（）和dispNL()分别用来显示姓名、性别和年龄；再生成类GZS表示高中生和类DXS表示大学生，同样包含相同含义的数据成员xm、xb和nl，也包括成员函数dispXM（）、dispXB（）和dispNL（）。

要求：（1）设计和实现基本类XS（2）设计和实现派生类CZS,GZS和DXS（3）分别生成CZS、GZS、DXS类对象（4）将CZS、GZS、DXS类对象的指针赋给指针赋给XS类的指针变量。

（5）分别用XS类的指针和引用访问dispXM（）、dispXB（）和dispNL（）函数。

（6）观察程序结果。

#include <iostream>#include <string.h>using namespace std;class XS{public:virtual void dispXM()=0;virtual void dispXB()=0;virtual void dispNL()=0;};class CZS:public XS{public:CZS(char * m="张三",int b=1,int n=14);void dispXM();void dispXB();void dispNL();protected:char xm[9];int xb,nl;};CZS::CZS(char *m,int b,int n){strcpy(xm,m);xb=b,nl=n;}void CZS::dispXM(){cout<<"name:"<<xm<<endl;}void CZS::dispXB(){if(xb==1)cout<<"Man"<<endl;if(xb==0)cout<<"Woman"<<endl;}void CZS::dispNL(){cout<<"age:"<<nl<<endl;}class GZS:public XS{public:GZS(char * m="张三",int b=1,int n=17);void dispXM();void dispXB();void dispNL();protected:char xm[9];int xb,nl;};GZS::GZS(char *m,int b,int n){strcpy(xm,m);xb=b,nl=n;}void GZS::dispXM(){cout<<"name:"<<xm<<endl;}void GZS::dispXB(){if(xb==1)cout<<"Man"<<endl;if(xb==0)cout<<"Woman"<<endl;}void GZS::dispNL(){cout<<"age:"<<nl<<endl;}class DXS:public XS{public:DXS(char * m="张三",int b=1,int n=20);void dispXM();void dispXB();void dispNL();protected:char xm[9];int xb,nl;};DXS::DXS(char *m,int b,int n){strcpy(xm,m);xb=b,nl=n;}void DXS::dispXM(){cout<<"name:"<<xm<<endl;}void DXS::dispXB(){if(xb==1)cout<<"Man"<<endl;if(xb==0)cout<<"Woman"<<endl; }void DXS::dispNL(){cout<<"age:"<<nl<<endl;}void displayP(XS *p){p->dispXM();p->dispXB();p->dispNL();}void displayR( XS &p){p.dispXM();p.dispXB();p.dispNL();}void main(){CZS czs("赵一",1,12);GZS gzs("钱二",0,15);DXS dxs("孙三",1,18);XS *p;//定义抽象基类的指针变量pp=&czs;//将初中生对象czs的地址赋给pdisplayP(p);p=&gzs;//将高中生对象czs的地址赋给pdisplayP(p);p=&dxs;//将大学生对象czs的地址赋给pdisplayP(p);cout<<"\n----------------------------------------\n";XS &r1=czs;//定义抽象基类的引用变量r1为czs的别名displayR(r1);XS &r2=gzs;//定义抽象基类的引用变量r2为czs的别名displayR(r2);XS &r3=dxs;//定义抽象基类的引用变量r3为czs的别名displayR(r3);cout<<"\n----------------------------------------\n";}2、某小型公司主要有3类人员：经理、兼职技术人员、兼职销售员。

C++练习题多态

态
1. 计算三角形，正方形和圆形三种图形的面积，周长提示：设计基类shape，让三角形、正方形、圆形均继承自此类。在shape中实现相应的计算面积、周长的虚函数，然后在子类中改写这些虚函数。 2. 车辆类，派生小轿车，卡车，吉普车，收费站对来往车辆收费提示：思路与上题类似 3.写一个程序，建立两个类型的表，队列和堆栈，使它们可以通过共用的接口访问。 list stack queue store() retrieve() 提示：此题可以先构建一个抽象类list，其内部申明公共接口为纯虚函数。然后队列和堆栈继承自list并改写这些纯虚函数。

Java多态练习

Java多态练习Java-Java多态作业练习第⼀题定义⼀个⾓⾊类，该类中包含⾓⾊的攻击⼒、⾓⾊名称、技能，同时产⽣出3中不同的⾓⾊(德玛西亚、寒冰射⼿、后羿)在创建该3中⾓⾊类的时候通过构造⽅法将当前⾓⾊所对应的⾓⾊属性值传递给⽗类完成⾓⾊创建。

再定义⼀个游戏类，该类中提供⼀个创建⾓⾊的⽅法和释放技能的⽅法，定义⼀个测试类，通过控制台提⽰完成⾓⾊的技能是否操作。

控制台提⽰要求：1、请选择需要创建的英雄：1、德玛西亚2、寒冰射⼿3、后羿2、在选择后控制台提⽰XXX英雄被创建3、提⽰请选择是否释放技能？ 1、释放 2、不释放4、如果选择1控制台就提⽰ XXX英雄，成功释放XXX技能如果选择2 直接程序结束。

提⽰游戏结束。

第⼆题（1）定义⼀个宠物类(Pet),它有两个⽅法：叫cry(),吃东西eat(),定义宠物的⼦类狗(Dog),猫(Cat),覆盖⽗类的cry(),eat()⽅法，⾥⾯写System.out.println("猫吃了鱼")这样的打印语句,另外狗有⾃⼰的⽅法看门guardEntrance()，猫⾃⼰独有的⽅法捉⽼⿏huntMice()定义⼀个Test类,在main中定义两个Pet变量,pet1,pet2，采⽤引⽤转型实例化Dog,Cat,分别调⽤Pet的cry(),eat();(2)将Pet引强制转换为具体的Dog，Cat，在调Dog的guardEntrance（），Cat的huntMice()（提⽰：先⽤instanceof进⾏类型判断）Pet p = new Dog()p.guradEntrance()(3)（思考）编写PetPark类，添加喂养宠物feedPet(Pet pet)的⽅法,在feedPet中调cry(),eat()⽅法,实例化PetPark类，再测试类中实例化狗 Dog dog = new Dog(), 猫 Pet cat = new Cat(),PetPark分别调feedPet()⽅法分别传参数cat,dog。

java多态的练习题

java多态的练习题在Java编程语言中，多态是面向对象编程中的一个重要概念。

通过多态的机制，我们可以使用父类引用指向子类对象，从而实现对不同对象的统一操作。

在本文中，将提供一些Java多态的练习题，以帮助读者更好地理解和掌握多态的应用。

练习一：假设有一个Animal类，其中包含了一个名为"sayHello()"的方法。

请根据以下要求创建相应的子类和实现方法：1. 创建两个子类，分别为Cat和Dog类；2. 在Cat类中重写sayHello()方法，使其输出"Hello, I am a cat!"；3. 在Dog类中重写sayHello()方法，使其输出"Hello, I am a dog!"；4. 创建一个Animal数组，使用多态的方式分别将Cat和Dog的对象存入数组中；5. 遍历Animal数组，并调用每个对象的sayHello()方法。

练习二：假设有一个Shape类，其中包含了一个名为"getArea()"的抽象方法。

请根据以下要求创建相应的子类和实现方法：1. 创建两个子类，分别为Circle和Square类；2. 分别在Circle类和Square类中实现getArea()方法，使其分别计算圆的面积和正方形的面积；- 圆的面积计算公式为：π * r * r；- 正方形的面积计算公式为：边长 * 边长；3. 创建一个Shape数组，使用多态的方式分别将Circle和Square的对象存入数组中；4. 遍历Shape数组，并调用每个对象的getArea()方法，输出每个图形的面积。

练习三：假设有一个Vehicle类，其中包含了一个名为"start()"的方法。

请根据以下要求创建相应的子类和实现方法：1. 创建三个子类，分别为Car、Bicycle和Motorcycle类；2. 在Car类中实现start()方法，使其输出"Car starts with engine!"；3. 在Bicycle类中实现start()方法，使其输出"Bicycle starts with pedal power!"；4. 在Motorcycle类中实现start()方法，使其输出"Motorcycle starts with kick start!"；5. 创建一个Vehicle数组，使用多态的方式分别将Car、Bicycle和Motorcycle的对象存入数组中；6. 遍历Vehicle数组，并调用每个对象的start()方法。

第三次练习多态练习

1．类中可以有许多相同名称，但参数类型或个数不同的成员函数，称为重载。

2．若a和b为int变量，则a+b可求和；若c和d为float变量，则c+d可求和；“+”具有不同的用途，这是运算符重载的例子。

3．运算符函数中的关键字是operator，它和运算符一起组成该运算符函数的函数名。

4．类中运算符重载一般采用两种形式：成员函数和友元函数。

5．对于双目运算符，若重载为类的成员函数，有1个参数；若重载为友元函数，则有 2 个参数。

6．面向对象程序设计的3大机制为：封装、继承、多态7．在编译时就解决的函数调用称为静态联编(绑定)；在运行是才解决的函数调用称为动态联编(绑定)。

8．如果一个类中有一个或多个纯虚函数，则这个类称为抽象类。

二．写出运行结果1．#include<iostream>using namespace std;class Sample{ private: int x;public : Sample( ){ }Sample(int a ){x=a; }void disp(){cout<<"x="<<x<<endl;}Sample operator+(Sample &);friend Sample operator-(Sample &,Sample &);};Sample Sample ::operator+(Sample &s){return Sample(x+s.x); }Sample operator-(Sample &s1,Sample &s2){return Sample(s1.x-s2.x); }int main(){ Sample obj1(5),obj2(10),obj3;obj3=obj1+obj2;obj3.disp();(obj1-obj2).disp();}x=15x=-52．#include<iostream>#include "cstring"using namespace std;class Sample{ private: char *str;public : Sample(char *s ){str=new char[strlen(s)+1];strcpy(str,s);}void disp(){cout<<"str="<<str<<endl;}char & operator[](int);};char & Sample::operator[](int i){return *(str+i);}{ char *s="olympics";Sample obj(s);obj.disp();int n=strlen(s);while(n>=0){ obj[n-1]=obj[n-1]-32;n--;}obj.disp();}str=olympicsstr=OLYMPICS3．#include<iostream>using namespace std;class base{ private: int b;public : base(int x=0){b=x;}virtual void show(){cout<<"base::b"<<b<<endl;cout<<"base::show()被调用！"<<endl;}};class derived:public base{private: int d;public : derived(int y=-1){d=y;}virtual void show(){cout<<"derived::d"<<d<<endl;cout<<"derived::show()被调用！"<<endl;}};int main(){ derived d;void(base::*fp)();fp=&base::show;(d.*fp)();}derived::d-1derived::show()被调用！4．//分析程序，该程序有问题吗？如果有，怎么改？#include<iostream>#include "cstring"using namespace std;class string{ private: char *str;public: string(char *s=" "){str=new char[strlen(s)+1];strcpy(str,s);}~string(){delete []str;}void print(){cout<<str<<endl;}};int main( ){string s1("abcd"), s2(" ");s2=s1;cout<<"s2: ";s2.print( );cout<<"s1: ";s1.print();}//改正的程序#include<iostream>#include "cstring"using namespace std;class string{private: char *str;public: string(char *s=" "){str=new char[strlen(s)+1];strcpy(str,s);}~string(){delete []str;}void print(){cout<<str<<endl;}string &operator=(const string &s);};string & string::operator=(const string &s){if (this==&s) return *this;delete []str;str=new char[strlen(s.str)+1];strcpy(str,s.str);return *this;}void main( ){string s1("abcd");string s2("");s2=s1;cout<<"s2: ";s2.print( );cout<<"s1: ";s1.print();}5．#include<iostream>using namespace std;class base{ public :base(){fc();}virtual void fc(){cout<<"in class base"<<endl;}virtual ~base(){cout<<"Destructing base object"<<endl;}};class A:public base {public:A(){fc( );}void f(){fc();}~A(){fd();}void fd(){cout<<"Destructing A obj"<<endl;} };class B:public A {public: B(){}void fc(){cout<<"In class B"<<endl;}~B(){fd();}void fd(){cout<<"Destructing B obj"<<endl;} };int main( ){ B b;b.fc();base *p=new A;delete p;}in class basein class baseIn class Bin class basein class baseDestructing A objDestructing base objectDestructing B objDestructing A objDestructing base object。

java多态练习题

java多态练习题Java多态是一种允许不同类的对象对同一消息做出响应的机制，主要通过继承和接口实现。

以下是一些Java多态的练习题，旨在帮助学生更好地理解和掌握Java多态的概念。

1. 理解多态的概念- 描述什么是Java中的多态性，并给出一个简单的例子。

2. 多态的实现方式- 列出Java中实现多态的两种主要方式，并解释它们的区别。

3. 重载与重写- 解释方法重载（overloading）和方法重写（overriding）的概念，并给出一个例子，展示如何使用它们来实现多态。

4. 向上转型- 给出一个代码示例，展示如何通过向上转型来实现多态。

5. 接口与抽象类- 解释接口和抽象类在实现多态中的作用，并给出一个使用接口实现多态的例子。

6. 动态绑定- 描述动态绑定的概念，并解释它是如何与多态性相关联的。

7. 多态与继承- 编写一个Java程序，展示继承如何与多态性一起工作，创建一个基类和几个派生类，然后使用基类引用来调用派生类的方法。

8. 多态与数组- 编写一个Java程序，展示如何使用多态性将不同类型的对象存储在同一个数组中。

9. 多态与方法调用- 编写一个Java程序，展示如何使用多态性在运行时调用正确的方法。

10. 多态与构造函数- 编写一个Java程序，展示如何在多态性的情况下调用构造函数。

11. 多态与异常处理- 编写一个Java程序，展示如何在多态性的情况下使用异常处理。

12. 多态与泛型- 编写一个Java程序，展示如何结合使用多态性和泛型。

13. 多态与设计模式- 描述多态性如何在设计模式中发挥作用，并给出一个使用设计模式实现多态性的例子。

14. 多态与性能- 讨论多态性对Java程序性能的潜在影响，并给出优化多态性使用的建议。

15. 多态与反射- 描述反射机制如何与多态性结合使用，并给出一个使用反射实现多态性的例子。

16. 多态与类型安全- 讨论Java中多态性与类型安全的关系，并给出一个示例，展示如何在多态性的情况下保持类型安全。

c++多态性相关习题

多态性10.2 典型例题分析与解答例题1：指出下列对定义重载函数的要求中，哪些是错误的提法。

A．要求参数的个数不同。

B.要求参数中至少有一个类型不同。

C．求函数的返回值不同。

D. 要求参数的个数相同时，参数类型不同。

答案：C例题3：下面关于友元的描述中，错误的是（）。

A. 友元函数可以访问该类的私有数据成员B. 一个类的友元类中的成员函数都是这个类的友元函数C. 友元可以提高程序的运行效率D. 类与类之间的友元关系可以继承答案：D例题4：下述静态成员的特性中，（）是错误的。

A. 静态成员函数不能利用this指针B. 静态数据成员要在类体外进行初始化C. 引用静态数据成员时，要在静态数据成员名前加<类名>和作用域运算符页脚内容1D. 静态数据成员不是所有对象所共有的答案：D例题5：关于虚函数的描述中，（）是正确的。

A. 虚函数是一个静态成员函数B. 虚函数是一个非成员函数C. 虚函数既可以在函数说明时定义，也可以在函数实现时定义D. 派生类的虚函数与基类中对应的虚函数具有相同的参数个数和类型参考答案：D例题11：分析下列程序的输出结果。

#include <iostream.h>class A{public:A() { cout<<"A's cons."<<endl; }virtual ~A() { cout<<"A's des."<<endl; }virtual void f() { cout<<"A's f()."<<endl; }页脚内容2void g() { f(); }};class B : public A{public:B() { f(); cout<<"B's cons."<<endl; }~B() { cout<<"B's des."<<endl; }};class C : public B{public:C() { cout<<"C's cons."<<endl; }~C() { cout<<"C's des."<<endl; }void f() { cout<<"C's f()."<<endl; }};void main(){ A *a=new C;a->g();delete a;页脚内容3}运行结果：A's cons.A's f().B's cons.C's cons.C's f().C's des.B's des.A's des.10．3 教材习题解答1．选择题（1）下列关于动态联编的描述中，错误的是（）。

C++多态练习题

C++多态练习题⼀、填空题（1）C++的两种联编⽅式为：动态联编和静态联编。

（2）C++⽀持两种多态性，静态联编所⽀持的多态性被称为编译时的多态性、动态联编所⽀持的多态性被称为运⾏时的多态性。

（3）重载函数在编译时表现出多态性，是静态联编；⽽虚函数则在运⾏时表现出多态性是动态联编。

（4）为了区分重载函数，把⼀个派⽣类中重定义基类的虚函数称为覆盖。

（5）如果派⽣类与基类的虚函数仅仅返回类型不同，其余相同，则c++认为是使⽤了不恰当的虚函数。

（6）在构造函数和析构函数中调⽤虚函数时，采⽤静态联编。

（7）纯函数的定义是在虚函数定义的基础上，再让函数等于0 。

（8）对于包含有纯虚函数的类被称为抽象类。

⼆、选择题（⾄少选⼀个，可以多选）（1）⽤关键字（A）标记的函数被称为虚函数。

A.virtualB.privateC.publicD.protected（2）在C++中，要实现动态联编，必须使⽤（D）调⽤虚函数。

A.类名B.派⽣类指针C.对象名D.基类指针（3）下列函数中，可以作为虚函数的是（BD）。

A.普通函数B.⾮静态成员函数C.构造函数D.析构函数（4）在派⽣类中，重载⼀个虚函数时，要求函数名、参数的个数、参数的类型、参数的顺序和函数的返回值（B）。

A.不同B.相同C.相容D.部分相同（5）使⽤虚函数保证了在通过⼀个基类类型的指针（含引⽤）调⽤⼀个虚函数时，c++系统对该调⽤进⾏（A），但是，在通过⼀个对象访问⼀个虚函数，使⽤（B）。

A.动态联编B.静态联编C.动态编译D.静态编译（6）下⾯函数原型声明中，（C）声明的fun()为纯虚函数。

A.void func()=0;B.virtual void func()=0;B.virtual void func();C.virtual void func(){};（7）若⼀个类中含有纯虚函数，则该类称为（C）。

A.基类B.虚基类C.抽象类D.派⽣类（8）假设Myclass为抽象类，下列声明（CD）是错误的。

c++多态性相关习题

多态性10.2 典型例题分析与解答例题1：指出下列对定义重载函数的要求中，哪些是错误的提法。

A．要求参数的个数不同。

B.要求参数中至少有一个类型不同。

C．求函数的返回值不同。

D. 要求参数的个数相同时，参数类型不同。

答案： C例题3：下面关于友元的描述中，错误的是（）。

A. 友元函数可以访问该类的私有数据成员B. 一个类的友元类中的成员函数都是这个类的友元函数C. 友元可以提高程序的运行效率D. 类与类之间的友元关系可以继承答案：D1例题4：下述静态成员的特性中，（）是错误的。

A. 静态成员函数不能利用this指针B. 静态数据成员要在类体外进行初始化C. 引用静态数据成员时，要在静态数据成员名前加<类名>和作用域运算符D. 静态数据成员不是所有对象所共有的答案：D例题5：关于虚函数的描述中，（）是正确的。

A. 虚函数是一个静态成员函数B. 虚函数是一个非成员函数C. 虚函数既可以在函数说明时定义，也可以在函数实现时定义D. 派生类的虚函数与基类中对应的虚函数具有相同的参数个数和类型参考答案：D2例题11：分析下列程序的输出结果。

#include <iostream.h>class A{public:A() { cout<<"A's cons."<<endl; }virtual ~A() { cout<<"A's des."<<endl; }virtual void f() { cout<<"A's f()."<<endl; } void g() { f(); }};class B : public A{public:B() { f(); cout<<"B's cons."<<endl; }3~B() { cout<<"B's des."<<endl; }};class C : public B{public:C() { cout<<"C's cons."<<endl; }~C() { cout<<"C's des."<<endl; }void f() { cout<<"C's f()."<<endl; }};void main(){ A *a=new C;a->g();delete a;}4运行结果：A's cons.A's f().B's cons.C's cons.C's f().C's des.B's des.A's des.10．3 教材习题解答1．选择题（1）下列关于动态联编的描述中，错误的是（）。

java 多态练习题

java 多态练习题Java多态练习题Java中的多态是面向对象编程的重要概念之一，它允许我们根据实际情况使用不同的子类对象来调用同一个父类方法。

接下来，我们将通过一些练习题来巩固对Java多态性的理解。

练习一：假设有一个"动物"类Animal，该类中有一个名为"动"的方法move()，其中输出"动物可以移动"的信息。

现在有两个子类"狗"类Dog和"猫"类Cat，它们继承自Animal类，并分别重写了move()方法。

请编写一个测试类PolymorphismTest，创建Animal、Dog和Cat的对象，并分别调用它们的move()方法。

练习二：假设有一个"形状"类Shape，其中有一个名为"计算面积"的方法calculateArea()，其中输出"计算面积"的信息。

现在有三个子类"圆形"类Circle、"矩形"类Rectangle和"三角形"类Triangle，它们都继承自Shape 类，并分别重写了calculateArea()方法。

请编写一个测试类PolymorphismTest2，创建Circle、Rectangle和Triangle的对象，并分别调用它们的calculateArea()方法。

练习三：假设有一个"手机"类Phone，其中有一个名为"打电话"的方法call()，其中输出"正在打电话"的信息。

现在有两个子类"智能手机"类SmartPhone和"老式手机"类OldPhone，它们都继承自Phone类，并分别重写了call()方法。

请编写一个测试类PolymorphismTest3，创建SmartPhone和OldPhone的对象，并分别调用它们的call()方法。

05.多态_练习题

高质量C++编程练习题
1
第5章多态练习
多态练习：第一部分第二部分
时间：6 学时
教学方法：学员练习
2
第5章多态_练习 part1
•
1、【基本题】定义一个Person类，它包含数据成员age, name和gender。从Person中派生一个类Employee,在新类中添加一个数据成员，存储个人的number.再从Employee中派生一个类Executive,每个派生类都应该定义一个函数，来显示相关的信息（名称和类型，如”Fred Smith is an Employee”）。编写一个main()函数，生成两个数组，一个数组包含5个Executive对象，另一个数组包含5个一般的 Employee对象，然后显示它们的信息。另外，调用从 Employee类继承的成员函数，显示Executive信息。 2.【基本题】设计一个图书管理系统,基类为类Book,要求有书名和作者属性，由Book类派生子类AudioBook(有声书，需要具有演说者属性)，对于Book和AudioBook进行合理的属性及行为的抽象，同时实现该类的print函数（注意，类体系中的每个类都要设计合适的构造函数和析构函数）
•
3
第5章多态练习
多态练习：第一部分第二部分
时间：6 学时
教学方法：学员练习
4
【基本题】定义了一个基类Animal, 它包含两个数据成员动物名称（string类型）和重量，还包含一个公共的虚拟成员函数who() 和一个纯虚函数sound(),公共的虚拟成员函数who(), 返回一个string对象，在派生类中sound()应返回一个string 对象，表示该动物发出的声音。把Animal类作为一个公共基类,派生三个子类Sheep，Dog和Cow,在每个类中实现 sound()函数。定义一个类Zoo,它至多可以在一个数组中存储 50种不同类型的动物（使用指针数组）。编写一个main()函数，创建给定数量的派生类对象的随机序列，在Zoo对象中存储这些对象的指针。使用Zoo对象的一个成员函数，输出Zoo中每个动物的信息，以及每个动物发出的声音。(注意使用多文件结构)

多态的练习题

多态的练习题多态（Polymorphism）是面向对象编程的重要特性之一，在实际应用中起到了非常关键的作用。

掌握多态的概念和使用方法对于提高程序的灵活性和可扩展性至关重要。

本文将介绍一些多态的练习题，帮助读者巩固对多态的理解和运用。

1. 题目一：动物的叫声我们有多种动物，包括狗、猫和鸟等，它们都有自己特有的叫声。

请使用多态的方式来实现一个动物类 Animal，以及各个具体动物的子类（Dog、Cat、Bird）。

在 Animal 类中定义一个名为 makeSound 的方法，用于输出不同动物的叫声。

在子类中重写该方法，分别输出对应动物的叫声。

示例代码：```javapublic class Animal {public void makeSound() {System.out.println("动物发出叫声");}}public class Dog extends Animal {@Overridepublic void makeSound() {System.out.println("狗狗汪汪叫"); }}public class Cat extends Animal {@Overridepublic void makeSound() {System.out.println("喵喵喵");}}public class Bird extends Animal {@Overridepublic void makeSound() {System.out.println("鸟儿唧唧叫"); }}public class Main {public static void main(String[] args) { Animal[] animals = new Animal[3];animals[0] = new Dog();animals[1] = new Cat();animals[2] = new Bird();for (Animal animal : animals) {animal.makeSound();}}}```2. 题目二：几何图形的面积计算我们有三种几何图形：圆形、矩形和三角形，它们都有自己对应的面积计算公式。

java 多态选择题

java 多态选择题一、单选题1. 多态性的基础是（）。

A. 继承B. 接口C. 抽象类D. 方法重写答案是：D. 方法重写。

多态性是指不同对象对同一消息有不同的响应，在Java中，可以通过方法重写来实现多态性。

2. 下列哪个选项不是多态的特性（）。

A. 方法重载B. 参数传递C. 向上转型D. 向下转型答案是：A. 方法重载。

多态性包括方法重载和参数传递等特性，向上转型和向下转型是多态的体现形式之一。

3. 在Java中，实现多态的方式有（）。

A. 继承和接口B. 继承和抽象类C. 继承和接口，抽象类都有用D. 类直接实现接口答案是：A. 继承和接口。

在Java中，实现多态的方式有两种：继承和接口。

向上转型和向下转型也是多态的体现形式。

4. 关于接口和多态的关系，以下说法正确的是（）。

A. 接口不能被实例化，只能被继承B. 接口可以用来实现多态，但不能通过接口引用实现多态的类对象C. 实现多态的类必须实现接口的所有方法D. 以上说法都不对答案是：D. 以上说法都不对。

接口可以用来实现多态，可以通过接口引用实现多态的类对象，实现多态的类不一定需要实现接口的所有方法。

5. 在Java中，以下哪个关键字用于实现多态（）。

A. extends 和 implementsB. extends 和 finalC. extends 和 interfaceD. override 和 extends答案是：D. override 和 extends。

Java中，关键字override和extends用于实现多态。

override用于子类重写父类的方法，extends用于继承父类的接口或抽象类。

二、多选题1. 多态性的表现形式有（）等。

A. 向上转型B. 向下转型C. 方法重载D. 方法重写E. 参数传递答案是：ADE。

多态性的表现形式包括向上转型、向下转型、方法重载和方法重写，也涉及到参数传递等特性。

2. 下列哪些选项体现了Java中的多态性（）A. 子类对象替换父类对象B. 使用父类的引用指向子类对象C. 使用接口引用指向实现了该接口的类对象D. 使用方法重载实现多态性答案是：ABCD。

多态的练习题

多态的练习题看程序，说出运算结果题⽬（1）/*看程序写结果:先判断有没有问题，如果没有，写出结果*/class Fu {public void show() {System.out.println("fu show");}}class Zi extends Fu {public void show() {System.out.println("zi show");}public void method() {System.out.println("zi method");}}class DuoTaiTest3 {public static void main(String[] args) {Fu f = new Zi();//找不到符号//f.method();//运⾏这个会报错f.show();}}题⽬（2）/*看程序写结果:先判断有没有问题，如果没有，写出结果多态的成员访问特点：⽅法：编译看左边，运⾏看右边。

继承的时候：⼦类中有和⽗类中⼀样的⽅法，叫重写。

⼦类中没有⽗亲中出现过的⽅法，⽅法就被继承过来了。

*/class A {public void show() {show2();}public void show2() {System.out.println("我");}}class B extends A {/*public void show() {show2();}*///这⾥的意思是B继承了A的show⽅法，因为类B并没有⾃⼰所属的show⽅法public void show2() {System.out.println("爱");}}class C extends B {public void show() {super.show();}public void show2() {System.out.println("你");}}public class DuoTaiTest4 {public static void main(String[] args) { A a = new B();a.show();B b = new C();b.show();}}最终答案是：爱你为了熟悉多态，写出了以下案例理解部分案例：猫狗案例：/*多态练习：猫狗案例*/class Animal {public void eat(){System.out.println("吃饭");}}class Dog extends Animal {public void eat() {System.out.println("狗吃⾁");}public void lookDoor() {System.out.println("狗看门");}}class Cat extends Animal {public void eat() {System.out.println("猫吃鱼");}public void playGame() {System.out.println("猫捉迷藏");}}class DuoTaiTest {public static void main(String[] args) {//定义为狗Animal a = new Dog();a.eat();System.out.println("--------------");//还原成狗Dog d = (Dog)a;d.eat();d.lookDoor();System.out.println("--------------");//变成猫a = new Cat();a.eat();System.out.println("--------------");//还原成猫Cat c = (Cat)a;c.eat();c.playGame();System.out.println("--------------");//演⽰错误的内容//Dog dd = new Animal();//Dog ddd = new Cat();//ClassCastException//Dog dd = (Dog)a;}}南北⽅⼈案例：/*不同地⽅饮⾷⽂化不同的案例*/class Person {public void eat() {System.out.println("吃饭");}}class SouthPerson extends Person { public void eat() {System.out.println("炒菜,吃⽶饭"); }public void jingShang() {System.out.println("经商");}}class NorthPerson extends Person {public void eat() {System.out.println("炖菜,吃馒头"); }public void yanJiu() {System.out.println("研究");}}class DuoTaiTest2 {public static void main(String[] args) { //测试//南⽅⼈Person p = new SouthPerson();p.eat();System.out.println("-------------");SouthPerson sp = (SouthPerson)p; sp.eat();sp.jingShang();System.out.println("-------------");//北⽅⼈p = new NorthPerson();p.eat();System.out.println("-------------");NorthPerson np = (NorthPerson)p; np.eat();np.yanJiu();}}。

多态及练习题

多态及练习题多态就是⽗类引⽤指向⼦类对象例如Animal a = new Dog();//向上转型多态必须使⽤向下转型的时候：当在其他类中调⽤⼦类对象中独有的⽅法的时候需要向下转型 Animal a = new Dog(); Dog d = (Dog) a;//向下转型多态在实际中的应⽤实际上就是为了程序的扩展性，OCP原则，关闭修改性，提⾼可扩展性，尽可能的少修改代码/*测试多态1.编写程序实现乐⼿弹奏乐器。

乐⼿可以弹奏不同的乐器从⽽发出不同的声⾳。

可以弹奏的乐器包括⼆胡、钢琴和琵琶。

实现思路及关键代码：1)定义乐器类Instrument，包括⽅法makeSound()2)定义乐器类的⼦类：⼆胡Erhu、钢琴Piano和⼩提琴Violin3)定义乐⼿类Musician，可以弹奏各种乐器play(Instrument i)4)定义测试类，给乐⼿不同的乐器让他弹奏*/public class TestMusic{public static void main(String[] args){Musician m = new Musician();Violin v = new Violin();m.play(v);}}class Instrument{public void makeSound(){System.out.println("乐器发声");}}class Erhu extends Instrument{public void makeSound(){System.out.println("⼆胡在拉");}}class Piano extends Instrument{public void makeSound(){System.out.println("弹钢琴");}}class Violin extends Instrument{public void makeSound(){System.out.println("拉⼩题琴");}}class Musician{public void play(Instrument i){i.makeSound();}}/*编写程序模拟“主⼈”喂养“宠物”的场景：提⽰1：主⼈类：Master宠物类：Pet宠物类⼦类：Dog、Cat、YingWu提⽰2：主⼈应该有喂养的⽅法：feed()宠物应该有吃的⽅法：eat()只要主⼈喂宠物，宠物就吃。

多态调用练习题

多态调用练习题多态是面向对象编程中一个重要的概念，它允许同一个方法在不同的对象上有不同的行为。

这篇文章将通过练习题的方式来帮助读者理解和掌握多态的概念和应用。

题目一：形状类与矩形、圆形类的继承关系首先，我们创建一个名为Shape的父类，它拥有一个名为calculate_area的方法，用来计算形状的面积。

接下来，我们将创建两个子类Rectangle（矩形）和Circle（圆形），它们都继承自Shape类并实现自己的calculate_area方法。

```pythonclass Shape:def calculate_area(self):passclass Rectangle(Shape):def __init__(self, width, height):self.width = widthself.height = heightdef calculate_area(self):return self.width * self.heightclass Circle(Shape):def __init__(self, radius):self.radius = radiusdef calculate_area(self):return 3.14 * self.radius * self.radius```现在，我们可以创建一个函数用来打印各个形状的面积。

这个函数接受一个Shape对象作为参数，并调用其calculate_area方法来计算并打印面积。

```pythondef print_area(shape):area = shape.calculate_area()print("面积为：", area)```接下来，我们就可以创建各个形状的实例，并调用print_area函数来打印它们的面积了。

```pythonrectangle = Rectangle(4, 5)circle = Circle(3)print_area(rectangle) # 打印矩形的面积print_area(circle) # 打印圆形的面积```运行以上代码，我们将会得到如下输出：```面积为： 20面积为： 28.26```通过这个例子，我们可以清楚地看到多态的作用。

java多态练习题

Java多态练习题一、选择题A. 多态是指同一方法可以根据对象的不同而有不同的实现B. 多态只能用于类的继承关系中C. 在Java中，方法重载不属于多态D. 多态可以提高代码的可扩展性和可维护性A. extendsB. implementsC. staticD. overrideA. 可以直接调用子类的特有方法B. 必须进行类型转换才能调用子类的特有方法C. 可以调用父类的所有方法D. 无法调用任何方法二、填空题1. 在Java中，多态的三个必要条件是：________、________和________。

2. 当子类重写父类的方法后，可以使用________关键字来调用父类的方法。

3. 在Java中，________关键字用于判断两个对象的类型是否相同。

三、判断题1. 多态允许同一操作作用于不同的对象，产生不同的执行结果。

（）2. 方法重载（Overload）和方法重写（Override）都是实现多态的方式。

（）3. 在Java中，子类对象可以直接赋值给父类引用，而无需进行类型转换。

（）四、简答题1. 请简述Java中多态的作用。

2. 请说明方法重写（Override）和方法重载（Overload）的区别。

3. 在使用多态时，如何访问子类特有的方法？五、编程题1. 定义一个动物类（Animal），包含一个吃（eat）的方法。

再定义一个狗类（Dog），继承动物类，并重写吃（eat）方法。

编写一个测试类，创建一个动物类引用，指向一个狗对象，并调用吃（eat）方法。

2. 编写一个图形类（Shape），包含一个求面积（getArea）的方法。

再定义两个子类：矩形类（Rectangle）和圆形类（Circle），分别重写求面积（getArea）方法。

编写一个测试类，创建一个图形数组，包含矩形和圆形对象，遍历数组并调用求面积（getArea）方法。

3. 定义一个员工类（Employee），包含姓名、工资等属性，以及一个计算工资（calculateSalary）的方法。

python中有关多态的试题

python中有关多态的试题含解答共20道1. 什么是多态性？-解答：多态性是指同一种操作作用于不同的对象上时，可以产生不同的行为。

2. Python中多态性的实现方式是什么？-解答：在Python中，多态性通过对象的特殊方法（例如`__len__`、`__add__`等）和动态类型特性实现。

3. 举例说明Python中的鸭子类型。

-解答：在Python中，不关心对象的具体类型，只关心对象是否具有特定的方法或属性。

例如，`len()`函数可以用于任何实现了`__len__`方法的对象。

4. 什么是函数的多态性？-解答：函数的多态性指同一函数名可以接受不同类型或数量的参数，并根据实际参数的类型或数量执行不同的操作。

5. 什么是运算符的多态性？-解答：运算符的多态性指同一运算符可以用于不同类型的操作数，并根据操作数的类型执行不同的操作。

6. 如何在Python中实现多态性？-解答：通过使用继承和重写方法，或者通过使用鸭子类型，可以实现多态性。

7. 什么是方法重写？它与多态性有什么关系？-解答：方法重写是子类覆盖父类中相同名称的方法。

多态性的一种表现就是通过方法重写实现，不同的子类可以提供不同的实现。

8. Python中的抽象基类是什么？它与多态性有什么关系？-解答：抽象基类是指包含抽象方法的类，它定义了一组子类必须实现的方法。

通过使用抽象基类，可以确保子类实现了必要的方法，从而实现多态性。

9. 什么是函数重载？Python支持函数重载吗？-解答：函数重载是指可以定义多个同名函数，但它们的参数类型或数量不同。

Python 不直接支持函数重载，因为它是一门动态类型语言，但可以通过默认参数值和可变参数来模拟一些重载的效果。

10. 如何使用`isinstance()`函数实现多态性？-解答：`isinstance()`函数用于检查对象是否属于指定的类型，通过使用该函数，可以在运行时根据对象的类型采取不同的操作，从而实现多态性。

C#面向对象编程-多态习题

C#面向对象编程-多态1．C#中的方法重写使用关键字（）。

a)overrideb)overloadc)staticd)inherit2．以下的C#代码，试图用来定义一个接口：public interface IFile{int A;int delFile() {A = 3;}void disFile();}关于以上的代码，以下描述错误的是（）。

（选择一项）a)以上的代码中存在的错误包括：不能在接口中定义变量，所以int A代码行将出现错误b)以上的代码中存在的错误包括：接口方法delFile是不允许实现的，所以不能编写具体的实现函数c)代码void disFile();定义无错误，接口可以没有返回值d)代码void disFile();应该编写为void disFile(){};3．在C#中，接口与抽象基类的区别在于（）。

a)抽象基类可以包含非抽象方法，而接口只能包含抽象方法b)抽象基类可以被实例化，而接口不能被实例化c)抽象基类不能被实例化，而接口可以被实例化d)抽象基类就是接口，它们之间无差别4．在开发某图书馆的图书信息管理系统的过程中，开始为教材类图书建立一个TextBook 类；现在又增加了杂志类图书，于是需要改变设计，则下面最好的设计应该是（）。

a)建立一个新的杂志类Journal。

b)建立一个新的杂志类Journal，并继承TextBoook类。

c)建立一个基类Book和一个新的杂志类Journal，并让Journal类和TextBoook类都继承于Book类。

d)不建立任何类，把杂志图书的某些特殊属性加到TextBoook类中。

5．可以使用（）关键字重写方法。

a)Overrideb)New6．（）可以看作类的模具。

A.抽象类B.接口C.虚方法7．以下叙述正确的是：()A．接口中可以有虚方法。

B.一个类可以实现多个接口。

C．接口不能被实例化。

D.接口中可以包含已实现的方法。

8.下列代码输出为（）：class Father{public void F() { Console.WriteLine("A.F"); }public virtual void G() { Console.WriteLine("A.G"); }}class Son: Father{new public void F() { Console.WriteLine("B.F"); }public override void G() { Console.WriteLine("B.G"); }}class override_new{static void Main() {Son b = new Son();Father a = b;a.F();b.F();a.G();b.G();}}A. A.FB.F A.G B.GB. A.F B.F B.G B.GC. A.F A.F B.G B.GD. B.F B.F B.G B.G9．写出程序的输出结果：public class A{public virtual void Fun1(int i){Console.WriteLine(i);}public void Fun2(A a){a.Fun1(1);Fun1(5);}}public class B:A {public override void Fun1(int i){base.Fun1(i+1);}public static void Main() {B b=new B();A a=new A();a.Fun2(b);b.Fun2(a);}}答案：2,5,1,610．在C＃中，允许多接口继承，从多个接口时，使用“：”后跟继承的接口的名字，多个接口名称之间使用（）符号进行分割。

多态练习(1)

多态练习(1)1、请用类的派生方式来组织下列动物实体与概念：动物，脊椎动物门，节肢动物门，鱼纲，鸟纲，爬行纲，哺乳纲，昆虫纲，鲨鱼，青鱼，海马，鹦鹉，海鸥，喜鹊，蝙蝠，翼龙，蜻蜓，金龟，扬子鳄，袋鼠，金丝猴，虎，蜈蚣，蜘蛛，蝗虫，知了，螃蟹，虾。

2、定义商品类及其多层的派生类。

以商品类为基类。

第一层派生出服装类、家电类、车辆类。

第二层派生出衬衣类、外衣类、帽子类、鞋子类；空调类、电视类、音响类；自行车类、轿车类、摩托车类。

要求给出基本属性和派生过程中增加的属性。

3、几何形体的派生关系如下：几何图形 geometric_shape)矩形 rectangle 圆 circle 三角形(triangle)对平面形体有长和面积，对立体有表面积和体积，对长方体 box)圆柱 cylinder)圆锥 cone)三棱锥(t_pyramid)三棱柱(t_prism)几何图形基类，周长、面积和体积应怎样计算（用什么函数）?对平面图形体积怎样计算（用什么函数）？对立体图形周长怎么计算（用什么函数）?要求实现多态性。

4、公司雇员（employee）包括经理（manager），技术人员（technician）和销售员（salesman）。

开发部经理（developermanger），既是经理也是技术人员。

销售部经理（salesmanager），既是经理也是销售员。

以employ类为虚基类派生出manager，technician和salesman类；再进一步派生出developermanager和salesmanager类。

employee类的属性包括姓名、职工号、工资级别，月薪（实发基本工资加业绩工资）。

操作包括月薪计算函数（pay()），该函数要求输入请假天数，扣去应扣工资后，得出实发基本工资。

technician类派生的属性有每小时附加酬金和当月工作时数，及研究完成进度系数。

业绩工资为三者之积。

也包括同名的pay()函数，工资总额为基本工资加业绩工资。

1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。

（5）分别用XS类的指针和引用访问dispXM（）、dispXB（）和dispNL（）函数。

（6）观察程序结果。

这些人员分别具有以下属性。

经理：姓名、编号、固定工资、当月薪水、计算月薪、显示信息兼职技术人员：姓名、编号、工作小时、每小时工资额、当月薪水、计算月薪、显示信息；兼职销售员：姓名、编号、销售额、销售额提成、当月薪水、计算月薪、显示信息要求：人员编号基数为1000，每输入一个人员信息编号顺序加1月薪计算办法是经理固定月薪8000元；兼职技术人员按100元/小时领取月薪；兼职推销员按当月销售额的4%提成。

根绝题目要求，设计一个基类employee，然后派生出technician （兼职技术人员）类、manager（经理）类和salesman（兼职销售员）类。

部分成员函数设置为虚函数将“<<”和“>>”运算符#include <iostream>#include <iomanip>#include <string.h>#include <fstream>using namespace std;const int Maxr=100;class Employee //职工类{int tag;//删除标记int no;//职工编号char name[20];char zw[20];//职工姓名int salary;//职工工资public:Employee(){}char *getname() {return name;}//获取名字int gettag() {return tag;}//获取标记int getno() {return no;}//获取编号int getsalary(){return salary;}void setzw(char q[])//设置名字{strcpy(zw,q);}void setname(char na[])//设置名字{strcpy(name,na);}void getsalary(int sa){salary=sa;}void delna(){tag=1;}//删除void addemp(int n,int sa,char *na,char *q)//增加{tag=0;no=n;salary=sa;strcpy(name,na);strcpy(zw,q);}void disp()//显示职工信息{cout < <"│" < <setw(10) < <no < <"│" < <setw(10) < <name < <"│" < <setw(10) < <salary < <"│" < <setw(10) < <zw < <"│" < <endl;cout < <"├—————┼—————┼—————┼—————┤" < <endl;}};class Database//职工数据类{int top;Employee read[Maxr];public:Database()//将职工信息从employee.txt读取到read[]中{ Employee s;top=-1;fstream file("employee.txt",ios::in);while (1){file.read((char *)&s,sizeof(s));if (!file) break;top++;read[top]=s;}file.close();}void clear()//删除所有{top=-1;}int addemp (int n, int sa,char *na,char*q) //增加职工{Employee *p=query(n);if (p==NULL){top++;read[top].addemp(n,sa,na,q);return 1;}return 0;}Employee *query(int empid){for (int i=0;i <=top;i++)if (read[i].getno()==empid && read[i].gettag()==0)return &read[i];return NULL;}Employee *query1(char empna[20]){for (int i=0;i <=top;i++)if ((read[i].getname()==empna) && read[i].gettag()==0)return &read[i];return NULL;}void disp() //职工信息显示{for (int i=0;i <=top;i++)read[i].disp();}void empdata();~Database() //将read[]中的信息读如到employee.txt中{fstream file("employee.txt",ios::out);for (int i=0;i <=top;i++)if (read[i].gettag()==0)file.write((char *)&read[i],sizeof(read[i]));file.close();}};void Database::empdata()//职工维护{int choice=1;int m=1;int b=1;char rname[20];int empid; int empsa;char q[20];Employee *r;while (choice!=0){cout < <"职工维护1：新增2：更改3：删除4：查找5：显示6：全删0：退出=>"; cin>>choice;switch (choice){case 1:cout < <setw(50) < <" ┌—————————————┐\n";cout < <setw(50) < <" │ 请选择您所需的操作│\n";cout < <setw(50) < <" │ 经理：1，并按回车键│\n";cout < <setw(50) < <" │ 业务经理：2，并按回车键│\n";cout < <setw(50) < <" │ 普通职工：3，并按回车键│\n";cout < <setw(50) < <" └—————————————┘\n"; cin>>m;while(m!=0){switch(m){case 1:cout < <"输入经理编号：";cin>>empid;cout < <"输入奖金: ";cin>>empsa;cout < <"输入经理姓名：";cin>>rname;addemp(empid,8000+empsa,rname,"经理");break;case 2:cout < <"输入业务经理编号：";cin>>empid;cout < <"输入月提成: ";cin>>empsa;cout < <"输入业务经理姓名：";cin>>rname;addemp(empid,4000+empsa,rname,"业务经理");break;case 3:cout < <"输入职工编号：";cin>>empid;cout < <"输入工资: ";cin>>empsa;cout < <"输入职工姓名：";cin>>rname;addemp(empid,empsa,rname,"普通职工");break;}break;}break;case 2:cout < <"输入职工编号：";cin>>empid;r=query(empid);if (r==NULL){cout < <"该职工不存在" < <endl;break;}cout < <"输入新的工资：" < <endl;cin>>empsa;r->getsalary(empsa);cout < <"请输入新的职务" < <endl;cin>>q;r->setzw(q);addemp(empid,empsa,rname,q);break;case 3:cout < <"输入职工编号：";cin>>empid;r=query(empid);if (r==NULL){cout < <"该读者不存在" < <endl;break;}r->delna();break;case 4:cout < <setw(50) < <" ┌—————————————┐\n";cout < <setw(50) < <" │ 请选择您所需的操作│\n";cout < <setw(50) < <" │ 按编号查找1，并按回车键│\n";cout < <setw(50) < <" │ 返回2，并按回车键│\n";cout < <setw(50) < <" └—————————————┘\n";cin>>b;while(b!=0){switch(b){case 1:cout < <"输入职工编号：";cin>>empid;r=query(empid);if (r==NULL){cout < <"该职工不存在" < <endl;break;}cout < <"├—————┼—————┼—————┼—————┤" < <endl;cout < <"│" < <setw(10) < <"编号" < <"│" < <setw(10) < <"姓名" < <"│" < <setw(10) < <"工资" < <"│" < <setw(10) < <"职务" < <"│" < <endl;cout < <"├—————┼—————┼—————┼—————┤" < <endl;r->disp();break;case 2:break;}break;}break;case 5:cout < <"├—————┼—————┼—————┼—————┤" < <endl;cout < <"│" < <setw(10) < <"编号" < <"│" < <setw(10) < <"姓名" < <"│" < <setw(10) < <"工资" < <"│" < <setw(10) < <"职务" < <"│" < <endl;cout < <"├—————┼—————┼—————┼—————┤" < <endl;disp();break;case 6:clear();break;}}}void main(){int choice=1;Database EmpDB;while(choice!=0){cout < <"***************************************************************************** ***" < <endl;cout < <endl;cout < <endl;cout < <setw(20) < <"******************************欢迎使用职工管理系统******************************" < <endl;cout < <endl;cout < <endl;cout < <setw(50) < <" ┌—————————————┐\n";cout < <setw(50) < <" │ 请选择您所需的操作│\n";cout < <setw(50) < <" │ │\n";cout < <setw(50) < <" │ 操作1，并按回车键│\n";cout < <setw(50) < <" │ │\n";cout < <setw(50) < <" │ 返回0，并按回车键│\n";精品文档cout < <setw(50) < <" └—————————————┘\n";cin>>choice;switch(choice){case 1:while(1){cout < <setw(20);EmpDB.empdata();break;break;}}}}3、堆栈的特点是：先进先出定义了一个堆栈类stack，包括初始化，压栈（就是将元素放在栈顶）、弹栈（取栈顶的一个元素），释放堆栈等操作要求运用模版实现，堆栈中可以根据需求放入double、int、char*等数据对象。

最新多态练习题

多态练习题

C++练习题 多态

Java多态练习

java多态的练习题

第三次练习 多态练习

java多态练习题

c++多态性相关习题

C++多态练习题

c++多态性相关习题

java 多态练习题

05.多态_练习题

多态的练习题

java 多态 选择题

多态的练习题

多态及练习题

多态调用练习题

java多态练习题

python中有关多态的试题

C#面向对象编程-多态习题

多态练习(1)

C++练习题多态

第三次练习多态练习

java 多态选择题