实验三多态性实验报告

实验3 虚函数和多态性1实验目的(1)了解多态性的概念。

(2)了解虚函数的作用和使用方法。

(3)了解静态关联和动态关联的概念和用法。

(4)了解纯虚函数和抽象类的概念和用法。

2实验内容任务1：参照书中的例6.4，设计一个程序，声明抽象基类shape，由它派生出3个类：Circle （圆形）、Rectangle（矩形）、Triangle（直角三角形），用一个函数printArea分别输出以上三者的面积。

任务1参考程序#include <iostream.h>//定义抽象基类Shapeclass Shape{public:virtual double printArea() const=0;};//定义Circle类class Circle:public Shape{public:Circle(double r):radius(r){}virtual double printArea() const;protected:double radius;};double Circle::printArea( ) const{return 3.14159*radius*radius;}//定义矩形类class Rect:public Shape{public:Rect(double w,double h):width(w),height(h){}virtual double printArea( ) const;protected:double width,height;};double Rect::printArea() const{return width*height;}//定义直角三角形class Triangle:public Shape{public:Triangle(double w,double h):width(w),height(h){}virtual double printArea( ) const;protected:double width,height;};double Triangle::printArea() const{return 0.5*width*height;}void main(){Circle circle(12.6);cout << "area of circle = "<<circle.printArea() <<endl;Rect rect(4.5,8.4);cout << "area of rectangle = "<< rect.printArea() <<endl;Triangle trl(4.5,8.4);cout << "area of triangle = "<<trl.printArea() <<endl;}3预习内容第6章。

一、实验目的1. 理解多态性的概念及其在面向对象编程中的重要性。

2. 掌握多态性的实现方式，包括方法重载和方法覆盖。

3. 学习如何利用多态性提高代码的可读性和可维护性。

4. 通过实例分析，加深对多态性在实际编程中的应用理解。

二、实验背景多态性是面向对象编程中的一个核心概念，它允许同一个接口（或方法）根据不同的数据类型执行不同的操作。

在Java、C++等面向对象编程语言中，多态性主要通过方法重载和方法覆盖来实现。

三、实验内容1. 方法重载方法重载是指在同一个类中，允许存在多个同名方法，但参数列表不同。

编译器通过参数列表的匹配来确定调用哪个方法。

（1）实验步骤1）创建一个名为“Animal”的类，包含一个方法名为“makeSound”。

2）在“Animal”类中，添加三个重载的“makeSound”方法，分别接受不同类型的参数（如int、String、double）。

3）创建一个名为“Dog”的类，继承自“Animal”类，并重写“makeSound”方法，使其输出“Woof! Woof!”。

4）创建一个名为“Cat”的类，继承自“Animal”类，并重写“makeSound”方法，使其输出“Meow! Meow!”。

（2）实验结果当创建“Dog”和“Cat”对象时，调用“makeSound”方法会根据对象类型输出相应的声音。

2. 方法覆盖方法覆盖是指在子类中重写父类的方法，使子类的方法具有与父类方法相同的签名，但具有不同的实现。

（1）实验步骤1）创建一个名为“Vehicle”的类，包含一个方法名为“move”，该方法无参数。

2）创建一个名为“Car”的类，继承自“Vehicle”类，并重写“move”方法，使其输出“Car is moving”。

3）创建一个名为“Bike”的类，继承自“Vehicle”类，并重写“move”方法，使其输出“Bike is moving”。

（2）实验结果当创建“Car”和“Bike”对象时，调用“move”方法会根据对象类型输出相应的移动信息。

多态性与虚函数实验报告实验目的：通过实验掌握多态性和虚函数的概念及使用方法，理解多态性实现原理和虚函数的应用场景。

实验原理：1.多态性：多态性是指在面向对象编程中，同一种行为或者方法可以具有多种不同形态的能力。

它是面向对象编程的核心特性之一，能够提供更加灵活和可扩展的代码结构。

多态性主要通过继承和接口来实现。

继承是指子类可以重写父类的方法，实现自己的特定行为；接口是一种约束，定义了类应该实现的方法和属性。

2.虚函数：虚函数是在基类中声明的函数，它可以在派生类中被重新定义，以实现多态性。

在类的成员函数前面加上virtual关键字，就可以将它定义为虚函数。

当使用基类指针或引用调用虚函数时，实际调用的是派生类的重写函数。

实验步骤：1. 创建一个基类Shape，包含两个成员变量color和area，并声明一个虚函数printArea(用于打印面积。

2. 创建三个派生类Circle、Rectangle和Triangle，分别继承Shape类，并重写printArea(函数。

3. 在主函数中，通过基类指针分别指向派生类的对象，并调用printArea(函数，观察多态性的效果。

实验结果与分析：在实验中，通过创建Shape类和派生类Circle、Rectangle和Triangle，可以实现对不同形状图形面积的计算和打印。

当使用基类指针调用printArea(函数时，实际调用的是派生类的重写函数，而不是基类的函数。

这就是多态性的实现，通过基类指针或引用，能够调用不同对象的同名函数，实现了对不同对象的统一操作。

通过实验1.提高代码的可扩展性和灵活性：通过多态性，可以将一类具有相似功能的对象统一管理，节省了代码的重复编写和修改成本，增强了代码的可扩展性和灵活性。

2.简化代码结构：通过虚函数，可以将各个派生类的不同行为统一命名为同一个函数，简化了代码结构，提高了代码的可读性和维护性。

3.支持动态绑定：通过运行时的动态绑定，可以根据对象的实际类型来确定调用的函数，实现了动态绑定和多态性。

类的继承与多态性实验报告目录1.介绍2.什么是多态3.多态在Java中的技术基础4.示例5.多态的好处6.总结介绍之前的文章介绍过类的封装性和继承性，现在是时候聊聊面向对象编程的三大特性之一的最后一个类的多态性了。

多态的基础是继承（包括了接口的实现）和方法的覆盖。

什么是多态多态对应的英文单词是polymorphism，百度翻译给出的翻译是：n.多型现象，多态性; 多机组合形式;按字面意思就是多种状态、形态、姿态等等，潜台词就是某个东西具有多种状态、形态、姿态等等。

那是什么东西呢？在面向对象的编程语言里面（当然就包括Java了）就是某个方法或函数。

那方法的多种状态、形态、姿态有是个什么意思呢？这其实是指同一个方法具有多个方法体，就是方法的实现。

而方法的相同与否是由方法签名决定的。

所以，多态其实本质上是指同一个类的同一个方法却具有不同的行为特征。

状态、形态、姿态指的就是行为特征。

多态在Java中的技术基础然而，在Java中，同一个类里面是不可能存在两个签名相同而实现不同的方法的，否则的话会导致无法判断该执行哪个方法，因此在编译时就会报错。

所以，肯定是在两个类中才有可能存在两个签名相同而实现不同的方法，一个实现在这个类，另一个实现在另一个类。

而如果这两个类毫无瓜葛，那么肯定就与多态的本质（同一个类的同一个方法却具有不同的行为特征）自相矛盾了。

所以，这两个类肯定是有某种联系的。

我们再想想，什么概念是能够让两个不同的类却又能称为同一个类的？答案就是类的继承/扩展，就是现实中的“某东西是某类东西”的概念，就是“具体和抽象”的思想。

比如，男人是人，女人也是人，男人类和女人类就借助于人类建立了某种联系，而人类具有的某个行为在男人类和女人类中是有着不同体现的，比如人类的吃饭这个行为，男人类的体现是狼吞虎咽，女人类的体现是细嚼慢咽。

例子不是很恰当，但意思就是这么个意思。

所以说，Java里面多态的技术基础就是方法的覆盖，当然，在Java中覆盖不仅仅发生在类的继承/扩展上，还可能发生在接口的实现上。

实验三继承和多态一、实验目的1.熟练掌握封装性，多态性的概念。

2.熟练掌握抽象类abstract的概念。

3.熟练掌握接口interface的概念。

4.熟练包package的概念以及编译运行的方法。

二、实验内容1.编写一个Java Application程序，该程序有个点Point类，它包含横坐标x和纵坐标y 两个属性，再给Point定义两个构造方法和一个打印点坐标的方法Show。

定义一个圆Circle 类，它继承Point类（它是一个点，圆心（Center）），除此之外，还有属性半径Radius，再给圆定义2个构造方法、一个打印圆的面积的方法PrintArea和一个打印圆中心、半径的方法Show（其中显示圆心可以用super.Show()的方式）。

编写一测试类，对其进行编译、运行。

结果如何？如去掉语句“super.Show();”，再看看运行结果。

理解程序中重载和多态性的运用。

2.完成以下步骤要求：（1）设计一个表示二维平面上点的类Point，包含有表示坐标位置的protected类型的成员变量x和y，获取和设置x和y值的public方法。

（2）设计一个表示二维平面上圆的类Circle，它继承自类Point，还包含有表示圆半径的protected类型的成员变量r，获取和设置r值的public方法、计算圆面积的public 方法。

（3）设计一个表示圆柱体的类Cylinder，它继承自类Circle，还包含有表示圆柱体高的protected类型的成员变量h、获取和设置h值的public方法、计算圆柱体体积的public 方法。

（4)建立若干个Cylinder对象，输出其轴心位置坐标、半径、高及其体积的值。

3.学校中有老师和学生两类人，而在职研究生既是老师又是学生，对学生的管理和对教师的管理在他们身上都有体现。

（1）设计两个信息管理接口StudentInterface和TeacherInterfaceo其中，StudentInterface接口包括setFee方法和getFee方法，分别用于设置和获取学生的学费；TeacherInterface接口包括setPay方法和getPay方法，分别用于设置和获取教师的工资。

实验3 多态性实验课程名：面向对象程序设计（C++）专业班级：09计科（一）班学号：2******** 姓名：***** 实验时间：12.6 实验地点：K4-102 指导教师：祁文青{cout<<"D::f3(double)"<<3*x<<endl;}};int main(){D d;B*pb=&d;D*pd=&d;pb->f1(1.23);pb->f1(1.23);pb->f2(1.23);pb->f3(1.23);pb->f3(3.14);return 0;}程序的运行结果。

答：2.编写一个程序，其中设计一个时间类Time,用来保存时、分、秒等私有数据成员，通过重载操作符“+”实现两个时间的相加。

要求将小时范围限制在大于等于0，分钟范围限制在0~59，秒钟范围限制在0~59秒。

【提示】时间类Time{public:Time(int h=0,int m=0,int s=0);Time operator+(Time&);void disptime(string);private:int hourse;cout<<s<<hourse<<":"<<minutes<<":"<<seconds<<endl;}int main(){int hh,mm,ss;do{cout<<"输入第一个时间时分秒（例如2 30 42）"<<endl;cin>>hh>>mm>>ss;}while(hh<0||mm<0||mm>59||ss<0||ss>59);Time t(hh,mm,ss);do{cout<<"输入第二个时间时分秒（例如2 30 42）"<<endl;cin>>hh>>mm>>ss;}while(hh<0||mm<0||mm>59||ss<0||ss>59);Time T(hh,mm,ss),t_total;t_total=t+T;t_total.disptime("输出结果(时/分/秒):");return 0;}程序运行结果：3.给出下面的抽象基类container;class container{protected:double radius;public:container(double radius1);virtual double surface_area()=0;virtual double volume()=0;};要求建立3个继承container的派生类cube、sphere与cylinder，让每一个派生类都包含虚函数surface_area()和volume()，分别用来计算正方体、球体和圆柱体的表面积及体积。

淮海工学院计算机科学系实验报告书课程名：《 C++程序设计(二)》题目：多态性和虚函数班级：学号：姓名：1、实验内容或题目（1）声明二维坐标类作为基类派生圆的类，把派生类圆作为基类，派生圆柱体类。

其中，基类二维坐标类有成员数据：x、y坐标值；有成员函数：构造函数实现对基类成员数据的初始化、输出的成员函数，要求输出坐标位置。

派生类圆类有新增成员数据：半径（R）；有成员函数：构造函数实现对成员数据的初始化、计算圆面积的成员函数、输出半径的成员函数。

派生圆柱体类新增数据有高（H）；新增成员函数有：构造函数、计算圆柱体体积的函数和输出所有成员的函数。

请完成程序代码的编写、调试。

（2）教材393页7－8题。

（3）教材416页1、4、5题。

2、实验目的与要求（1）理解继承与派生的概念（2）掌握通过继承派生出一个新的类的方法（3）了解多态性的概念（4）了解虚函数的作用与使用方法3、实验步骤与源程序⑴实验步骤先定义一个基类point，及其成员函数，然后以public的继承方式定义子类circle，再定义一个派生类cylinder，最后在main主函数中定义类对象，调用函数实现其功能。

先定义一个基类A及其重载的构造函数,然后以Public派生出子类B，再定义其构造函数,最后在main主函数中定义类对象，调用成员函数实现其功能。

⑵源代码1.#include <iostream.h>class Point{public:Point(float=0,float=0);void setPoint(float,float);float getX() const {return x;}float getY() const {return y;}friend ostream & operator<<(ostream &,const Point &); protected:float x,y;};Point::Point(float a,float b){x=a;y=b;}void Point::setPoint(float a,float b){x=a;y=b;}ostream & operator<<(ostream &output,const Point &p){cout<<"["<<p.x<<","<<p.y<<"]"<<endl;return output;}class Circle:public Point{public:Circle(float x=0,float y=0,float r=0);void setRadius(float);float getRadius() const;float area () const;friend ostream &operator<<(ostream &,const Circle &); protected:float radius;};Circle::Circle(float a,float b,float r):Point(a,b),radius(r){}void Circle::setRadius(float r){radius=r;}float Circle::getRadius() const {return radius;}float Circle::area() const{return 3.14159*radius*radius;}ostream &operator<<(ostream &output,const Circle &c){cout<<"Center=["<<c.x<<","<<c.y<<"], r="<<c.radius<<", area="<<c.area()<<endl;return output;}class Cylinder:public Circle{public:Cylinder (float x=0,float y=0,float r=0,float h=0);void setHeight(float);float getHeight() const;float area() const;float volume() const;friend ostream& operator<<(ostream&,const Cylinder&);protected:float height;};Cylinder::Cylinder(float a,float b,float r,float h):Circle(a,b,r),height(h){}void Cylinder::setHeight(float h){height=h;}float Cylinder::getHeight() const {return height;}float Cylinder::area() const{return 2*Circle::area()+2*3.14159*radius*height;}float Cylinder::volume() const{return Circle::area()*height;}ostream &operator<<(ostream &output,const Cylinder& cy){cout<<"Center=["<<cy.x<<","<<cy.y<<"], r="<<cy.radius<<", h="<<cy.height <<"\narea="<<cy.area()<<", volume="<<cy.volume()<<endl;return output;}int main(){Cylinder cy1(3.5,6.4,5.2,10);cout<<"\noriginal cylinder:\nx="<<cy1.getX()<<", y="<<cy1.getY()<<", r=" <<cy1.getRadius()<<", h="<<cy1.getHeight()<<"\narea="<<cy1.area()<<", volume="<<cy1.volume()<<endl;cy1.setHeight(15);cy1.setRadius(7.5);cy1.setPoint(5,5);cout<<"\nnew cylinder:\n"<<cy1;Point &pRef=cy1;cout<<"\npRef as a point:"<<pRef;Circle &cRef=cy1;cout<<"\ncRef as a Circle:"<<cRef;return 0;}2．(1)#include <iostream>using namespace std;class A{public:A(){a=0;b=0;}A(int i){a=i;b=0;}A(int i,int j){a=i;b=j;}void display(){cout<<"a="<<a<<" b="<<b;} private:int a;int b;};class B : public A{public:B(){c=0;}B(int i):A(i){c=0;}B(int i,int j):A(i,j){c=0;}B(int i,int j,int k):A(i,j){c=k;}void display1(){display();cout<<" c="<<c<<endl;}private:int c;};int main(){B b1;B b2(1);B b3(1,3);B b4(1,3,5);b1.display1();b2.display1();b3.display1();b4.display1();return 0;}(2)#include <iostream>using namespace std;class A{public:A(){cout<<"constructing A "<<endl;} ~A(){cout<<"destructing A "<<endl;} };class B : public A{public:B(){cout<<"constructing B "<<endl;} ~B(){cout<<"destructing B "<<endl;} };class C : public B{public:C(){cout<<"constructing C "<<endl;}~C(){cout<<"destructing C "<<endl;}};int main(){C c1;return 0;}3.(1)//Point.hclass Point{public:Point(float=0,float=0);void setPoint(float,float);float getX() const {return x;}float getY() const {return y;}friend ostream & operator<<(ostream &,const Point &); protected:float x,y;}//Point.cppPoint::Point(float a,float b){x=a;y=b;}void Point::setPoint(float a,float b){x=a;y=b;}ostream & operator<<(ostream &output,const Point &p){output<<"["<<p.x<<","<<p.y<<"]"<<endl;return output;}//Circle.h#include "point.h"class Circle:public Point{public:Circle(float x=0,float y=0,float r=0);void setRadius(float);float getRadius() const;float area () const;friend ostream &operator<<(ostream &,const Circle &);protected:float radius;};//Circle.cppCircle::Circle(float a,float b,float r):Point(a,b),radius(r){}void Circle::setRadius(float r){radius=r;}float Circle::getRadius() const {return radius;}float Circle::area() const{return 3.14159*radius*radius;}ostream &operator<<(ostream &output,const Circle &c){output<<"Center=["<<c.x<<","<<c.y<<"], r="<<c.radius<<", area="<<c.area()<<endl;return output;}//Cylinder.h#include "circle.h"class Cylinder:public Circle{public:Cylinder (float x=0,float y=0,float r=0,float h=0);void setHeight(float);float getHeight() const;float area() const;float volume() const;friend ostream& operator<<(ostream&,const Cylinder&);protected:float height;};//Cylinder.cppCylinder::Cylinder(float a,float b,float r,float h):Circle(a,b,r),height(h){}void Cylinder::setHeight(float h){height=h;}float Cylinder::getHeight() const {return height;}float Cylinder::area() const{ return 2*Circle::area()+2*3.14159*radius*height;}float Cylinder::volume() const{return Circle::area()*height;}ostream &operator<<(ostream &output,const Cylinder& cy){output<<"Center=["<<cy.x<<","<<cy.y<<"], r="<<cy.radius<<", h="<<cy.height<<"\narea="<<cy.area()<<", volume="<<cy.volume()<<endl;return output;}//main.cpp#include <iostream.h>#include "cylinder.h"#include "point.cpp"#include "circle.cpp"#include "cylinder.cpp"int main(){Cylinder cy1(3.5,6.4,5.2,10);cout<<"\noriginal cylinder:\nx="<<cy1.getX()<<", y="<<cy1.getY()<<", r=" <<cy1.getRadius()<<", h="<<cy1.getHeight()<<"\narea="<<cy1.area()<<", volume="<<cy1.volume()<<endl;cy1.setHeight(15);cy1.setRadius(7.5);cy1.setPoint(5,5);cout<<"\nnew cylinder:\n"<<cy1;Point &pRef=cy1;cout<<"\npRef as a point:"<<pRef;Circle &cRef=cy1;cout<<"\ncRef as a Circle:"<<cRef;return 0;}(2)#include <iostream>using namespace std;class Shape{public:virtual double area() const =0;class Circle:public Shape{public:Circle(double r):radius(r){} virtual double area() const {return 3.14159*radius*radius;}; protected:double radius;};class Rectangle:public Shape{public:Rectangle(double w,double h):width(w),height(h){} virtual double area() const {return width*height;} protected:double width,height; };class Triangle:public Shape{public:Triangle(double w,double h):width(w),height(h){} virtual double area() const {return 0.5*width*height;} protected:double width,height; };void printArea(const Shape &s)cout<<s.area()<<endl;} int main(){Circle circle(12.6);cout<<"area of circle =";printArea(circle);Rectangle rectangle(4.5,8.4);cout<<"area of rectangle =";printArea(rectangle);Triangle triangle(4.5,8.4);cout<<"area of triangle =";printArea(triangle);return 0;}(3)#include <iostream>using namespace std;class Shape{public:virtual double area() const =0;};class Circle:public Shape{public:Circle(double r):radius(r){}virtual double area() const {return 3.14159*radius*radius;}; protected:double radius;class Square:public Shape{public:Square(double s):side(s){}virtual double area() const {return side*side;}protected:double side;};class Rectangle:public Shape{public:Rectangle(double w,double h):width(w),height(h){}virtual double area() const {return width*height;}protected:double width,height; };class Trapezoid:public Shape{public:Trapezoid(double t,double b,double h):top(t),bottom(t),height(h){} virtual double area() const {return 0.5*(top+bottom)*height;} protected:double top,bottom,height;};class Triangle:public Shapepublic:Triangle(double w,double h):width(w),height(h){}virtual double area() const {return 0.5*width*height;} protected:double width,height;};int main(){Circle circle(12.6);Square square(3.5);Rectangle rectangle(4.5,8.4);Trapezoid trapezoid(2.0,4.5,3.2);Triangle triangle(4.5,8.4);Shape *pt[5]={&circle,&square,&rectangle,&trapezoid,&triangle};double areas=0.0;for(int i=0;i<5;i++){areas=areas+pt[i]->area();}cout<<"totol of all areas="<<areas<<endl;return 0;}4、测试数据与实验结果（可以抓图粘贴）5、结果分析与实验体会继承时，子类对基类的访问属性，基类的私有成员无论以何种方式继承在子类中都是不可访问的，唯有调用基类中的成员函数方可访问其私有变量。

河南**大学实验报告课程名称面向对象程序设计名称实验三多态性院系＿信息工程学院＿＿班级＿＿计科172学生姓名＿ ** ＿＿实验三多态性一．实验目的本实验的目的是使学生了虚函数的作用，掌握多态的概念、编译时多态、运行时多态，掌握运算符重载和虚函数的用法。

二．实验环境Visual C++ 6.0 及以上版本。

三．实验内容熟悉掌握C++多态的相关知识。

根据老师布置的实验题目，提前分析题目要求所需要的类，设计好解决题目要求需要的对象个数，设计解决问题需要的主函数等。

题目可以从以下题目中选择一个。

1．定义一个实数类Real，类中包括一个数据成员real，构造函数、display()函数以及重载的+、-、*、/运算符。

用公有继承方式声明一个复数类Complex，该类包括两个数据成员real，image，并重载Real类的函数和+、-、*、/运算符。

编写一个复数四则运算计算器。

2.Shape是一个几何图形的基类，它至少有求自身周长函数Circumference()和求自身面积函数Area()。

从Shape类派生出Circle类、Ellipse类、Triangle 类和Rectangle类，分别继承基类Shape的Circumference()和Area()，并增加新的成员。

编写主函数，定义各派生类对象，求多派生类对象的周长之和、面积之和。

3．其它和本实验目的相符的题目，根据学生实际情况增加相应的题目，但题目难度不应低于以上两个题目。

注意：从以上题目中选择一个作为实验题目。

选择题目2四、实验原理1.按照题目要求分析解决问题需要的类；2.进行类的设计并实现；3.分析解决问题需要定义的对象及对象间的消息传递关系；4.设计主函数实现题目要求。

五、数据结构和程序设计实验中出现的问题以及解决方案：问题一：改为六、实验总结学习使用虚函数实验动态多态性。

而虚函数就是在基类中被关键字virtual说明，并在派生类中重新定义的函数，且在派生类中重工业新定义时，函数原型，包括返回类型、函数名、参数个数与参数类型的顺序，都必须与基类中的完全相同。

实验四 NaCl盐析法提DNA及HLA多态性分析一、实验目的（1）掌握盐析法提取DNA方法；（2）掌握PCR扩增HLA基因序列的方法；（3）了解HLA多态性。

二、实验原理（1）盐析法提取DNA原理DNA和蛋白质等其他成分在不同浓度的NaCl溶液中溶解度不同,利用这一特点选择适当的盐浓度就能使DNA充分溶解而使杂质沉淀或者相反以达到分离目的。

DNA在NaCl溶液中的溶解度先增大后减小，在DNA溶解度最低时DNA从溶液中析出，而其他杂质还留在溶液中达到粗提取的目的。

（2）PCR技术的原理在DNA聚合酶催化下，以母链DNA为模板，以特定引物为延伸起点，通过变性、退火、延伸等步骤，体外复制出与母链模板DNA 互补的子链DNA的过程。

是一项DNA体外合成放大技术，能快速特异地在体外扩增任何目的DNA。

三、实验材料（1）全血样品；NaCl；Tris-HCl；蛋白酶K；70%乙醇；无水乙醇；MgCl2；SDS；乙二胺四乙酸(EDTA)；琼脂糖；PCR试剂。

四、操作方法DNA提取：1.新鲜抗凝全血或冻存抗凝全血0.5ml置于2ml离心管中,补3倍体积的红细胞裂解液(0.01mol/L Tris-HCL pH7.6; 0.01mol/L NaCl; 0.005mol/L MgCl2)混合，2500 rpm离心15 min，移去上清，再用同体积的红细胞裂解液两次裂解红细胞，沉淀用生理盐水洗涤1次，收集白细胞沉淀。

2.沉淀中加入150μl TE混匀，再加15μl 10% SDS及蛋白酶K 20μl，56℃消化过夜, 得到清亮粘绸的液体。

加入235μl 5mol/L NaCl，轻轻摇匀至少1min，5000rpm离心10min；3.将上清转至另一支1.5ml离心管中，加860μl无水乙醇颠倒摇动数次至DNA絮状析出，离心10000转/分，10分钟；4.加860μl冰冻70%乙醇混合去盐，12000rpm离心3min，弃上清，重复一次。

一、实验目的通过本次实验，加深对多态性的理解，掌握多态性的基本概念、实现方式以及在Java语言中的应用，提高面向对象编程的能力。

二、实验环境1. 操作系统：Windows 102. 开发工具：Eclipse3. 编程语言：Java三、实验内容1. 多态性基本概念多态性是指同一个操作作用于不同的对象，可以有不同的解释，产生不同的执行结果。

在Java中，多态性主要表现在两个方面：方法重载和方法重写。

2. 方法重载方法重载是指在一个类中，允许存在多个名称相同、参数列表不同的方法。

编译器通过参数列表来区分这些方法，实现多态性。

（1）实验步骤1) 创建一个名为“Shape”的类，包含一个方法“draw()”，该方法不接受任何参数。

2) 在“Shape”类中添加三个方法：draw(String color)，draw(String color, int size)，draw(int x, int y)。

3) 创建一个名为“Circle”的类，继承自“Shape”类，并添加一个名为“draw”的方法，该方法接受一个int类型的参数radius。

4) 创建一个名为“Rectangle”的类，继承自“Shape”类，并添加一个名为“draw”的方法，该方法接受两个int类型的参数width和height。

5) 在主类中创建“Circle”和“Rectangle”对象，并调用它们的draw()方法。

（2）实验结果当执行程序时，根据传入的参数不同，调用不同的draw()方法。

3. 方法重写方法重写是指子类在继承父类的基础上，对父类的方法进行修改，实现多态性。

（1）实验步骤1) 创建一个名为“Animal”的类，包含一个名为“makeSound”的方法。

2) 创建一个名为“Dog”的类，继承自“Animal”类，并重写“makeSound”方法，使其输出“汪汪”。

3) 创建一个名为“Cat”的类，继承自“Animal”类，并重写“makeSound”方法，使其输出“喵喵”。

继承与多态实验报告继承与多态实验报告在面向对象编程中，继承和多态是两个重要的概念。

通过继承，我们可以创建新的类，并从现有的类中继承属性和方法。

而多态则允许我们使用父类的引用来指向子类的对象，实现同一操作具有不同的行为。

本实验旨在通过实际的编程实践，加深对继承和多态的理解。

实验一：继承在这个实验中，我们创建了一个动物类（Animal），并从它派生出了两个子类：狗类（Dog）和猫类（Cat）。

动物类具有一些共同的属性和方法，如名字（name）和发出声音（makeSound）。

子类继承了父类的属性和方法，并可以添加自己的特定属性和方法。

在编写代码时，我们首先定义了动物类，并在其中实现了共同的属性和方法。

然后，我们创建了狗类和猫类，并分别在这两个类中添加了自己的特定属性和方法。

通过继承，我们可以在子类中直接使用父类的方法，并且可以根据需要进行重写。

实验二：多态在这个实验中，我们使用多态的概念来实现一个动物园的场景。

我们定义了一个动物园类（Zoo），并在其中创建了一个动物数组。

这个数组可以存储不同类型的动物对象，包括狗、猫等。

通过多态，我们可以使用动物类的引用来指向不同类型的动物对象。

例如，我们可以使用动物类的引用来指向狗对象，并调用狗类特有的方法。

这样，我们可以统一处理不同类型的动物对象，而不需要为每种类型编写特定的处理代码。

实验三：继承与多态的结合应用在这个实验中，我们进一步探索了继承和多态的结合应用。

我们定义了一个图形类（Shape），并从它派生出了三个子类：圆形类（Circle）、矩形类（Rectangle）和三角形类（Triangle）。

每个子类都实现了自己的特定属性和方法。

通过继承和多态，我们可以在图形类中定义一些通用的方法，如计算面积和周长。

然后，我们可以使用图形类的引用来指向不同类型的图形对象，并调用相应的方法。

这样，我们可以轻松地对不同类型的图形进行统一的处理。

结论：通过本次实验，我们进一步理解了继承和多态的概念，并学会了如何在编程中应用它们。

多态性实验报告多态性实验报告引言：多态性是面向对象编程中的一个重要概念，它允许对象在不同的上下文中表现出不同的行为。

本实验旨在通过一系列的实验来探究多态性的概念和应用，以及它对程序设计的影响。

实验一：多态性的概念在本实验的第一部分，我们首先对多态性的概念进行了深入的研究。

多态性是指同一个方法在不同的对象上表现出不同的行为。

例如，在一个动物类中，不同的子类（如狗、猫、鸟）都可以实现一个叫声的方法，但是每个子类的叫声是不同的。

这种灵活性使得我们可以编写更加通用和可扩展的代码。

实验二：多态性的应用在第二个实验中，我们通过一个图形绘制的例子来展示多态性的应用。

我们创建了一个抽象的图形类，并派生出不同的子类，如圆形、矩形和三角形。

每个子类都实现了一个绘制方法，但是绘制的方式和结果是不同的。

通过将这些不同的子类对象存储在一个通用的图形数组中，我们可以轻松地遍历并绘制每个图形，而无需关心具体的子类类型。

实验三：多态性的优势和局限性在第三个实验中，我们深入研究了多态性的优势和局限性。

多态性使得代码更加灵活和可扩展，可以减少代码的重复性。

然而，过度使用多态性可能会导致代码的复杂性增加，降低程序的性能。

因此，在设计和实现中需要权衡多态性的使用。

实验四：多态性在实际项目中的应用在最后一个实验中，我们通过一个实际的项目来展示多态性的应用。

我们选择了一个图书管理系统作为例子，其中包括了不同类型的图书，如小说、教材和杂志。

通过使用多态性，我们可以统一管理这些不同类型的图书，并实现一套通用的借阅和归还功能。

这样，无论新增了多少种类型的图书，我们都可以轻松地扩展和修改代码。

结论：通过本次实验，我们深入了解了多态性的概念和应用，并通过一系列的实验来验证和探究多态性在程序设计中的作用。

多态性的使用可以使代码更加灵活和可扩展，但也需要在设计和实现中进行合理的权衡。

在实际项目中，多态性可以帮助我们更好地管理和处理不同类型的对象，提高代码的可维护性和可扩展性。

c++实验多态性实验报告C+＋实验多态性实验报告一、实验目的本次实验的主要目的是深入理解和掌握 C+＋中的多态性概念及其实现方式。

通过实际编程和运行代码，体会多态性在面向对象编程中的重要作用，提高编程能力和对 C+＋语言特性的运用水平。

二、实验环境本次实验使用的编程环境为 Visual Studio 2019，操作系统为Windows 10。

三、实验内容（一）虚函数1、定义一个基类｀Shape`，其中包含一个虚函数｀area(）｀用于计算图形的面积。

2、派生类｀Circle` 和｀Rectangle` 分别重写｀area(）｀函数来计算圆形和矩形的面积。

（二）纯虚函数1、定义一个抽象基类｀Vehicle`，其中包含一个纯虚函数｀move(）｀。

2、派生类｀Car` 和｀Bicycle` 分别实现｀move(）｀函数来描述汽车和自行车的移动方式。

（三）动态多态性1、创建一个基类指针数组，分别指向不同的派生类对象。

2、通过基类指针调用虚函数，观察多态性的效果。

四、实验步骤（一）虚函数实现1、定义基类｀Shape` 如下：｀｀｀cppclass Shape ｛public:virtual double area(）＝ 0;｝；｀｀｀2、派生类｀Circle` 的定义及｀area(）｀函数的实现：｀｀｀cppclass Circle ： public Shape ｛private:double radius;public:Circle(double r) ： radius(r) ｛｝double area(）｛return 314 radius radius;｝｝；｀｀｀3、派生类｀Rectangle` 的定义及｀area(）｀函数的实现：｀｀｀cppclass Rectangle ： public Shape ｛private:double length, width;public:Rectangle(double l, double w) ： length(l)， width(w) ｛｝double area(）｛return length width;｝｀｀｀（二）纯虚函数实现1、定义抽象基类｀Vehicle` 如下：｀｀｀cppclass Vehicle ｛public:virtual void move(）＝ 0;｝；｀｀｀2、派生类｀Car` 的定义及｀move(）｀函数的实现：｀｀｀cppclass Car ： public Vehicle ｛public:void move(）｛std:：cout ＜＜＂Car is moving on the road＂＜＜ std:：endl;｝｝；3、派生类｀Bicycle` 的定义及｀move(）｀函数的实现：｀｀｀cppclass Bicycle ： public Vehicle ｛public:void move(）｛std:：cout ＜＜＂Bicycle is moving on the path＂＜＜ std:：endl;｝｝；｀｀｀（三）动态多态性实现1、创建基类指针数组并指向不同的派生类对象：｀｀｀cppShape shapes2;shapes0 ＝ new Circle(50)；shapes1 ＝ new Rectangle(40, 60)；｀｀｀2、通过基类指针调用虚函数：｀｀｀cppfor （int i ＝ 0; i ＜ 2; i+＋）｛std:：cout ＜＜＂Area: ＂＜＜ shapesi>area(）＜＜ std:：endl;｝｀｀｀五、实验结果（一）虚函数实验结果运行程序后，能够正确计算出圆形和矩形的面积，并输出到控制台。

浙江理工大学信息学院实验指导书实验名称：类的多态性的实现学时安排：3实验类别：设计性实验实验要求：1人1组学号：姓名：￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣一、实验目的1.理解重载运算符的意义。

2.掌握使用成员函数、友员函数重载运算符的特点。

3.掌握重载运算符函数的调用方法。

4.掌握动态联编的概念。

5.掌握虚函数和纯虚函数的使用方法。

二、实验原理介绍设计性实验具体原理请见实验内容和步骤实现对抽象类的继承，通过operator函数调用的形式,实现运算符的重载三、实验设备介绍软件需求: windows或linux下的c++编译器硬件需求: 对于硬件方面的要求，建议配置是Pentium III 450以上的CPU处理器，64MB以上的内存，200MB的自由硬盘空间、CD-ROM驱动器、能支持24位真彩色的显示卡、彩色显示器、打印机。

四、实验内容某公司的员工有经理Manager、技术人员Technicist和营销人员SalsePerson，他们的薪金计算方法如下：经理按月计酬，方法是：基本工资+奖金；技术人员按月计酬，方法是：基本工资；营销人员按月计酬，方法是：基本工资+销售利润*5%。

每类人员都有职工编号、姓名、性别、入职时间、职位、基本工资等数据；各类人员使用统一接口get_pay()计算各类人员的月薪，重载<<运算符实现员工信息的输出。

其次，设计一个统计并输出该公司员工当月薪金情况的报表类Report，该类提供insert接口向Report类的容器中添加员工信息，并提供print接口用于展示以职位为单位的每个员工的职工编号、姓名、性别、入职时间以及当月该员工的薪酬，并统计出该职位员工薪酬的最高值和最低值。

为了提供更方便的查找功能，请为Report类重载[]运算符，下标值为职位，能根据职位信息查找出所有符合该职位的员工。

在主函数中对实现的类进行测试，首先，创建各类人员对象，通过Report类的insert接口向报表中添加这些人员信息，然后通过Report类的print接口输出当月员工薪酬情况报表。

实验三多态与模板一、声明一个Shape抽象类，在此基础上派生出Rectangle和Circle类，二者都有GetArea （）和GetPerim（）函数，GetArea用来计算对象的面积，GetPerim用来计算对象的周长。

封装上述各类，并编写测试程序。

Shape.h的内容：class Shape{public:Shape();virtual void GetArea();virtual void GetPerim();virtual ~Shape();};Shape.cpp的内容：#include "Shape.h"Shape::Shape(){}Shape::~Shape(){}void Shape::GetArea(){}void Shape::GetPerim(){}Circle.h的内容：#include "Shape.h"class CCircle : public Shape{public:virtual void GetPerim();virtual void GetArea();CCircle();virtual ~CCircle();private:float r;};Circle.cpp中的内容#include "Circle.h"#include "math.h"#include "iostream.h"CCircle::CCircle(){cout<<"请输入圆的半径："<<endl;cin>>r;}CCircle::~CCircle(){cout<<"Thank you very much!";}void CCircle::GetArea(){ float s;float pi=3.14;s=pi*r*r;cout<<"这个圆形的面积是:"<<s<<endl;} void CCircle::GetPerim(){ float c;float pi=3.14;c=2*pi*r;cout<<"这个圆形的周长是:"<<c<<endl; } Rectangle.h中的内容：#include"Shape.h"class Rectangle: public Shape{private:float a,b;public:Rectangle();virtual void GetArea();virtual void GetPerim();virtual ~Rectangle();};Rectangle.cpp中的内容：#include "Rectangle.h"#include "math.h"#include "iostream.h"Rectangle::Rectangle(){ cout<<"请输入矩形的长和宽："<<endl;cin>>a>>b;}Rectangle::~Rectangle(){ cout<<"Thank you very much!"<<endl;}void Rectangle::GetArea(){ float s;s=a*b;cout<<"这个矩形的面积是:"<<s<<endl;} void Rectangle::GetPerim(){ float c;c=a+a+b+b;cout<<"这个矩形的周长是:"<<c<<endl;} Shapetest.cpp中的内容：#include"Circle.h"#include"Rectangle.h"#include "iostream.h"int main(){ CCircle C;C.GetArea();C.GetPerim();Rectangle R;R.GetArea();R.GetPerim();return 0;}二、有一种栈，这种栈是按数组索引减小的方向增长的。