实验6 类的继承与派生
实验6类的继承与多态
实验6类的继承与多态
实验6 类的继承与多态
实验目的及要求：
1)掌握继承、多态和向上转型的概念与实现方法；
2)掌握成员变量的隐藏和方法重写；
3)掌握关键字super的使用。
实验类型：设计型
实验内容：
（1）请编程实现如下需求：乐器(Instrument)分为：钢琴(Piano)、小提琴(Violin)、大提琴(Cello)，三种乐器的弹奏play()方法各不相同。
编写一个测试类InstrumentTest，要求编写方法testPlay(Instrument in)，对这三种乐器进行弹奏测试。
要依据乐器的不同，进行相应的弹奏测试，在main()方法中进行测试。
（2）定义Mother类及其属性（身高、体重、年龄）和方法（工作、做家务）；定义Daughter类继承Mother类，并增加一些属性（爱好）和方法（看动画片）。
定义一个类UseExtends，在该类的main方法中创建一个名为daughter的对象，使用Mother类和Daughter类的属性和方法进行测试。
（3）定义一个交通工具类Vehicle，包含属性（speed, name, color）和方法(start, stop, run)；再定义一个飞行器子类Aircraft继承自Vehicle类。
然后从Aircraft类派生两个子类：航天飞机（SpaceShuttle）和喷气式飞机（Jet）。
实验报告要求：每个程序写出设计思路、主要代码、调试过程中遇到的问题及解决方案。
继承和派生实验报告
实验目的与要求：1.掌握类的继承与派生关系以及实验方法，理解类的层次结构。
2.掌握派生类构造函数初始化基类成员和对象成员的方法。
3.掌握内联函数和默认函数。
4.掌握赋值兼容原则，掌握派生类的复制构造函数和赋值运算符的定义。
实验过程及内容：1.实践教程实验二十二P81范例：定义一个继承与派生关系的类体系，在派生类中访问基类成员。
①先定义一个点类，包含x，y坐标数据成员，显示函数和计算面积的函数成员；②以点为基类派生一个圆类，增加表示半径的数据成员，重载显示和计算面积的函数；③定义一个线段类，以两个点类对象作数据成员，定义显示、求面积及长度函数，线段类采用聚合方式，因为有两个端点，不能用派生。
编程测试所定义的类体系。
本实验教程中有源码，请自行运行，体会和熟悉继承与派生的基本概念及实现方法，掌握派生类构造函数初始化基类成员和对象成员的方法等。
2. 实践教程P83编程：多层派生练习，由上题Point类和Circle类继续派生出Cylinder类。
要求计算圆柱的底面积、侧面积、全面积和体积。
请编写所有完整的成员函数，并编写主函数进行验证。
数据处理1.(1)(2)j结果报错，原因是派生类中的成员函数不能访问基类中的私有成员。
（3）在Line类中添加两个数据成员。
2. #include <iostream>#include <cmath>using namespace std;#define PI 3.14159class Point{friend class Line;protected:double x, y ;public:Point(){x = 0 ; y = 0 ; }Point(double xv,double yv){ x = xv; y = yv; }double Area(){return 0;}void Show() {cout<<"x="<<x<<' '<<"y="<<y<<endl;}};class Circle :public Point{protected:double radius;public:Circle(){ x = 0; y = 0; radius = 0; }Circle(double xv,double yv,double vv):Point(xv,yv){ //调用基类构造函数radius = vv;}Circle(Circle & cir):Point(cir){ //按赋值兼容规则cir可为Point实参radius=cir.radius;}Circle & operator=(Circle & cir){this->Point::operator=(cir); //在派生类中定义重载的拷贝赋值操作符有固定的标准格式radius=cir.radius;return *this;}double Area(){return PI*radius*radius;}void Show()cout<<"x="<<x<<' '<<"y="<<y<<" radius="<<radius<<endl; //访问基类的数据成员}};class Cylinder:public Circle {double high;public:Cylinder(){ x = 0; y = 0; radius = 0;high=0; }Cylinder(double xv,double yv,double vv,double kv):Circle(xv,yv,vv){ //调用基类构造函数high=kv;}Cylinder(Cylinder & cyl):Circle(cyl){ //按赋值兼容规则cyl可为Cylinder实参high=cyl.high;}Cylinder & operator=(Cylinder & cyl){this->Circle :: operator=(cyl); //在派生类中定义重载的拷贝赋值操作符有固定的标准格式high=cyl.high;return *this;}double ceArea(){return 2*PI*radius*high;}double quArea(){return ceArea()+2* Area();}double volume(){return Area()*high;}void Show(){cout<<"x="<<x<<' '<<"y="<<y<<' '<<"radius="<<radius<<' '<<"high="<<high<<endl; //访问基类的数据成员};class Line{Point start,end; //对象成员public:Line(){} //对象成员初始化Line(double xv1,double yv1,double xv2,double yv2) :start(xv1,yv1),end(xv2,yv2){ }double GetLength() {return sqrt((start.x-end.x)*(start.x-end.x)+(start.y-end.y)*(start.y-end.y));}double Area(){return 0;}void Show(){cout<<"start point:\n";start.Show();cout<<"end point:\n";end.Show();}};int main(){Point pt(0,0);Circle cl1(100,100,10),cl2(cl1),cl3;Cylinder h1(50,50,20,30),h2(h1),h3;Line ln1(0,0,100,100),ln2;cout<<"点面积："<<pt.Area()<<endl;pt.Show();cout<<"cl1圆面积："<<cl1.Area()<<endl;cl1.Show();cout<<"cl2圆面积："<<cl2.Area()<<endl;cl2.Show();cl3=cl1;cout<<"cl3圆面积："<<cl3.Area()<<endl;cl3.Show();cout<<"h1底面积："<<h1.Area()<<endl;cout<<"h1侧面积："<<h1.ceArea()<<endl;cout<<"h1全面积："<<h1.quArea()<<endl;cout<<"h1体积："<<h1.volume()<<endl;h1.Show();cout<<"h2底面积："<<h2.Area()<<endl;cout<<"h2侧面积："<<h2.ceArea()<<endl;cout<<"h2全面积："<<h2.quArea()<<endl;cout<<"h2体积："<<h2.volume()<<endl;h2.Show();h3=h1;cout<<"h3底面积："<<h3.Area()<<endl;cout<<"h3侧面积："<<h3.ceArea()<<endl;cout<<"h3全面积："<<h3.quArea()<<endl;cout<<"h3体积："<<h3.volume()<<endl;h3.Show();cout<<"线面积："<<ln1. Area()<<'\t'<<"线长度："<<ln1. GetLength()<<endl;ln1.Show();ln2.Show();return 0;}实验结论：通过这次实验，我对类的继承和派生，派生类构造函数初始化基类成员和对象成员的方法，以及赋值兼容原则有了更深的理解。
实验六继承与派生之欧阳理创编
继承与组合一、实验目的1．了解继承在面向对象程序设计中的重要作用。
2．进一步理解继承与派生的概念。
3．掌握通过继承派生出一个新的类的方法。
4．了解虚基类的作用和用法。
5．掌握类的组合二、实验内容1．请先阅读下面的程序，写出程序运行的结果，然后再上机运行程序，验证自己分析的结果是否正确。
(1)#include <iostream>using namespace std;class A{public:A(){cout<<"A::A() called.\n";}virtual ~A(){cout<<"A::~A() called.\n";}};class B:public A{public:B(int i){ cout<<"B::B() called.\n";buf=new char[i];}virtual ~B(){ delete []buf;cout<<"B::~B() called.\n";}private:char *buf;};void fun(A *a){ cout<<"May you succeed!"<<endl;delete a;}int main(){A *a=new B(15);fun(a);return 0;}1、（1）程序运行结果：A::A() called.B::B() called.May you succeed!B::~B() called.A::~A() called.(2)#include<iostream>using namespace std;class A{public:A(int a,int b):x(a),y(b){ cout<<"A constructor..."<<endl; }void Add(int a,int b){ x+=a;y+=b;}void display(){ cout<<"("<<x<<","<<y<<")";}~A(){cout<<"destructor A..."<<endl;}private:int x,y;};class B:private A{private:int i,j;A Aobj;public:B(int a,int b,int c,int d):A(a,b),i(c),j(d) ,Aobj(1,1){ cout<<"B constructor..."<<endl;}void Add(int x1,int y1,int x2,int y2){A::Add(x1,y1);i+=x2; j+=y2;}void display(){A::display();Aobj.display();cout<<"("<<i<<","<<j<<")"<<endl;}~B(){cout<<"destructor B..."<<endl;}};int main(){B b(1,2,3,4);b.display();b.Add(1,3,5,7);b.display();return 0;}（2）程序运行结果：A constructor...A constructor...B constructor...(1,2) (1,1) (3,4)(2,5) (1,1) (8,11)destructor B...destructor A...destructor A...(3)#include<iostream>using namespace std;class A{public:A(int a):x(a){ cout<<"A constructor..."<<x<<endl; }int f(){return ++x;}~A(){cout<<"destructor A..."<<endl;}private:int x;};class B:public virtual A{private:int y;A Aobj;public:B(int a,int b,int c):A(a),y(c),Aobj(c){ cout<<"B constructor..."<<y<<endl;}int f(){A::f();Aobj.f();return ++y;}void display(){cout<<A::f()<<"\t"<<Aobj.f()<<"\t"<<f()<<endl; }~B(){cout<<"destructor B..."<<endl;}};class C:public B{public:C(int a,int b,int c):B(a,b,c),A(0){ cout<<"C constructor..."<<endl;}};class D:public C,public virtual A{public:D(int a,int b,int c):C(a,b,c),A(c){ cout<<"D constructor..."<<endl;}~D(){cout<<"destructor D..."<<endl;}};int main(){D d(7,8,9);d.f();d.display();return 0;}（3）程序运行结果：A constructor (9)A constructor (9)B constructor (9)C constructor...D constructor...12 12 11destructor D...destructor B...destructor A...destructor A...(4)#include <iostream>using namespace std;class Base1{public:Base1(){cout<<"class Base1!"<<endl;}};class Base2{public:Base2(){cout<<"class Base2!"<<endl;}};class Level1:public Base2,virtual public Base1 {public:Level1(){cout<<"class Level1!"<<endl;}};class Level2: public Base2,virtual public Base1{public:Level2(){cout<<"class Level2!"<<endl;}};class TopLevel:public Level1,virtual public Level2{public:TopLevel(){cout<<"class TopLevel!"<<endl;}};int main(){TopLevel obj;return 0;}（4）程序运行结果：class Base1!class Base12class Leve12!class Base2!class Leve11!class TopLeve1!2．某出版系统发行图书和磁带，利用继承设计管理出版物的类。
(C++)实验报告六：继承与派生
实验6 继承与派生一、实验目的1．理解继承与派生、单继承与多继承的概念；2．理解基类与派生类的定义及使用方法，派生类对象的定义与初始化方法；3．理解继承与派生过程中，把派生类作为基类构成类族的概念及虚基类的概念。
二、实验环境一台PC机，Windows XP操作系统，Visual C++ 6.0开发环境。
三、实验内容1、由在校人员类(Person)作为基类派生出学生类(Student)：实验步骤：#include <iostream>#include <string>using namespace std;class Person{public:Person(int i,char *n, char s, int a){ID=i;name=n;sex=s;age=a;};int getID(){return ID;}void show(){cout<<"ID: "<<ID<<endl;cout<<"name : "<<name<<endl;cout<<"sex: "<<sex<<endl;cout<<"age: "<<age<<endl;}private:int ID;string name;char sex;int age;};class Student:public Person{public:Student(int i,char *n,char s,int a,float m,float p,float e,float c):Person(i,n,s,a){math=m;physical=p;english=e;cpp=c;total=math+physical+english+cpp;}void show(){Person::show();cout<<"math: "<<math<<endl;cout<<"physical: "<<physical<<endl;cout<<"english: "<<english<<endl;cout<<"C++: "<<cpp<<endl;cout<<"total: "<<total<<endl;}private:float math,physical,english,cpp,total;};void main(){Person p1(1,"张帅",'M',22);p1.show();cout<<endl;Student s1(9901,"林维",'S',21,65,70,75,88);s1.show();}实验结果：2、由学生类、课程类作为基类，共同派生出选课类。
实验六继承与派生之欧阳光明创编
继承与组合欧阳光明（2021.03.07）一、实验目的1．了解继承在面向对象程序设计中的重要作用。
2．进一步理解继承与派生的概念。
3．掌握通过继承派生出一个新的类的方法。
4．了解虚基类的作用和用法。
5．掌握类的组合二、实验内容1．请先阅读下面的程序，写出程序运行的结果，然后再上机运行程序，验证自己分析的结果是否正确。
(1)#include <iostream>using namespace std;class A{public:A(){cout<<"A::A() called.\n";}virtual ~A(){cout<<"A::~A() called.\n";}};class B:public A{public:B(int i){ cout<<"B::B() called.\n";buf=new char[i];}virtual ~B(){ delete []buf;cout<<"B::~B() called.\n";}private:char *buf;};void fun(A *a){ cout<<"May you succeed!"<<endl;delete a;}int main(){A *a=new B(15);fun(a);return 0;}1、（1）程序运行结果：A::A() called.B::B() called.May you succeed!B::~B() called.A::~A() called.(2)#include<iostream>using namespace std;class A{public:A(int a,int b):x(a),y(b){ cout<<"A constructor..."<<endl; }void Add(int a,int b){ x+=a;y+=b;}void display(){ cout<<"("<<x<<","<<y<<")";}~A(){cout<<"destructor A..."<<endl;}private:int x,y;};class B:private A{private:int i,j;A Aobj;public:B(int a,int b,int c,int d):A(a,b),i(c),j(d) ,Aobj(1,1){ cout<<"B constructor..."<<endl;}void Add(int x1,int y1,int x2,int y2){A::Add(x1,y1);i+=x2; j+=y2;}void display(){A::display();Aobj.display();cout<<"("<<i<<","<<j<<")"<<endl;}~B(){cout<<"destructor B..."<<endl;}};int main(){B b(1,2,3,4);b.display();b.Add(1,3,5,7);b.display();return 0;}（2）程序运行结果：A constructor...A constructor...B constructor...(1,2) (1,1) (3,4)(2,5) (1,1) (8,11)destructor B...destructor A...destructor A...(3)#include<iostream>using namespace std;class A{public:A(int a):x(a){ cout<<"A constructor..."<<x<<endl; }int f(){return ++x;}~A(){cout<<"destructor A..."<<endl;}private:int x;};class B:public virtual A{private:int y;A Aobj;public:B(int a,int b,int c):A(a),y(c),Aobj(c){ cout<<"B constructor..."<<y<<endl;}int f(){A::f();Aobj.f();return ++y;}void display(){cout<<A::f()<<"\t"<<Aobj.f()<<"\t"<<f()<<endl; }~B(){cout<<"destructor B..."<<endl;}};class C:public B{public:C(int a,int b,int c):B(a,b,c),A(0){ cout<<"C constructor..."<<endl;} };class D:public C,public virtual A{public:D(int a,int b,int c):C(a,b,c),A(c){ cout<<"D constructor..."<<endl;} ~D(){cout<<"destructor D..."<<endl;}};int main(){D d(7,8,9);d.f();d.display();return 0;}（3）程序运行结果：A constructor (9)A constructor (9)B constructor (9)C constructor...D constructor...12 12 11destructor D...destructor B...destructor A...destructor A...(4)#include <iostream>using namespace std;class Base1{public:Base1(){cout<<"class Base1!"<<endl;}};class Base2{public:Base2(){cout<<"class Base2!"<<endl;}};class Level1:public Base2,virtual public Base1{public:Level1(){cout<<"class Level1!"<<endl;}};class Level2: public Base2,virtual public Base1{public:Level2(){cout<<"class Level2!"<<endl;}};class TopLevel:public Level1,virtual public Level2{public:TopLevel(){cout<<"class TopLevel!"<<endl;}};int main(){TopLevel obj;return 0;}（4）程序运行结果：class Base1!class Base12class Leve12!class Base2!class Leve11!class TopLeve1!2．某出版系统发行图书和磁带，利用继承设计管理出版物的类。
实验6 类的继承与派生课前讲解
课前讲解—类的继承与派生一、继承原理这里举一个继承的例子，定义两个类Point类，代表一个点；Rectangle类，代表一个矩形。
这里Point类（x,y）代表一个点的坐标，把它作为父类；Rectangle类，把它作为Point类的子类。
为啥这样考虑呢？因为一个点的位置决定了以后，就可以以这个点作为矩形的左上角坐标，然后再加上矩形的宽度，高度两个分量值，就可以直接构成一个矩形了。
我们可以看到，左边是Point类包含的所有属性和方法；右边则是Rectangle类包含的所有属性和方法，它的一部分属性和方法是从父类继承下来的。
任何一个矩形对象，都必须需要知道左上角的坐标位置（x,y）和其宽度w，高度h才能知道这是一个怎样的矩形。
因此每当我们用语句创建一个矩形对象的时候，需要调用initRectangle函数做矩形的初始化工作，要为这个函数传入四个参数：所传入的参数需要赋给对象的x,y,w,h分量。
由于在Rectangle类中只定义了宽度w，高度h两个属性，因此x,y的初始化工作它并不能直接完成，此时，就需要调用父类（Point类）里面的initPoint(x,y)函数来完成x,y分量的初始化，等父类的初始化工作完成后，然后再回到子类（Rectangle类）中完成w，h分量的初始化。
总结：Point类是父类，派生出Rectangle子类。
父类中定义的属性x，y被子类继承，子类中则增加了新的属性w,h。
二、派生类的构造函数和析构函数上述程序不是太好，如果引入构造函数和析构函数的概念，把上述的init函数改成构造函数，则代码会更好一些：经过上述定义后，每当创建Rectangle对象时，系统就会分配一块内存给这个对象：总共需要4个int空间，这四个数据成员都需要正确的赋予数值，才能定义一个有意义的矩形。
其中w,h两个属性是Rectangle对象可以直接访问的，而x,y两个属性继承自Point，而且是private，因此在Rectangle对象中不能直接访问这两个属性，只能通过间接调用getX(),getY()函数获取 x,y属性的值。
继承与派生实验报告
继承与派生实验报告继承与派生实验报告引言：继承与派生是面向对象编程中的重要概念，通过继承，一个类可以派生出子类，从而实现代码的复用和扩展。
本文将通过实验来探讨继承与派生的概念、原理和应用。
实验目的：1. 理解继承与派生的概念和原理；2. 掌握如何在编程语言中实现继承和派生；3. 熟悉继承与派生的应用场景。
实验步骤：1. 创建父类：首先，我们创建一个名为"Animal"的父类，该类具有属性和方法，例如"age"和"eat()"。
2. 创建子类：接下来，我们创建一个名为"Cat"的子类，该类继承自"Animal"类。
在子类中，我们可以重写父类的方法或添加新的方法。
3. 实例化对象：通过实例化父类和子类的对象，我们可以调用它们的方法和访问它们的属性。
4. 测试继承与派生：我们可以通过调用父类和子类的方法，观察它们的行为是否符合预期。
实验结果：在创建父类"Animal"时，我们定义了一个"age"属性和一个"eat()"方法。
在创建子类"Cat"时，我们继承了父类的属性和方法，并添加了一个新的"meow()"方法。
在实例化父类对象时，我们可以通过调用"eat()"方法来模拟动物进食的行为。
而在实例化子类对象时，我们既可以调用从父类继承而来的"eat()"方法，也可以调用子类特有的"meow()"方法来模拟猫咪的叫声。
通过实验，我们发现继承与派生的优势在于代码的复用和扩展。
我们只需在父类中定义一次通用的属性和方法，然后让不同的子类继承父类，即可实现代码的复用。
同时，子类还可以通过重写父类的方法或添加新的方法，实现代码的扩展和个性化。
讨论与应用：继承与派生不仅仅局限于上述的父类和子类关系，它还可以在多层次的继承结构中发挥作用。
实验指导书06 类的继承与派生
C++ 面向对象程序设计 实验指导书
实验 06 类的继承与派生
1.1 时间安排 4 学时
本实验安排 4 个实验课时。
1.2 实验目的和要求
1、 从深层次上理解继承与派生的关系 2、 掌握不同继承方式下，从派生类/对象内部和外部对基类成员的访问控制权限。 3、 掌握单继承和多继承的使用方法，尤其是派生类构造函数的声明方式。 4、 掌握继承与派生下构造函数与析构函数的调用顺序。 5、 理解“类型兼容”原则 6、学习利用虚基类解决二义性问题。
C++ 面向对象程序设计 实验指导书 Supervisor * Sptr=new Supervisor("Tanya",8000.00,5000.00); //动态申请空间 cout<<"Name:"<<e.getName()<<endl; cout <<"Pay:"<<e.pay(60)<<endl; //设每月工作小时 cout <<"Name:"<<m.getName()<<endl; cout <<"Pay:"<<m.pay(40)<<endl; cout <<"Name:"<<Sptr->getName()<<endl; cout <<"Pay:"<<Sptr->pay(40)<<endl; //参数这里不起作用 cout<<"/*********类型兼容规则测试********************/"<<endl; /*三个Display，实质上调用的均是Employee的pay函数， 因此，在显示m、*Sptr的对象内容时，出现了与上面不符的结果。*/ Display(e,60); Display(m,40); Display(Sptr,40); }
实验六继承与派生之欧阳音创编
继承与组合一、实验目的1．了解继承在面向对象程序设计中的重要作用。
2．进一步理解继承与派生的概念。
3．掌握通过继承派生出一个新的类的方法。
4．了解虚基类的作用和用法。
5．掌握类的组合二、实验内容1．请先阅读下面的程序，写出程序运行的结果，然后再上机运行程序，验证自己分析的结果是否正确。
(1)#include <iostream>using namespace std;class A{public:A(){cout<<"A::A() called.\n";}virtual ~A(){cout<<"A::~A() called.\n";}};class B:public A{public:B(int i){ cout<<"B::B() called.\n";buf=new char[i];}virtual ~B(){ delete []buf;cout<<"B::~B() called.\n";}private:char *buf;};void fun(A *a){ cout<<"May you succeed!"<<endl;delete a;}int main(){A *a=new B(15);fun(a);return 0;}1、（1）程序运行结果：A::A() called.B::B() called.May you succeed!B::~B() called.A::~A() called.(2)#include<iostream>using namespace std;class A{public:A(int a,int b):x(a),y(b){ cout<<"A constructor..."<<endl; }void Add(int a,int b){ x+=a;y+=b;}voiddisplay(){ cout<<"("<<x<<","<<y<<")";}~A(){cout<<"destructor A..."<<endl;}private:int x,y;};class B:private A{private:int i,j;A Aobj;public:B(int a,int b,int c,int d):A(a,b),i(c),j(d) ,Aobj(1,1){ cout<<"B constructor..."<<endl;}void Add(int x1,int y1,int x2,int y2){A::Add(x1,y1);i+=x2; j+=y2;}void display(){A::display();Aobj.display();cout<<"("<<i<<","<<j<<")"<<endl;}~B(){cout<<"destructor B..."<<endl;} };int main(){B b(1,2,3,4);b.display();b.Add(1,3,5,7);b.display();return 0;}（2）程序运行结果：A constructor...A constructor...B constructor...(1,2) (1,1) (3,4)(2,5) (1,1) (8,11)destructor B...destructor A...destructor A...(3)#include<iostream>using namespace std;class A{public:A(int a):x(a){ cout<<"A constructor..."<<x<<endl; }int f(){return ++x;}~A(){cout<<"destructor A..."<<endl;} private:int x;};class B:public virtual A{private:int y;A Aobj;public:B(int a,int b,int c):A(a),y(c),Aobj(c){ cout<<"B constructor..."<<y<<endl;}int f(){A::f();Aobj.f();return ++y;}void display(){cout<<A::f()<<"\t"<<Aobj.f()<<"\t"<<f() <<endl; }~B(){cout<<"destructor B..."<<endl;} };class C:public B{public:C(int a,int b,int c):B(a,b,c),A(0){ cout<<"C constructor..."<<endl;}};class D:public C,public virtual A{public:D(int a,int b,int c):C(a,b,c),A(c){ cout<<"D constructor..."<<endl;}~D(){cout<<"destructor D..."<<endl;}};int main(){D d(7,8,9);d.f();d.display();return 0;}（3）程序运行结果：A constructor (9)A constructor (9)B constructor (9)C constructor...D constructor...12 12 11destructor D...destructor B...destructor A...destructor A...(4)#include <iostream>using namespace std;class Base1{public:Base1(){cout<<"class Base1!"<<endl;}};class Base2{public:Base2(){cout<<"class Base2!"<<endl;}};class Level1:public Base2,virtual public Base1{public:Level1(){cout<<"class Level1!"<<endl;}};class Level2: public Base2,virtual public Base1{public:Level2(){cout<<"class Level2!"<<endl;}};class TopLevel:public Level1,virtual public Level2{public:TopLevel(){cout<<"class TopLevel!"<<endl;}};int main(){TopLevel obj;return 0;}（4）程序运行结果：class Base1!class Base12class Leve12!class Base2!class Leve11!class TopLeve1!2．某出版系统发行图书和磁带，利用继承设计管理出版物的类。
实验6 类的继承与多态
安徽机电职业技术学院实验报告一、实验目的1、进一步掌握类的定义与使用；2、掌握类的继承，以及访问属性public, private和protected的用法；3、了解类的多态性；4、掌握使用类来构造应用程序。
二、实验内容使用Visual Studio .NET 2005，在Point-Circle-Cylinder示例程序中，添加一个圆锥体类(Cone)，该类派生自圆类(Circle)，并具有以下属性：高度(Height)，以及以下方法：Area （求圆锥体的表面积）、Volumn（求圆锥体的体积）三、实验步骤1、将服务器上“面向对象”课件的文件夹中的“Csharp示例\第7课\ Exercise”文件夹复制到本地磁盘上。
打开其中的“Exercise.sln”，完成其中的3个任务。
这3个任务目标写在Form1.cs文件中，需要在项目中添加2个类(圆类Circle, 圆锥体Cone)的定义。
2、将完成的源程序压缩后，连同本实验报告，一同通过电子邮件交给指导教师。
四、程序运行结果截图程序运行后单击"Circle类测试"按钮后的运行结果截图：程序运行后单击"Cone类测试"按钮后的运行结果截图：程序运行后单击"多态性测试"按钮后的运行结果截图：五、程序源代码(用Winrar压缩后用附件提交，源代码中要有比较完备的注释)，以下代码请粘贴于此：Circle类的代码：class Circle:Point{private double radius;public double Radius{get{return radius;}set{radius = value;}}public Circle(){this.X = 0;this.Y= 0;this.radius = 0;}public Circle( int X, int Y,double radius):base(X,Y){this.X = X;this.Y = Y;this.radius = radius;}public override double Area(){return Math.Round(Math.PI * Math.Pow(this.radius,2),2);}public double zhouchang(){return 2 * Math.PI * radius;}public override string Name{get{return"圆";}}public override string ToString(){return"圆心坐标="+ base.ToString() + "，半径=" + radius+"\r圆的周长="+Math.Round(this.zhouchang(),2);//return "圆心坐标=["+this.X+","+this.Y+"];半径="+ radius+"\n"+"圆的周长"+Math.Round(this.zhouchang())+"\n"+"圆的面积="+Math.Round(this.Areaes());}}任务1的代码：// TODO 1: 给本项目添加1个Circle类的定义，它继承自Point类Circle a = new Circle(5,5,5);string str=+":"+ a.ToString();Output(str);Cone类的代码：class Cone:Circle{private double Height;private double height{get{return Height;}set{Height = value;}}public Cone(){this.Height = 0;this.X = 0;this.Y = 0;}public Cone(int X, int Y, double radius, double Height):base(X,Y,radius) {this.X = X;this.Y = Y;this.Height = Height;this.Radius = radius;}public double Areas(){return base.Area() + (this.zhouchang() * Height) / 2;}public override double Volume(){return Math.Round((base.Area() * Height) / 3,2);}public override string Name{get{return"圆锥";}}public override string ToString(){return"圆心坐标=[" + this.X + "," + this.Y + "];半径=" + this.Radius + "\n" + "圆锥的高=" +this.Height+"圆锥的表面积="+Math.Round(this.Areas(),2);}}任务2的代码：// TODO 2: 给本项目添加1个Cone类的定义，它继承自Circle类Cone b = new Cone(1, 2, 3,4);string strs = + ":" + b.ToString();Output(strs);六、思考题：1、请说明private、public、protected这3个访问修饰符的作用public成员，可以从程序的任何位置，通过该类（基类或派生类）的对象引用，来访问它。
实验6 类的继承与派生
填写本次实验的实验原理（理论知识）或者流程图
5.实验过程或源代码
填写实际上机操作的实验步骤或主要源代码
6．实验结论及心得
填写本Байду номын сангаас实验的输出结果（如果有输出的话）、存在的问题、心得等内容
中北大学电子与计算机科学技术学院
实验报告
课程名称面向对象程序设计学号06060341X01学生姓名张三辅导教师况立群
系别
计算机科学与技术
实验室名称
软件基础实验室
实验时间
2008.9.18
1．实验名称
实验六类的继承与派生
2.实验目的
（1）学习定义和使用类的继承关系，定义派生类。
（2）熟悉不同继承方式下对基类成员的访问控制。
（3）学习利用虚基类解决二义性问题
3.实验内容
（1）定义一个基类Animal，有私有整型成员变量age，构造其派生类dog，在其成员函数SetAge(int n)中直接给age赋值，看看会有什么问题，把age改为公有成员变量，还会有问题吗？编程试试看。
（2）定义一个车(vehicle)基类，具有MaxSpeed、Weight等成员变量，Run、Stop等成员函数，由此派生出自行车(bicycle)类、汽车(motorcar)类。自行车类有高度(height)等属性，汽车类有座位数(SeatNum)等属性。从bicycle和motorcar派生出摩托车(motorcycle)类，在继承过程中，注意把vehicle设置为虚基类。如果不把vehicle设置为虚基类，会有什么问题？编程试试看。
实验六继承与派生之令狐文艳创作
继承与组合令狐文艳一、实验目的1．了解继承在面向对象程序设计中的重要作用。
2．进一步理解继承与派生的概念。
3．掌握通过继承派生出一个新的类的方法。
4．了解虚基类的作用和用法。
5．掌握类的组合二、实验内容1．请先阅读下面的程序，写出程序运行的结果，然后再上机运行程序，验证自己分析的结果是否正确。
(1)#include <iostream>using namespace std;class A{public:A(){cout<<"A::A() called.\n";}virtual ~A(){cout<<"A::~A() called.\n";}};class B:public A{public:B(int i){ cout<<"B::B() called.\n";buf=new char[i];}virtual ~B(){ delete []buf;cout<<"B::~B() called.\n";}private:char *buf;};void fun(A *a){ cout<<"May you succeed!"<<endl;delete a;}int main(){A *a=new B(15);fun(a);return 0;}1、（1）程序运行结果：A::A() called.B::B() called.May you succeed!B::~B() called.A::~A() called.(2)#include<iostream>using namespace std;class A{public:A(int a,int b):x(a),y(b){ cout<<"A constructor..."<<endl; }void Add(int a,int b){ x+=a;y+=b;}void display(){ cout<<"("<<x<<","<<y<<")";}~A(){cout<<"destructor A..."<<endl;}private:int x,y;};class B:private A{private:int i,j;A Aobj;public:B(int a,int b,int c,int d):A(a,b),i(c),j(d) ,Aobj(1,1){ cout<<"B constructor..."<<endl;} void Add(int x1,int y1,int x2,int y2){A::Add(x1,y1);i+=x2; j+=y2;}void display(){A::display();Aobj.display();cout<<"("<<i<<","<<j<<")"<<endl;}~B(){cout<<"destructor B..."<<endl;}};int main(){B b(1,2,3,4);b.display();b.Add(1,3,5,7);b.display();return 0;}（2）程序运行结果：A constructor...A constructor...B constructor...(1,2) (1,1) (3,4)(2,5) (1,1) (8,11)destructor B...destructor A...destructor A...(3)#include<iostream>using namespace std;class A{public:A(int a):x(a){ cout<<"A constructor..."<<x<<endl; }int f(){return ++x;}~A(){cout<<"destructor A..."<<endl;}private:int x;};class B:public virtual A{private:int y;A Aobj;public:B(int a,int b,int c):A(a),y(c),Aobj(c){ cout<<"B constructor..."<<y<<endl;}int f(){A::f();Aobj.f();return ++y;}void display(){cout<<A::f()<<"\t"<<Aobj.f()<<"\t"<<f()<<endl;}~B(){cout<<"destructor B..."<<endl;}};class C:public B{public:C(int a,int b,int c):B(a,b,c),A(0){ cout<<"C constructor..."<<endl;}};class D:public C,public virtual A{public:D(int a,int b,int c):C(a,b,c),A(c){ cout<<"D constructor..."<<endl;}~D(){cout<<"destructor D..."<<endl;}};int main(){D d(7,8,9);d.f();d.display();return 0;}（3）程序运行结果：A constructor (9)A constructor (9)B constructor (9)C constructor...D constructor...12 12 11destructor D...destructor B...destructor A...destructor A...(4)#include <iostream>using namespace std;class Base1{public:Base1(){cout<<"class Base1!"<<endl;}};class Base2{public:Base2(){cout<<"class Base2!"<<endl;}};class Level1:public Base2,virtual public Base1{public:Level1(){cout<<"class Level1!"<<endl;}};class Level2: public Base2,virtual public Base1{public:Level2(){cout<<"class Level2!"<<endl;}};class TopLevel:public Level1,virtual public Level2 {public:TopLevel(){cout<<"class TopLevel!"<<endl;}};int main(){TopLevel obj;return 0;}（4）程序运行结果：class Base1!class Base12class Leve12!class Base2!class Leve11!class TopLeve1!2．某出版系统发行图书和磁带，利用继承设计管理出版物的类。
C 继承与派生实验报告
C 继承与派生实验报告1. 引言继承与派生是面向对象编程中的基本概念之一，C语言作为一门面向过程的编程语言，也支持继承与派生的概念。
本实验旨在通过编写代码演示C语言中的继承与派生的使用方法，加深对这一概念的理解。
2. 继承与派生的概念继承是一种面向对象编程中的重要概念，通过继承，派生类可以继承基类的属性和方法。
在C语言中，继承是通过结构体嵌套的方式实现的。
派生是继承的一种特殊形式，通过派生，派生类可以在基类的基础上增加新的属性和方法。
3. 实验步骤步骤一：定义基类首先，我们需要定义一个基类，基类包含一些公共的属性和方法。
在C语言中，我们可以使用结构体来定义类。
typedef struct {int x;int y;} Point;上述代码定义了一个名为Point的结构体，它包含了两个整型属性x和y。
这个结构体可以看作是基类。
步骤二：定义派生类接下来，我们可以定义派生类，派生类通过嵌套包含基类的结构体来实现继承。
typedef struct {Point base; // 基类结构体int z; // 派生类自己的属性} Point3D;上述代码定义了一个名为Point3D的结构体，它嵌套包含了基类Point的结构体，并新增了一个整型属性z。
这个结构体可以看作是派生类。
步骤三：使用派生类在定义好派生类后，我们可以使用派生类来创建对象，并调用基类的属性和方法。
int main() {// 创建对象Point3D point3d;point3d.base.x = 1;point3d.base.y = 2;point3d.z = 3;// 调用基类属性printf("x: %d\n", point3d.base.x);printf("y: %d\n", point3d.base.y);// 调用派生类自己的属性printf("z: %d\n", point3d.z);return0;}上述代码示例了如何使用派生类创建对象，并访问基类的属性和派生类自己的属性。
实验六继承与派生之欧阳美创编
继承与组合一、实验目的1．了解继承在面向对象程序设计中的重要作用。
2．进一步理解继承与派生的概念。
3．掌握通过继承派生出一个新的类的方法。
4．了解虚基类的作用和用法。
5．掌握类的组合二、实验内容1．请先阅读下面的程序，写出程序运行的结果，然后再上机运行程序，验证自己分析的结果是否正确。
(1)#include <iostream>using namespace std;class A{public:A(){cout<<"A::A() called.\n";}virtual ~A(){cout<<"A::~A() called.\n";}};class B:public A{public:B(int i){ cout<<"B::B() called.\n";buf=new char[i];}virtual ~B(){ delete []buf;cout<<"B::~B() called.\n";}private:char *buf;};void fun(A *a){ cout<<"May you succeed!"<<endl;delete a;}int main(){A *a=new B(15);fun(a);return 0;}1、（1）程序运行结果：A::A() called.B::B() called.May you succeed!B::~B() called.A::~A() called.(2)#include<iostream>using namespace std;class A{public:A(int a,int b):x(a),y(b){ cout<<"A constructor..."<<endl; }void Add(int a,int b){ x+=a;y+=b;}void display(){ cout<<"("<<x<<","<<y<<")";}~A(){cout<<"destructor A..."<<endl;}private:int x,y;};class B:private A{private:int i,j;A Aobj;public:B(int a,int b,int c,int d):A(a,b),i(c),j(d) ,Aobj(1,1){ cout<<"B constructor..."<<endl;}void Add(int x1,int y1,int x2,int y2){A::Add(x1,y1);i+=x2; j+=y2;}void display(){A::display();Aobj.display();cout<<"("<<i<<","<<j<<")"<<endl;}~B(){cout<<"destructor B..."<<endl;}};int main(){B b(1,2,3,4);b.display();b.Add(1,3,5,7);b.display();return 0;}（2）程序运行结果：A constructor...A constructor...B constructor...(1,2) (1,1) (3,4)(2,5) (1,1) (8,11)destructor B...destructor A...destructor A...(3)#include<iostream>using namespace std;class A{public:A(int a):x(a){ cout<<"A constructor..."<<x<<endl;}int f(){return ++x;}~A(){cout<<"destructor A..."<<endl;}private:int x;};class B:public virtual A{private:int y;A Aobj;public:B(int a,int b,int c):A(a),y(c),Aobj(c){ cout<<"B constructor..."<<y<<endl;}int f(){A::f();Aobj.f();return ++y;}void display(){cout<<A::f()<<"\t"<<Aobj.f()<<"\t"<<f()<<endl; }~B(){cout<<"destructor B..."<<endl;}};class C:public B{public:C(int a,int b,int c):B(a,b,c),A(0){ cout<<"C constructor..."<<endl;}};class D:public C,public virtual A{public:D(int a,int b,int c):C(a,b,c),A(c){ cout<<"Dconstructor..."<<endl;}~D(){cout<<"destructor D..."<<endl;} };int main(){D d(7,8,9);d.f();d.display();return 0;}（3）程序运行结果：A constructor (9)A constructor (9)B constructor (9)C constructor...D constructor...12 12 11destructor D...destructor B...destructor A...destructor A...(4)#include <iostream>using namespace std;class Base1{public:Base1(){cout<<"class Base1!"<<endl;}};class Base2{public:{cout<<"class Base2!"<<endl;}};class Level1:public Base2,virtual public Base1{public:Level1(){cout<<"class Level1!"<<endl;}};class Level2: public Base2,virtual public Base1{public:Level2(){cout<<"class Level2!"<<endl;}};class TopLevel:public Level1,virtual public Level2 {public:TopLevel(){cout<<"class TopLevel!"<<endl;}};int main(){TopLevel obj;return 0;}（4）程序运行结果：class Base12class Leve12!class Base2!class Leve11!class TopLeve1!2．某出版系统发行图书和磁带，利用继承设计管理出版物的类。
C++实验报告--继承和派生
}
void show(){
Person::show();
cout<<"Teacher lesson:"<<lesson<<endl;
}
};
class Student:virtual public Person{
private:
{
cout<<"constructing...."<<endl;
}
void show(){
cout<<"YJSZJ:"<<endl;
Teacher::show();
Student::show();
}
};
void main(){
YJSZJ x(21,50,98.0,99.0,97.0,5000,02);
}
void show_biaomianji()
{
cout<<"表面积:"<< "2*(A*B+A*H+B*H)= "<<2*(A*B+A*H+B*H)<<" (cm2)"<<endl;;
}
};
void main(){
Point C(6,8),D(3,4);
C.showXY();
D.showXY();
int H;
public:
Cuboid(int H,int A,int B,int X,int Y):Rectangle(A,B,X,Y)
C 继承与派生实验报告
C 继承与派生实验报告C 继承与派生实验报告引言：在计算机编程领域，继承与派生是一种重要的概念。
通过继承，我们可以构建更加复杂和灵活的程序结构，提高代码的可重用性和可维护性。
本实验旨在通过实际操作和分析，深入理解C语言中继承与派生的原理和应用。
实验目的：1. 理解继承与派生的概念和原理；2. 掌握C语言中继承与派生的语法和用法；3. 实践继承与派生的应用，加深对其理解。
实验步骤：1. 创建基类和派生类：首先，我们创建一个基类Animal，其中包含一个成员函数eat()和一个成员变量name。
然后，我们创建一个派生类Dog，继承自基类Animal，并添加一个成员函数bark()和一个成员变量breed。
2. 实现继承与派生的功能：在基类Animal中，实现成员函数eat()，用于输出动物的进食行为。
在派生类Dog中，实现成员函数bark()，用于输出狗的吠叫行为。
同时，通过继承，派生类Dog可以直接访问基类Animal中的成员变量name。
3. 测试继承与派生的效果：在主函数中，创建一个Dog对象，并调用其成员函数eat()和bark()，以验证继承与派生的功能是否正常工作。
同时，可以通过修改派生类Dog的成员变量breed，观察其对程序运行结果的影响。
实验结果与分析：通过实验，我们可以发现继承与派生的强大功能。
基类Animal提供了一种通用的行为eat()，而派生类Dog则通过添加成员函数bark()，实现了更加具体和特定的行为。
这种继承与派生的关系，使得我们可以在保留原有功能的基础上，进行灵活的扩展和定制。
此外，通过继承，派生类Dog可以直接访问基类Animal中的成员变量name。
这种继承的特性，使得派生类可以共享基类的数据，避免了重复定义和冗余代码的问题。
同时，通过修改派生类Dog的成员变量breed，我们可以看到其对程序运行结果的影响。
这种灵活性，使得我们可以根据具体需求，定制不同的派生类，实现更加个性化的功能。
实验六继承与派生之欧阳家百创编
继承与组合欧阳家百（2021.03.07）一、实验目的1．了解继承在面向对象程序设计中的重要作用。
2．进一步理解继承与派生的概念。
3．掌握通过继承派生出一个新的类的方法。
4．了解虚基类的作用和用法。
5．掌握类的组合二、实验内容1．请先阅读下面的程序，写出程序运行的结果，然后再上机运行程序，验证自己分析的结果是否正确。
(1)#include <iostream>using namespace std;class A{public:A(){cout<<"A::A() called.\n";}virtual ~A(){cout<<"A::~A() called.\n";}};class B:public A{public:B(int i){ cout<<"B::B() called.\n";buf=new char[i];}virtual ~B(){ delete []buf;cout<<"B::~B() called.\n";}private:char *buf;};void fun(A *a){ cout<<"May you succeed!"<<endl;delete a;}int main(){A *a=new B(15);fun(a);return 0;}1、（1）程序运行结果：A::A() called.B::B() called.May you succeed!B::~B() called.A::~A() called.(2)#include<iostream>using namespace std;class A{public:A(int a,int b):x(a),y(b){ cout<<"A constructor..."<<endl; }void Add(int a,int b){ x+=a;y+=b;}void display(){ cout<<"("<<x<<","<<y<<")";}~A(){cout<<"destructor A..."<<endl;}private:int x,y;};class B:private A{private:int i,j;A Aobj;public:B(int a,int b,int c,int d):A(a,b),i(c),j(d) ,Aobj(1,1){ cout<<"B constructor..."<<endl;}void Add(int x1,int y1,int x2,int y2){A::Add(x1,y1);i+=x2; j+=y2;}void display(){A::display();Aobj.display();cout<<"("<<i<<","<<j<<")"<<endl;}~B(){cout<<"destructor B..."<<endl;}};int main(){B b(1,2,3,4);b.display();b.Add(1,3,5,7);b.display();return 0;}（2）程序运行结果：A constructor...A constructor...B constructor...(1,2) (1,1) (3,4)(2,5) (1,1) (8,11)destructor B...destructor A...destructor A...(3)#include<iostream>using namespace std;class A{public:A(int a):x(a){ cout<<"A constructor..."<<x<<endl; }int f(){return ++x;}~A(){cout<<"destructor A..."<<endl;}private:int x;};class B:public virtual A{private:int y;A Aobj;public:B(int a,int b,int c):A(a),y(c),Aobj(c){ cout<<"B constructor..."<<y<<endl;}int f(){A::f();Aobj.f();return ++y;}void display(){cout<<A::f()<<"\t"<<Aobj.f()<<"\t"<<f()<<endl; }~B(){cout<<"destructor B..."<<endl;}};class C:public B{public:C(int a,int b,int c):B(a,b,c),A(0){ cout<<"C constructor..."<<endl;}};class D:public C,public virtual A{public:D(int a,int b,int c):C(a,b,c),A(c){ cout<<"D constructor..."<<endl;}~D(){cout<<"destructor D..."<<endl;}};int main(){D d(7,8,9);d.f();d.display();return 0;}（3）程序运行结果：A constructor (9)A constructor (9)B constructor (9)C constructor...D constructor...12 12 11destructor D...destructor B...destructor A...destructor A...(4)#include <iostream>using namespace std;class Base1{public:Base1(){cout<<"class Base1!"<<endl;}};class Base2{public:Base2(){cout<<"class Base2!"<<endl;}};class Level1:public Base2,virtual public Base1{public:Level1(){cout<<"class Level1!"<<endl;}};class Level2: public Base2,virtual public Base1{public:Level2(){cout<<"class Level2!"<<endl;}};class TopLevel:public Level1,virtual public Level2 {public:TopLevel(){cout<<"class TopLevel!"<<endl;}};int main(){TopLevel obj;return 0;}（4）程序运行结果：class Base1!class Base12class Leve12!class Base2!class Leve11!class TopLeve1!2．某出版系统发行图书和磁带，利用继承设计管理出版物的类。
继承与派生的实验总结
继承与派生的实验总结继承与派生这事儿啊，可太有意思了。
我做这个实验的时候啊，就跟那刘姥姥进大观园似的，啥都新鲜。
我就瞅着那些代码啊，就像是一群小蚂蚁排着队，继承就像是一个小蚂蚁跟在大蚂蚁后面，大蚂蚁有的东西，小蚂蚁也有了一部分，可它又有点自己的小个性，这就是派生了。
我当时就对着电脑屏幕，眼睛瞪得跟铜铃似的，心里想：“这玩意儿可真神奇。
”我旁边坐的是小李，那小子头发乱得像个鸡窝，眼睛老是眯着，跟没睡醒似的。
他捣鼓这个实验比我快，我就凑过去问他：“小李啊，你这咋整的啊？我这继承咋就派生不出来我想要的东西呢？”小李看了我一眼，慢悠悠地说：“你看你，就跟那没头的苍蝇似的，乱撞。
你得先把基础的继承关系搞明白，就像盖房子，地基打不好，能往上盖楼吗？”我一听，觉得挺有道理，可还是有点迷糊。
我又回到我的座位上，看着那一行行代码，感觉它们像是在跟我作对。
我挠挠头，这时候阳光从窗户透进来，照在我脸上，暖烘烘的，可我心里却有点烦躁。
我就想啊，这继承和派生啊，就像家族里的事儿一样。
老祖宗传下来的东西，子孙后代有的好好继承，还能发展出自己的新玩意儿，有的就给弄丢了或者弄歪了。
这代码也是啊，从基类到派生类，得有个传承的脉络。
我就重新开始梳理，一行一行地看，一个字符一个字符地对。
这时候，我感觉我就像一个侦探，在寻找那些隐藏在代码里的线索。
突然，我就发现了问题所在，原来是我在一个函数的参数设置上出了岔子。
我一拍大腿，“原来是你这个小坏蛋在捣乱。
”我赶紧改过来，再一运行，成了！那感觉就像是在黑暗里摸索了好久，突然找到了灯的开关一样，整个世界都亮堂了。
这个实验让我明白啊，继承和派生可不只是简单的代码操作，它就像是一种传承的智慧，不管是在代码的世界里，还是在我们的生活中，都有着重要的意义呢。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
实验5 类的继承与派生
一．实验目的
⒈掌握C++类的继承编程方法。
⒉掌握构造函数链的调用次序。
二．实验时间
2节课。
三．实验内容
定义一个基础类Shape，在此基础上派生出Rectangle和Circle，在Rectanlge 的基础上派生出RoundRectangle类。
这些类都包括一个计算面积的getArea()函数。
提示：圆角矩形，就是在矩形类的基础上增加了圆角半径这个属性，由于四个圆角刚好可以构成一个圆，自己推算一下它的求面积公式。
要求：
（1）定义Shape，Rectangle，Circle，RoundRectangle类。
（Shape类中包括color属性，类型为string；其他类中所需要的属性自己定义）
（2）在每个类中定义有参构造函数和无参构造函数，析构函数，用于访问属性的get/set函数和getArea函数
（3）编写测试程序观察构造函数、析构函数的调用过程。
（4）创建两组Shape，Rectangle，Circle，RoundRectangle对象（分别调用无参构造函数和有参构造函数创建），并显示每个对象的颜色和面积（用打印语句显示是什么颜色，面积是多少）。
实验前思考题：
1. 如何正确的画出Shape，Rectangle，Circle，RoundRectangle类的继承关系图（类图）？
2. 在定义类图的时候有什么原则需要遵循？
四．实验要求
1.结合上课内容，写出程序，并调试程序，要给出程序的测试数据和实验结果。
2.整理上机步骤，总结经验和体会。
3.完成和上交源程序。
课前思考题，类图如下：
Shape
-color
+getArea()
Circle -radius
+getArea()
Rectangle
-width
-height
+getArea()
RoundRectangle -roundRadius
+getArea()。