多态练习题
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
#include
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:"< } void CZS::dispXB() { if(xb==1) cout<<"Man"< if(xb==0) cout<<"Woman"< } void CZS::dispNL() { cout<<"age:"< } 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:"< } void GZS::dispXB() { if(xb==1) cout<<"Man"< if(xb==0) cout<<"Woman"< } void GZS::dispNL() { cout<<"age:"< } 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:"< } void DXS::dispXB() { if(xb==1) cout<<"Man"< if(xb==0) cout<<"Woman"< void DXS::dispNL() { cout<<"age:"< } 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;//定义抽象基类的指针变量p p=&czs;//将初中生对象czs的地址赋给p displayP(p); p=&gzs;//将高中生对象czs的地址赋给p displayP(p); p=&dxs;//将大学生对象czs的地址赋给p displayP(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类人员：经理、兼职技术人员、兼职销售员。这些人员分别具有以下属性。 经理：姓名、编号、固定工资、当月薪水、计算月薪、显示信息 兼职技术人员：姓名、编号、工作小时、每小时工资额、当月薪水、计算月薪、显示信息； 兼职销售员：姓名、编号、销售额、销售额提成、当月薪水、计算月薪、显示信息 要求： 人员编号基数为1000，每输入一个人员信息编号顺序加1 月薪计算办法是经理固定月薪8000元；兼职技术人员按100元/小时领取月薪；兼职推销员按当月销售额的4%提成。根绝题目要求，设计一个基类employee，然后派生出technician （兼职技术人员）类、manager（经理）类和salesman（兼职销售员）类。 部分成员函数设置为虚函数 将“<<”和“>>”运算符 #include #include #include #include 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 < <"│" < cout < <"├—————┼—————┼—————┼—————┤" < } }; 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 < cout < cout < cout < cout < cout < 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 < <"该职工不存在" < break; } cout < <"输入新的工资：" < cin>>empsa; r->getsalary(empsa); cout < <"请输入新的职务" < cin>>q; r->setzw(q); addemp(empid,empsa,rname,q); break; case 3: cout < <"输入职工编号："; cin>>empid; r=query(empid); if (r==NULL) { cout < <"该读者不存在" < break; } r->delna(); break; case 4: cout < cout < cout < cout < cout < cin>>b; while(b!=0){ switch(b) { case 1: cout < <"输入职工编号："; cin>>empid; r=query(empid); if (r==NULL) { cout < <"该职工不存在" < break; } cout < <"├—————┼—————┼—————┼—————┤" < cout < <"│" < cout < <"├—————┼—————┼—————┼—————┤" < r->disp(); break; case 2: break; } break; } break; case 5: cout < <"├—————┼—————┼—————┼—————┤" < cout < <"│" < cout < <"├—————┼—————┼—————┼—————┤" < disp(); break; case 6: clear(); break; } } } void main() { int choice=1;Database EmpDB; while(choice!=0) { cout < <"***************************************************************************** ***" < cout < cout < cout < cout < cout < cout < cout < cout < cout < cout < cout < cout < cin>>choice; switch(choice) { case 1: while(1){ cout < EmpDB.empdata(); break; break;} } } } 3、堆栈的特点是：先进先出 定义了一个堆栈类stack，包括初始化，压栈（就是将元素放在栈顶）、弹栈（取栈顶的一个元素），释放堆栈等操作 要求运用模版实现，堆栈中可以根据需求放入double、int、char*等数据对象。 4、上课教材的课后习题 实验项目名称：继承和多态 （所属课程：Java语言程序设计） 院系：专业班级：姓名： 学号：实验地点：指导老师： 本实验项目成绩：教师签字：日期： 1．实验目的 （1）掌握类的继承机制。 （2）熟悉类中成员变量和方法的访问控制。 （3）熟悉方法或构造方法多态性。 2.实验内容 （1）模拟编写程序，理解类的继承、多态、继承和多态规则。 （2）独立编程，实现类的继承和多态。 3.实验作业 设计一个类Shape（图形）包含求面积和周长的area()方法和perimeter()方法以及设置颜色的方法SetColor()，并利用Java多态技术设计其子类Circle（圆形）类、Rectangle （矩形）类和Triangle（三角形）类，并分别实现相应的求面积和求周长的方法。每个类都要覆盖toString方法。 海伦公式：三角形的面积等于s(s-a)(s-b)(s-c)的开方，其中s=(a+b+c)/2 程序代码为： Class包 package Class; public class Shape { private String color = "while"; public Shape(String color){ this.color = color; } public void setColor(String color){ this.color = color; } public String getColor(){ return color; } public double getArea(){ return 0; } public double getPerimeter(){ return 0; } public String toString(){ return"color:" + color; } } package Class; public class Circle extends Shape { private double radius; public Circle(String color,double radius) { super(color); this.radius = radius; } public void setRadius(double radius){ this.radius = radius; } public double getRadius(){ return radius; } public double getCircleArea(){ return 3.14*radius*radius; } public double getCirclePerimeter(){ return 3.14*2*radius; } public String toString(){ 继承与多态习题 一.基本概念与基础知识自测题 8.1填空题 8.1.1 如果类α继承了类β，则类α称为（1）类，而类β称为（2）类。（3）类 的对象可作为（4）类的对象处理，反过来不行，因为（5）。如果强制转换则要注意（6）。 答案：（1）基类 （2）派生类 （3）派生类 （4）基类 （5）派生类有一些新成员 （6）只能派生类强制转换为基类 8.1.2 当用public继承从基类派生一个类时，基类的public成员成为派生类的（1）成员， protected成员成为派生类的（2）成员，对private成员是（3）。公有派生可以使其类的（4），所以公有派生是主流。 答案：（1）public成员 （2）protected成员 （3）不可访问 （4）接口不变 8.1.3 利用继承能够实现（1）。这种实现缩短了程序开发的时间，VC++中的（2）很 好地体现了这一点。 答案：（1）代码的复用 （2）MFC编程 8.1.4 一个派生类只有一个直接基类的情况称为（1），而有多个直接基类的情况称为 （2）。继承体现了类的（3）概念，这在MFC中得到了很好表现，MFC中只采用了（4）。 答案：（1）单继承 （2）多重继承 （3）层次 （4）单继承 8.1.5 C++中多态性包括两种多态性：（1）和（2）。前者是通过（3）实现的， 而后者是通过（4）和（5）来实现的。 答案：（1）编译时的 （2）运行时的 （3）函数和运算符的重载 （4）类继承关系 （5）虚函数 8.1.6 在基类中将一个成员函数说明成虚函数后，在其派生类中只要（1）、（2）和 （3）完全一样就认为是虚函数，而不必再加关键字（4）。如有任何不同，则认为是（5）而不是虚函数。除了非成员函数不能作为虚函数外，（6）、（7）和（8）也不能作为虚函数。 答案：（1）同虚函数名 （2）同参数表 （3）同返回类型。如基类中返回基类指针，而派生类中返回派生类指针是允许的 （4）virtual （5）重载 （6）静态成员函数 （7）内联函数 （8）构造函数 8.1.7 纯虚函数定义时在函数参数表后加（1），它表明程序员对函数（2），其本质 是将指向函数体的指针定为（3）。 答案：（1）=0 （2）不定义 （3）NULL 8.2简答题 8.2.1构造函数和析构函数可以继承吗？派生类构造函数各部分的执行次序是怎样的？答：构造函数和析构函数不可以继承。派生类构造函数各部分的执行次序是： 1.调用基类构造函数，按它们在派生类声明的先后顺序，依次调用。 2.调用新增成员对象的构造函数，按它们在类定义中声明的先后顺序，依次调用。 3.派生类的构造函数体中的操作。 8.2.2什么叫派生类的同名覆盖（override）? 答：如果派生类声明了一个和某个基类成员同名的新成员（当然如是成员函数，参数表也必须一样，否则是重载），派生类中的新成员就屏蔽了基类同名成员，类似函数中的局部变量屏蔽全局变量。称为同名覆盖（override）。 8.2.3派生类的析构函数中需完成什么任务？是否要编写对基数和成员对象的析构函数的 调用？为什么？ 答：析构函数的功能是作善后工作，析构函数无返回类型也没有参数，情况比较简单。派生类析构函数定义格式与非派生类无任何差异，不要编写对基数和成员对象的析构函数的调用，只要在函数体内把派生类新增一般成员处理好就可以了，因为对新增的成员对象和基类的善后工作，系统会自己调用成员对象和基类的析构函数来完成。 8.2.4为什么要使用虚基类？怎样定义虚基类？用一个实例来解释虚基类在其派生类中的 存储方式。 答：在多重继承是有可能出现同一基类的两个拷贝，为避免这种情况，可使用虚基类。虚基类（virtual base class）定义方式如下： class派生类名:virtual 访问限定符基类类名{...}; class派生类名:访问限定符virtual基类类名{...}; virtual 关键字只对紧随其后的基类名起作用。 Java 程序设计练习题（1） 一、单项选择题 1．下面（ B ）是合法的 Java 标识符。 A、#_pound B、_underscore C、5Interstate D 、 class 2．下面（ D ）赋值语句不会出现编译警告或错误。 A、float f=1.3; B、char c="a"; C、byte b=257; D、int i=10; 3．编译一个定义了两个类和三个方法的 Java 源程序文件，总共会产生（ D ）个字节码文件。 A、5 个字节码文件，以“.java”为扩展名 B、2 个字节码文件，以“.java”为扩展名 C、5 个字节码文件，以“.class”为扩展名 D、2 个字节码文件，以“.class”为扩展名4．有关类的说法，正确的是（ B ）。 A、类具有封装性，所以类的数据是不能被访问的 B、类具有封装性，但可以通过类的公共接口访问类中的数据 C、声明一个类时，必须使用 public 修饰符 D、每个类中必须有 main 方法，否则程序无法运行 5．执行完下面程序片段后，（ B ）的结论是正确的。 int a, b, c; a = 1; b = 2; c = (a + b > 3 ? a++ : b++); A、a 的值是 2，b 的值是 3 B、a 的值是 1，b 的值是 3 C、a 的值是 1，b 的值是 2 D、c 的值是 false 6．将类的成员的访问权限设置为默认的，则该成员能被（ A ）。 A、同一包中的类访问 B、其他包中的类访问 C、所有的类访问 D、所有的类的子类访问 7．下面的方法重载，正确的是（ C ）。 A、int fun(int a, float b) { } B、float fun(int a, float b) { } float fun(int a, float b) { } float fun(int x, float y) { } C、float fun(float a) { } D、float fun1(int a, float b) { } float fun(float a, float b) { } float fun2(int a, float b) { } 8．下面关于继承的说法，正确的是（ D ）。 A、超类的对象就是子类的对象 B、一个类可以有几个超类 C、一个类只能有一个子类 D、一个类只能有一个超类 9．下面关于多态性的说法，正确的是（ C ）。 A、一个类中不能有同名的方法 共交力系及一图多态小专 例题1：如图所示,用完全相同的轻质弹簧1、2、3将两个相同的小球连接并懋挂,小球静止时,弹簧3水平,弹簧1与竖直方向的夹角θ=30°,弹簧1的弹力大小为F ,则( B ) A. 弹簧3的弹力大小为2F B. 弹簧3的弹力大小为2 F C. 每个小球重力大小为23F D. 每个小球重力大小为3F 解决方法1：整体隔离法 解决方法二：一图多态 例题2： 如图所示，两质点A 、B 质量分别为m 、2m ，用两根等长的细轻绳悬挂在O 点，两球之间夹着一根劲度系数为k 的轻弹簧，静止不动时，两根细线之间的夹角为60°。设绳OA 、OB 与竖直方向的夹角分别为α和β，则（ B ） A. βα2= B. βαsin 2sin = C. βαtan 2tan = D. βα2cos cos = 方法一：共交力系法（力矩平衡）： 方法二：一图多态 例题3：(一图多态、共点力)如图所示，两个可视为质点的小球a 和b ，用一不计重力的刚性轻细杆相连，再用两根等长的轻细绳吊在O 点。已知小球a 和b 的质量之比a m ：b m =1:3，细杆长度是细绳长度的2倍。两球处于平衡状态时，细杆与水平面的夹角为θ，绳Oa 上的拉力为a F ，绳Ob 上的拉力为b F ，则下列说法正确的是（ B ） A. ?=30θ B.?=15θ C.1:3:=b a F F D.2:2:=b a F F 解题法： 练习1：(一图多态、共点力)如图所示,一轻质细杆两端分别固定着质量为mA 和mB 的两个小球A 和B(可视为质点),将其放在一个直角形光滑槽中,已知轻杆与槽右壁成α角,槽右壁与水平地面成θ角时,两球刚好能平衡,且α≠0,则A. B 两小球质量之比为( C ) A. sin θsin αcos θcos α?? B. cos θ sin αsin θcos α?? C.cos θcos αsin θsin α?? D. cos θcos αcos θsin α?? 练习2：(一图多态、共点力)如图所示,一个半球形的碗放在桌面上,碗口水平,O 是球心,碗的内表面光滑。一根轻质杆的两端固定有两个小球,质量分别是m1,m2.当它们静止时,m 1、m 2与球心的连线跟水平面分别成60°,30°角,则碗对两小球 的弹力大小之比是( B ) A. 1:2 B. 1:3 C. 3:1 D. 2:3 练习3：如图所示，在墙角有一根质量为m 的均匀绳，一端悬于天花板上的A 点，另一端悬于竖直墙壁上的B 点，平衡后最低点为C 点，测得AC ＝2BC ，且绳在B 端附近的切线与墙壁夹角为α，已知重力加速度为g ，则绳在A 处的张力是________，在最低点C 处的张力是________。 答案：α2tan 43mg += A T αmgtan 3 1=C T Java多态的综合例子: package Test; public interface USBInterface { void start(); void conn(); void stop(); } package Test; public class MovingDisk implements USBInterface { @Override public void start() { // TODO Auto- System.out.println("移动设备已经插入，开始使用"); } @Override public void conn() { // TODO Auto-generated method stub System.out.println("移动设备已经连接，正在使用"); } @Override public void stop() { // TODO Auto-generated method stub System.out.println("移动设备已经退出"); } } package Test; public class Mouse implements USBInterface { public void start() { System.out.println("鼠标已插入，开始使用"); } @Override public void conn() { System.out.println("鼠标已经连接，正在使用中"); } @Override public void stop() { System.out.println("鼠标拨出"); } } package Test; public class MainBorad { public void start() { System.out.println("主板加载成功"); } public void useUsb(USBInterface u) { u.conn(); u.start(); u.stop(); } } package Test; public class KeyBoard implements USBInterface { @Override public void start() { System.out.println("键盘已经插入，开始使用"); } @Override public void conn() { // TODO Auto-generated method stub System.out.println("键盘已经连接，正在使用"); } @Override public void stop() { // TODO Auto-generated method stub System.out.println("键盘已经拨出"); } } package Test; public class Test { /** * @param args 第七章继承多态 一、选择题： 1、分析: class A { A() { } } class B extends A { //系统自动生成的构造方法和类的访问权限一样 } 哪两种说法是正确的? ( ) A:类B的构造方法是public的. B:类B的构造方法包含对this()的调用. C:类B的构造方法没有参数. D:类B的构造方法包含对super()的调用. 2、运行结果是:（） class Base { Base() { System.out.print("Base"); } } public class Alpha extends Base { public static void main( String[] args ) { new Alpha(); new Base(); } } A: Base B: BaseBase C: 编译失败. D: 没有输出. E: 运行时异常. 3. 程序的运行结果是?（） A: 编译失败. B: hello from a C: hello from b D: hello from b E: hello from a hello from a hello from b 4. 运行结果是:（） class TestSuper { TestSuper(int i) { } } class TestSub extends TestSuper{ } class TestAll { public static void main (String [] args) { new TestSub(); } } A: 编译失败. B: 程序运行没有异常. C: 第7行抛出异常. D: 第2行抛出异常. 5. 程序的运行结果是?（） A: 0 B: 1 C: 2 D: 编译失败. 6. 对于语句"B is a D" 和"B has a C"，一下哪两种说法是正确的? ( ) A:D是B. B:B是D. C:D是C. D:B是C. E:D继承B. F:B 继承D. 7. 运行结果是?（） 1. 什么是多态 多态是C++中的一个重要的基础，可以这样说，不掌握多态就是C++的门个汉。我就给它定一个这样的名字-- “调用’同名函数’却会因上下文不同会有不同的实现的一种机制”。这个名字长是长了点儿，可是比“多态”清楚多了。看这个长的定义，我们可以从中找出多态的三个重要的部分。一是“相同函数名”，二是“依据上下文”，三是“实现却不同”。我们且把它们叫做多态三要素吧。 2. 多态带来的好处 多态带来两个明显的好处：一是不用记大量的函数名了，二是它会依据调用时的上下文来确定实现。确定实现的过程由C++本身完成，另外还有一个不明显但却很重要的好处是：带来了面向对象的编程。 3. C++中实现多态的方式 C++中共有三种实现多态的方式。由“容易说明白”到“不容易说明白”排序分别为: 第一种是函数重载；第二种是模板函数；第三种是虚函数。 4. 细说用函数重载实现的多态 函数重载是这样一种机制：允许有不同参数的函数有相同的名字。 具体一点讲就是：假如有如下三个函数： void test(int arg){} //函数1 void test(char arg){} //函数2 void test(int arg1,int arg2){} //函数3 如果在C中编译，将会得到一个名字冲突的错误而不能编译通过。在C++中这样做是合法的。可是当我们调用test的时候到底是会调用上面三个函数中的哪一个呢？这要依据你在调用时给的出的参数来决定。如下： test(5); //调用函数1 test('c');//调用函数2 test(4,5); //调用函数3 C++是如何做到这一点的呢？原来聪明的C++编译器在编译的时候悄悄的在我们的函数名上根据函数的参数的不同做了一些不同的记号。具体说如下： void test(int arg) //被标记为‘test有一个int型参数’void test(char arg) //被标记为‘test有一个char型的参数’void test(int arg1,int arg2) //被标记为‘test第一个参数是int型，第二个参数为int型’ 这样一来当我们进行对test的调用时，C++就可以根据调用时的参数来确定到底该用哪一个test函数了。噢，聪明的C++编译器。其实C++做标记做的比我上面所做的更聪明。我上面哪样的标记太长了。C++编译器用的标记要比我的短小的多。看看这个真正的C++的对这三个函数的标记： ?test@@YAXD@Z ?test@@YAXH@Z ?test@@YAXHH@Z 是不是短多了。但却不好看明白了。好在这是给计算机看的，人看不大明白是可以理解的。 还记得cout吧。我们用<<可以让它把任意类型的数据输出。比如可以象下面那样： cout << 1; //输出int型 cout << 8.9; //输出double型 多态性是面向对象编程三个重要特性之一。Java中的多态性是通过综合应用继承、覆 盖，以及向上转型实现的。本章首先综合阐述面向对象编程的这些重要特征，引申到代码中的多态概念、多态带来的好处，以及多态能够解决的问题。然后通过实例详细讨论多态技术 在编程中的应用。 3：如何在程序中最有效地计算众多不同几何体的表面积comArea ()? 计算表面积的方法，如comArea，包括其 他类似方法，如comArea，print()，等等，都可应用多态来解决。因为这 些方法都可以针对不同的几何体，进行运算和操作。即：形态不一、方法相同、内容多样。 public abstract class shape { public double area(){ return 0; } public void print(){ } } public class sphere extends shape{ private double r; public sphere(double r){ this.r=r; } public void print(){ System.out.println("球的半径："+r); } public double area(){ return Math.PI*r*r*r*4/3; } } public class comArea { public static void main(String[] args) { shape h[]; h=new shape[2]; h[0]=new sphere(10); h[1]=new square(10,10,10); Operator.areaMax(h); } } public class Operator { //将长方形和圆看做Shape类型 public static void areaMax(shape h[]){ shape max; for(int i=1;i 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 Java多态 1. Java中除了static和final方法外，其他所有的方法都是运行时绑定的。private 方法都被隐式指定为final的，因此final的方法不会在运行时绑定。当在派生类中重写基类中static、final、或private方法时，实质上是创建了一个新的方法。 2.在派生类中，对于基类中的private方法，最好采用不同的名字。 3.包含抽象方法的类叫做抽象类。注意定义里面包含这样的意思，只要类中包含一个抽象方法，该类就是抽象类。抽象类在派生中就是作为基类的角色，为不同的子类提供通用的接口。 4.对象清理的顺序和创建的顺序相反，当然前提是自己想手动清理对象，因为大家都知道Java垃圾回收器。 5.在基类的构造方法中小心调用基类中被重写的方法，这里涉及到对象初始化顺序。 6.构造方法是被隐式声明为static方法。 7.用继承表达行为间的差异，用字段表达状态上的变化。 在JAVA中有两种多态是指：运行时多态和编译时多态。 关于类的多态性简介如下： 多态(polymorphism)意为一个名字可具有多种语义.在程序设计语言中,多态性是指”一种定义,多种实现”.例如,运算符+有多种含义,究竟执行哪种运算取决于参加运算的操作数类型: 1+2 //加法运算符 “1” + “2” //字符串连接运算,操作数是字符串 多态性是面向对象的核心特征之一,类的多态性提供类中成员设计的灵活性和方法执行的多样性. 1、类多态性表现 (1)方法重载 重载表现为同一个类中方法的多态性.一个类生命多个重载方法就是为一种功能提供多种实现.编译时,根据方法实际参数的数据类型\个数和次序,决定究竟应该执行重载方法中的哪一个. (2)子类重定义从父类继承来的成员 当子类从父类继承来的成员不适合子类时,子类不能删除它们,但可以重定义它们,使弗雷成员适应子类的新需求.子类重定义父类成员,同名成员在父类与子类之间表现出多态性,父类对象引用父类成员,子类对象引用子类成员,不会产生冲突和混乱. 子类可重定义父类的同名成员变量,称子类隐藏父类成员变量.子类也可以重定义父类的同名成员方法，当子类方法的参数列表与父类方法参数列表完全相同时，称为子类方法覆盖 作业题 一、写出下列程序运行结果 1.#include }; void fun(A *a) { delete a; } int main( ) { A *a=new B(10); fun(a); } 二、程序设计题 1有一个交通工具类vehicle，将它作为基类派生小车类car、卡车类truck和轮船类boat，定义这些类并定义一个虚函数用来显示各类信息。 5.2定义一个shape抽象类，派生出Rectangle类和Circle类，计算各派生类对象的面积Area( )。 5.5某学校对教师每月工资的计算公式如下：固定工资+课时补贴。教授的固定工资为5000元,每个课时补贴50元；副教授的固定工资为3000元,每个课时补贴30元;讲师的固定工资为2000元,每个课时补贴20元。给出教师抽象类及主函数,补充编写程序求若干教师的月工资。 #include 多态的量子、多态的世界 我们知道，量子是最基本的能量单位，可以说是能量的最小单位，所有的微观粒子包括分子、原子、电子、光子他们都是量子的一种表现形态。其实，我们的这个世界本身都是微观粒子组成的，准确地说，整个自然界本身都是由量子组成的，宏观世界也是量子的一种表现形态。 量子的多态表现为，量子的状态没有被观察时，它是多态的，一旦被观察，则只能存在一个能量的状态。我们回忆薛定谔猫理论：设想在一个封闭的匣子里，有一只活猫及一瓶毒药。当衰变发生时，药瓶被打破，猫将被毒死。按照常识，猫可能死了，也可能还活着。量子力学告诉我们，存在一个中间态，猫既不死也不活，直到进行观察看看发生了什么。量子力学告诉我们：除非进行观测，否则一切都不是确定的，可这使微观不确定原理变成了宏观不确定原理，客观规律不以人的意志为转移，猫既活又死违背了逻辑思维。我们分析薛定谔猫论的假设，匣子、毒药、猫——构成了一个统一体，这一状态猫命悬一线本身就是多态的，从某种意义上讲匣子、毒药已经是猫生存的一部分，只是他们之间是否相互作用，不相互作用，等于毒药不存在，猫存活；相互作用，猫死。在匣子的存在下，我们不观察，真的不知道是否相互作用，只能是生、死共存状态。 托马斯·杨的双缝实验，量子力学认为，观察时光子走单缝，不观察时走双缝。只取决于你测量这个物体的方式。从量子学角度看，如 果你不观察它，那么现实并不存在或是模糊的、多态的，尽管听上去非常怪异，但结果证实了量子理论的正确性。例如光子，如果你用平面镜、水等手段研究光子的性质，那么光子具有粒子性——折射、反射；如果你用类似于双缝实验的手段测量光子的性质，光子即表现为波动性。 叠加的多态量子，有人为的，更多的是自然的，观察、测量时，测量的手段、方法解除了量子的多态，即确认量子的存在状态——唯一性。叠加即量子的分身，就是量子处在不稳定的、随时可变的多重状态，测量时即确定量子多态的哪一种状态。量子纠缠其实就是量子或多态量子之间的相互作用，纠缠就是量子之间的相互吸引，既然是相互吸引，不论纠缠的量子距离多远，相互纠缠的量子其中的一个量子的运动状态被改变，另一个量子的运动状态也必然随着改变。犹如天文观察到的相互绕转的双星，假设双星中的一个由于某种原因，例如爆炸损失一部分，双星的另一个运动状态必然改变。理论推测，组成量子的“元”，半径极短约在10-24米或更小，质量极小，但是密度极大，量子纠缠是通过量子“元”形成的密度引力相互作用的，使相干量子纠缠。 其实，不仅微观世界是多态的，宏观世界也是多态的。例如一张桌子，我们不同的感觉器官感觉它，会出现不同的存在“状态”，用眼睛看我们能得到桌子的形状，并不能知道桌子的其他性质，例如硬度、味道等。我们把盲人摸象的现象应用到量子的多态现象是非常形象 面向对象编程有三个特征，即封装、继承和多态。 封装隐藏了类的内部实现机制，从而可以在不影响使用者的前提下改变类的内部结构，同时保护了数据。 继承是为了重用父类代码，同时为实现多态性作准备。那么什么是多态呢？ 方法的重写、重载与动态连接构成多态性。Java之所以引入多态的概念，原因之一是它在类的继承问题上和C++不同，后者允许多继承，这确实给其带来的非常强大的功能，但是复杂的继承关系也给C++开发者带来了更大的麻烦，为了规避风险，Java只允许单继承，派生类与基类间有IS-A的关系（即“猫”is a “动物”）。这样做虽然保证了继承关系的简单明了，但是势必在功能上有很大的限制，所以，Java引入了多态性的概念以弥补这点的不足，此外，抽象类和接口也是解决单继承规定限制的重要手段。同时，多态也是面向对象编程的精髓所在。 要理解多态性，首先要知道什么是“向上转型”。 我定义了一个子类Cat，它继承了Animal类，那么后者就是前者是父类。我可以通过 Cat c = new Cat(); 实例化一个Cat的对象，这个不难理解。但当我这样定义时： Animal a = new Cat(); 这代表什么意思呢？ 很简单，它表示我定义了一个Animal类型的引用，指向新建的Cat类型的对象。由于Cat是继承自它的父类Animal，所以Animal类型的引用是可以指向Cat类型的对象的。那么这样做有什么意义呢？因为子类是对父类的一个改进和扩充，所以一般子类在功能上较父类更强大，属性较父类更独特， 定义一个父类类型的引用指向一个子类的对象既可以使用子类强大的功能，又可以抽取父类的共性。 所以，父类类型的引用可以调用父类中定义的所有属性和方法，而对于子类中定义而父类中没有的方法，它是无可奈何的； 同时，父类中的一个方法只有在在父类中定义而在子类中没有重写的情况下，才可以被父类类型的引用调用； 对于父类中定义的方法，如果子类中重写了该方法，那么父类类型的引用将会调用子类中的这个方法，这就是动态连接。 一、选择题 1.软件设计中的（）设计指定各个组件之间的通信方式以及各组件之间如 何相互作用。 A．数据 B．接口 C．结构 D．组件 2.UML 是一种（）。 A．面向对象的程序设计语言 B．面向过程的程序设计语言 C．软件系统开发方法 D．软件系统建模语言 3.面向对象中的（）机制是对现实世界中遗传现象的模拟，通过该机制，基 类的属性和方法被遗传给派生类。 A．封装 B．多态C．继承 D．变异 4.下面关于类、对象和实例的叙述中，错误的是（）。 A 类是创建对象的模板 B 对象是类的实例 C 类是对象的实例 D 类是一组具有共同特征的对象集合 5.下列不在UP的初始阶段中完成的 A编制简要的愿景文档 B粗略评估成本 C定义大多数的需求 D业务案例 6.下面那一种模式是不属于GRASP模式的 A 多态（Ploymorphism） B 行为对象（pure fabrication） C 中间者（Indirection） D GoF 7.类是一组具有相同属性的和相同服务的对象的抽象描述，类中的每个对象都 是这个类的一个。 9.一个对象通过发送来请求另一个对象为其服务。 A调用语句B消息C命令D口令 10.下面的述中，对迭代和增量式开发描述错误的是（）。 A. 迭代是时间定量的 B. 系统是增量式增长的 C. 迭代是以循环反馈和调整为核心驱动力的 D. 当迭代无法依照时间表来集成、测试和稳定局部系统时，可以推迟完成 日期。 11.有关UP阶段的说法，不正确的是（） A. UP的一个开发周期（以系统发布作为产品结束标志）由多个迭代组成； B. 初始阶段不是需求阶段，而是研究可行性的阶段。 C. 细化阶段就是需求或设计阶段； D. 细化阶段就是迭代地实现核心架构并解决高风险问题的阶段； 12.下面关于领域模型的描述，不正确的是（） A. 领域模型就是软件对象图； B. 应用UML表示法，领域模型被描述为一组没有定义操作的类图； C. 创建领域模型的原因之一是帮助理解关键业务概念和词汇； D. 领域模型和领域层使用相似的命名可以减少软件表示与我们头脑中的领 Java中的多态用法实例分析 多态分两种： (1)编译时多态（设计时多态）：方法重载。 (2)运行时多态：JAVA运行时系统根据调用该方法的实例的类型来决定选择调用哪个方法则被称为运行时多态。（我们平时说得多的事运行时多态，所以多态主要也是指运行时多态） 运行时多态存在的三个必要条件： 一、要有继承（包括接口的实现）； 二、要有重写； 三、父类引用指向子类对象。 详细解释： 运行时多态的解释：a.运行时多态是指程序中定义的引用变量所指向的具体类型和b.通过该引用变量发出的方法调用在编程时并不确定，而是在程序运行期间才确定，即一个引用变量倒底会指向哪个类的实例对象，该引用变量发出的方法调用到底是哪个类中实现的方法，必须在由程序运行期间才能决定. 1.程序序中定义的引用变量所指向的具体类型不确定(即一个引用变量倒底会指向哪个类的实例对象)。 例子： driver类中drive方法（Vehicle类vehicle）{} oneDriver.drive(newcar()) oneDriver.drive(newbus()) 其中vehicle变量无法确定具体使用哪个子类实例。 1.通过该引用变量发出的方法调用在编程时并不确定(该引用 变量发出的方法调用到底是哪个类中实现的方法)。 例子:厨师，园丁，理发师的Cut方法调用.persion.cut(). 多态的好处： 1.可替换性（substitutability）。多态对已存在代码具有可替换性。例如，多态对圆Circle类工作，对其他任何圆形几何体，如圆环，也同样工作。 2.可扩充性（extensibility）。多态对代码具有可扩充性。增加新的子类不影响已存在类的多态性、继承性，以及其他特性的运行和操作。实际上新加子类更容易获得多态功能。例如，在实现了圆锥、半圆锥以及半球体的多态基础上，很容易增添球体类的多态性。 3.接口性（interface-ability）。多态是超类通过方法签名，向子类提供了一个共同接口，由子类来完善或者覆盖它而实现的。如图8.3所示。图中超类Shape规定了两个实现多态的接口方法，puteArea()以及puteVolume()。子类，如Circle和Sphere为了实现多态，完善或者覆盖这两个接口方法。 4.灵活性（flexibility）。它在应用中体现了灵活多样的操作，提高了使用效率。 5.简化性（simplicity）。多态简化对应用软件的代码编写和修改过程，尤其在处理大量对象的运算和操作时，这个特点尤为突出和重要。 一、选择题 1. 在C++中,类与类之间的继承关系具有（C ） A）自反性B）对称性C）传递性D）反对称性 2. 在公有继承的情况下，基类的成员（私有的除外）在派生类中的访问权限（B A）受限制B）保持不变C）受保护D）不受保护 3. 按解释中的要求在下列程序划线处填入的正确语句是： （C ） #in elude 6. 当一个派生类仅有protected继承一个基类时，基类中的所有公有成员成为派生类的（C） A） public 成员B） private 成员C） protected 成员D) 友元 7. 不论派生类以何种方法继承基类，都不能使用基类的(B ) A) public 成员B) private 成员C) protected 成员D) public 成员和protected 成员 8 下面叙述错误的是( S )。 A) 基类的protected 成员在派生类中仍然是protected 的 B) 基类的protected 成员在public 派生类中仍然是protected 的 C) 基类的protected 成员在private 派生类中是private 的 D) 基类的protected 成员不能被派生类的对象访问 9. 下列说法中错误的是( S )。 A) 保护继承时基类中的public 成员在派生类中仍是public 的 B) 公有继承时基类中的private 成员在派生类中仍是private 的 C) 私有继承时基类中的public 成员在派生类中是private 的 D) 保护继承时基类中的public 成员在派生类中是protected 的 10下面叙述错误的是( C)。 A) 派生类可以使用private 派生 B) 对基类成员的访问必须是无二义性的 C) 基类成员的访问能力在派生类中维持不变 D) 赋值兼容规则也适用于多继承的组合 11派生类的构造函数的成员初始化列表中，不能包含(C )。 A) 基类的构造函数B) 派生类中子对象 的初始化 C) 基类中子对象的初始化D) 派生类中一般数 据成员的初始化 12. 下列虚基类的声明中，正确的是： ( B ) A)class virtual B: public A B)class B: virtual public A C)class B: public A virtual D)virtual class B: public A 13..实现运行时的多态性采用（D ） A）重载函数B）构造函数C）析构函数D）虚函数 14. 若一个类中含有纯虚函数，则该类称为（D ）JAVA继承和多态实验报告
继承与多态习题
Java练习题(试卷)
两个连接体的一图多态老师版
Java多态的综合例子
第七章继承多态练习题
C++对多态的理解
java多态的实际应用
多态练习题
java多态
c++多态性与虚函数习题
多态的量子
Java多态性详解——父类引用子类对象
uml综合练习题及答案
Java中的多态用法实例分析
C++习题3(继承和多态)