实验报告5多态性
实验报告5 继承与多态
实验名称:继承与多态一.实验目的:((1)理解继承的含义,掌握派生类的定义方法和实现;(2)理解虚函数在类的继承层次中的作用,虚函数的引入对程序运行时的影响,能够对使用虚函数的简单程序写出程序结果。
(3)编写体现类的继承性(成员变量,成员方法,成员变量隐藏)的程序;(4)编写体现类多态性(成员方法重载,构造方法重载)的程序。
(5)理解接口和抽象类、抽象方法的定义和实现方法;(5)理解接口和抽象类的差别。
二.上机内容:(1)进行类的继承和基类构造方法的应用的练习;(2)进行类的多态性练习(3)进行抽象类和接口的练习(4)整理上机步骤,总结经验和体会。
(5)完成实验报告。
三.上机步骤:类的继承和基类构造方法的应用(1)编写一个学生和教师数据输入和显示程序,学生数据有编号、姓名、班级和成绩,教师数据有编号、姓名、职称和部门。
要求将编号、姓名输入和显示设计成一个类person,并作为学生数据操作类student和教师类数据操作类teacher的基类。
using System;using System.Collections.Generic;using System.Text;namespace ConsoleApplication2{class person{public string bh;//编号public string xm;//姓名public person(string bh, string xm){this.bh = bh;this.xm = xm;}public void show(){Console.WriteLine("姓名:{0}", xm);Console.WriteLine("编号:{0}", bh);}}class student : person{public string bj;//班级public int cj;//成绩public student(string sbh, string sxm, string sbj, int scj): base(sbh, sxm){bh = sbh;xm = sxm;bj = sbj;cj = scj;}public new void show(){Console.WriteLine("***student***");Console.WriteLine("姓名:{0}", xm);Console.WriteLine("编号:{0}", bh);Console.WriteLine("班级:{0}", bj);Console.WriteLine("成绩:{0}", cj);}}class teacher : person{public string zc;//职称public string bm;//部门public teacher(string tbh, string txm, string tzc, string tbm) : base(tbh, txm){bh = tbh;xm = txm;zc = tzc;bm = tbm;}public new void show(){Console.WriteLine("***teacher***");Console.WriteLine("姓名:{0}", xm);Console.WriteLine("编号:{0}", bh);Console.WriteLine("职称:{0}", zc);Console.WriteLine("部门:{0}", bm);}}class program{static void Main(string[] args){student st = new student("050013", "张三", "信管091", 91);st.show();teacher te = new teacher("046950", "范仲淹", "特级教师", "教务处"); te.show();Console.ReadLine();}}}运行结果:(2)将以上程序尝试改成通过调用基类构造方法的方式来初始化编号和姓名,并总结调用基类构造方法的应用要点。
多态性实验报告
多态性实验报告一、实验目的本次实验的主要目的是深入研究和理解多态性这一重要的概念,并通过实际操作和观察来验证多态性在不同情境下的表现和作用。
二、实验原理多态性是面向对象编程中的一个关键特性,它允许不同的对象对相同的消息或操作做出不同的响应。
这种特性基于类的继承和方法的重写机制。
当一个父类的引用指向子类对象时,通过该引用调用方法时,实际执行的是子类中重写的方法,从而实现了多态性。
三、实验材料与环境1、编程语言:选择了 Java 作为实验的编程语言。
2、开发工具:使用了 IntelliJ IDEA 作为集成开发环境。
3、实验设备:一台配置良好的计算机,操作系统为 Windows 10。
四、实验步骤1、创建父类`Shape````javaclass Shape {public void draw(){Systemoutprintln("Drawing a shape");}}```2、创建子类`Circle` 和`Square` 继承自`Shape````javaclass Circle extends Shape {@Overridepublic void draw(){Systemoutprintln("Drawing a circle");}}class Square extends Shape {@Overridepublic void draw(){Systemoutprintln("Drawing a square");}}```3、在主函数中进行测试```javapublic class PolymorphismTest {public static void main(String args) {Shape shape1 = new Circle();Shape shape2 = new Square();shape1draw();shape2draw();}}```五、实验结果运行上述代码,输出结果为:```Drawing a circleDrawing a square```这表明,通过父类的引用调用`draw` 方法时,实际执行的是子类中重写的方法,实现了多态性。
Java实验报告继承、多态、接口和异常处理
Java实验报告继承、多态、接⼝和异常处理实验5 继承、多态、接⼝和异常处理⼀、实验⽬的1、掌握Java的类和对象的声明和使⽤⽅法;2、掌握Java的类的继承和实现⽅法;3、掌握多态性在类的继承中的运⽤;4、掌握接⼝的定义与使⽤;5、掌握基本异常的处理机制;6、熟悉try语句与catch语句的搭配使⽤;7、了解有异常处理与没有异常处理的差别;8、多重catch语句的使⽤;9、使⽤Throws声明异常和Throw抛出异常。
⼆、实验环境1、PC微机;2、DOS操作系统或 Windows 操作系统;3、Java sdk程序开发环境、eclipse集成环境。
三、实验内容1. 设计三个类,分别是学⽣类Student,本科⽣类UnderGraduate,研究⽣类Postjgraduate,其中Student类是⼀个抽象类,它包含学⽣的基本信息如姓名、所学课程、课程成绩等,⽽Undergraduate类和Postgraduate类都是Student类的⼦类,这两个类计算课程成绩等级的⽅法有所不同,如下表所⽰。
假设某班级⾥既有研究⽣⼜有本科⽣,编写程序统计出全班学⽣2. 和Mobilephone具体实现,并设计⼀个应⽤程序类来使⽤这些类。
3.要求设计⼀个GUI图形窗⼝程序,该程序让⽤户输⼊⼀个星期中的任意⼀天的数字1-7,然后输出该数字所对应的是星期⼏。
四、实验步骤实验内容⼀1.建⽴package experiment5_1,其最终⽬录结构如下:2.建⽴Student类:package experiment5_1;public abstract class Student {final static int CourseNo = 3;String name;String type;int[] courses;String courseGrade;public Student(String name) {/doc/1bd4a299a66e58fafab069dc5022aaea998f41e2.html = name; courses = new int[CourseNo];courseGrade = "" ;}public abstract void calculateGrade();public String getName( ) {return name;}public String getType( ) {return type ;}public String getCourseGrade( ) {return courseGrade;}public int getCourseScore(int courseNumber) {return courses[courseNumber];}public void setName(String name) {/doc/1bd4a299a66e58fafab069dc5022aaea998f41e2.html = name;}public void setType(String type) {this.type = type;}public void setCourseScore(int courseNumber, int courseScore) { //按课程索引号设置课程成绩this.courses[courseNumber] = courseScore ;}}3.建⽴外部类(1)研究⽣类Postjgraduatepackage experiment5_1;public class postgraduate extends Student {public postgraduate(String name) {super(name);type = "研究⽣";}public void calculateGrade() {// TODO Auto-generated method stubint total = 0;double average = 0;for (int i = 0; i < CourseNo; i++) {total += courses[i];};average = total / CourseNo;if (average>=90&&average<100) courseGrade = "优秀"; else if (average>=80&&average<90) courseGrade = "良好"; else if (average>=70&&average<80) courseGrade = "⼀般"; else if (average>=60&&average<70) courseGrade = "及格"; else courseGrade = "不及格";}}(2)本科⽣类UnderGraduatepackage experiment5_1;public class undergraduate extends Student {public undergraduate(String name ) {super(name);type = "本科⽣";}public void calculateGrade() {int total = 0;double average = 0;for (int i = 0; i < CourseNo; i++) {total += getCourseScore(i) ;};average = total / CourseNo;if (average>=80&&average<100) courseGrade = "优秀"; else if (average>=70&&average<80) courseGrade = "良好"; else if (average>=60&&average<70) courseGrade = "⼀般"; else if (average>=50&&average<60) courseGrade = "及格"; else courseGrade = "不及格";}}4.编写代码测试函数package experiment5_1;public class polymorphism {public static void main(String[] args) {Student[] students = new Student[5];students[0] = new undergraduate("陈建平");students[1] = new undergraduate("鲁向东");students[2] = new postgraduate("匡晓华");students[3] = new undergraduate("周丽娜");students[4] = new postgraduate("梁欣欣");for (int i=0; i<5 ;i++) {students[i].setCourseScore(0,87);students[i].setCourseScore(1,90);students[i].setCourseScore(2,78);}for (int i=0; i<5 ;i++) {students[i].calculateGrade();}System.out.println("姓名" + " 类型" +" 成绩");System.out.println("-----------------------");for (int i=0; i<5 ;i++) {System.out.println(students[i].getName( )+" "+students[i].getType( )+" "+students[i].getCourseGrade( ));}}}实验内容⼆1.建⽴package experiment5_2,其最终⽬录结构如下:2.写接⼝Soundable代码:package experiment5_2;public interface Soundable {public void increaseV olume( );public void decreaseV olume( );public void stopSound( );public void playSound( );}3.创建三个类Radio、Walkman和Mobilephone具体实现,分别添加代码:// Mobilephone类package experiment5_2;class Mobilephone implements Soundable{public void increaseV olume( ) {System.out.println("增⼤⼿机⾳量");}public void decreaseV olume( ) {System.out.println("减⼩⼿机⾳量");}public void stopSound( ) {System.out.println("关闭⼿机");}public void playSound( ) {System.out.println("⼿机发出来电铃声");}}// Walkman类package experiment5_2;class Walkman implements Soundable { public void increaseV olume( ) { System.out.println("增⼤随声听⾳量"); }public void decreaseV olume( ) { System.out.println("减⼩随声听⾳量"); }public void stopSound( ) {System.out.println("关闭随声听");}public void playSound( ) {System.out.println("随声听发出⾳乐"); }}// Radio类package experiment5_2;class Radio implements Soundable{ public void increaseV olume( ) { System.out.println("增⼤收⾳机⾳量"); }public void decreaseV olume( ) { System.out.println("减⼩收⾳机⾳量"); }public void stopSound( ) {System.out.println("关闭收⾳机");}public void playSound( ) {System.out.println("收⾳机播放⼴播"); }}4.创建people类及编写测试代码://People类package experiment5_2;class People {public void listen(Soundable s) {s.playSound( );}}//测试代码package experiment5_2;import java.util.Scanner;public class InterfaceTest {public static void main(String[] args) {int i;People sportsman = new People( );Scanner scanner = new Scanner(System.in);Soundable[] soundDevice = new Soundable[3];//往声⾳设备数组中放⼊能发声的设备soundDevice[0] = new Radio( );soundDevice[1] = new Walkman( );soundDevice[2] = new Mobilephone();System.out.println("你想听什么? 请输⼊选择:0-收⾳机1-随声听2-⼿机");i = scanner.nextInt( );//开始听声⾳sportsman.listen(soundDevice[i]);soundDevice[i].increaseV olume( );soundDevice[i].stopSound();scanner.close();}}实验内容三1.建⽴package experiment5_3,其最终⽬录结构如下package experiment5_3;import java.awt.*;import java.awt.event.*;import javax.swing.*;public class DateTransf extends JFrame implements KeyListener{/****/private static final long serialVersionUID = 1L;private static DateTransf frm;private static JTextField txt;private static JTextField data;DateTransf() {setTitle("数字与星期转换");setLocation(700, 300);setSize(400,130);}public static void main(String[] args) {frm = new DateTransf();frm.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);frm.setLayout(new GridLayout(2,2));txt = new JTextField(12);data = new JTextField(12);JLabel lable1 = new JLabel("输⼊数字:");JLabel lable2 = new JLabel("星期⼏:");frm.add(lable1);txt.addKeyListener(frm);frm.add(txt);frm.add(lable2);frm.add(data);frm.setVisible(true);}public void keyPressed(KeyEvent e) {if (e.getSource() == txt) {if (e.getKeyCode() == KeyEvent.VK_ENTER) // 判断按下的键是否是回车键{try {int number = Integer.parseInt(txt.getText());switch (number) {case 1:data.setText("Mon");break;case 2:data.setText("Tue");break;case 3:data.setText("Wen");break;case 4:data.setText("Thu");break;case 5:data.setText("Fri");break;case 6:data.setText("Sat");break;case 7:data.setText("Sun");break;default:JOptionPane.showMessageDialog(null, "您输⼊的数字不是1~7","⽆效⽇期",/doc/1bd4a299a66e58fafab069dc5022aaea998f41e2.html RMATION_MESSAGE); break;}}catch (Exception e1) {// TODO: handle exceptionJOptionPane.showMessageDialog(null, "您输⼊的不是整数","⽆效⽇期",/doc/1bd4a299a66e58fafab069dc5022aaea998f41e2.html RMA TION_MESSAGE); }}}}public void keyReleased(KeyEvent e) {}public void keyTyped(KeyEvent e) {}}2.编译运⾏五、实验结果●实验内容⼀结果:●实验内容⼆结果:●实验内容三结果:六、实验⼩结1.这次实验的内容⽐较多,需要掌握Java的类和对象的声明和使⽤⽅法、Java的类的继承和实现⽅法、多态性在类的继承中的运⽤、接⼝的定义与使⽤、基本异常的处理机制、try语句与catch语句的搭配使⽤等等;2. 在实验过程中,重点是要区分好实例和类,灵活掌握类的调⽤。
多态性与虚函数实验报告
多态性与虚函数实验报告实验目的:通过实验掌握多态性和虚函数的概念及使用方法,理解多态性实现原理和虚函数的应用场景。
实验原理: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中覆盖不仅仅发生在类的继承/扩展上,还可能发生在接口的实现上。
多态性
位点多态性是由于等位基因之间在特定的位点上DNA序列存在差异,也就是基因组中散在的碱基的不同,包 括点突变(转换和颠换),单个碱基的置换、缺失和插入。突变是基因多态性的一种特殊形式,单个碱基的置换 又称为单核苷酸多态性(single nucleotide polymorphism, SNP), SNP通常是一种二等位基因(biallelic) 或二态的变异。据估计,单碱基变异的频率在1/1000-2/1000。SNP在基因组中数量巨大,分布频密,检测易于自 动化和批量化,被认为是新一代的遗传标记。
类型
遗传和变异这一对既对立又统一的内在矛盾,在外在环境的影响下相互作用,促生了生物群体遗传多态性的 存在,进而提供了物种进Байду номын сангаас的动力。根据一个群体中各种变异类型的比例,可以把遗传多态性分为两种类型:
平衡型:一个群体中各种变异类型的比数可以长期保持不变,呈现所谓平衡型(或稳定)多态现象;
过渡型:一个群体中各种变异在一种类型取代另一种类型的过程中所呈现的多态现象,这里各种变异类型的 比数逐渐发生变化,因此称为过渡型(不稳定)多态现象。
基因
1
定义
2
成因
3
生物学作用
4
医学意义
5
检测方法
定义
基因多态性(gene polymorphism)是指处于随机婚配的群体中,同一基因位点可存在2种以上的基因型。 在人群中,个体间基因的核苷酸序列存在着差异性称为DNA基因多态性(gene polymorphism)。这种多态性可以 分为两类,即DNA位点多态性(site polymorphism)和长度多态性 (length polymorphism)。
度量
遗传多态性现象是指同一生物群体中,两种或两种以上变异类型或基因型并存的现象。一般认为每种变异型 的频率超过1%即可定为多态现象,不足1%的称为罕见变异型。
实验3-多态性
A5=a1.operator*(a2)
A6=A1/A2;
A6=a1.perator/(a2)
A3=++A1;
A3=operator++(a1)
A4=A2++;
A4=a2.operator++
实 验 报 告
四、实验小结(包括问题和解决方法、心得体会、意见与建议等)
1.在题目(1)中由①②两步,请总结关于动态多态性的实现方法。
纯虚函数不能被调用,因为它只有函数名,而无具体实现代码,无法实现具体的
功能。
3.其它问题和解决方法:
在做第二个题时,把成员函数当作友元函数那样去重载运算符了,编译时报错说
参数过多,还没搞明白为什么,最后被老师指出来才发现,
4.心得体会:
看着教材上的例题照猫画虎竟然还出错了,有时针对不同的情况要有相应的处理
a6=a1/a2;
cout<<"a1=";
a1.print();
cout<<"a2=";
a2.print();
cout<<"a3=a1+a2=";
a3.print();
cout<<"a4=a1-a2=";
a4.print();
cout<<"a5=a1*a2=";
a5.print();
cout<<"a6=a1/a2=";
friend Complex operator-(const Complex &c1,const Complex &c2);
C 实验多态性实验报告
class Point { public:
Point(int xx,int yy):x(xx),y(yy) {} void display()const; Point &operator++(); Point operator++(int); Point &operator--(); Point operator--(int); private:
using namespace std;
int Double(int x);
long Double(long x);
float Double(float x);
double Double(double x);
int main()
{ int myInt = 6500;
cout<<Double(myInt)<<endl;
学习使用虚函数实现动态多态性。而虚函数就是在基类中被关键字 virtual 说明,
实 并在派生类中重新定义的函数,且在派生类中重工业新定义时,函数原型,包括返回
类型、函数名、参数个数与参数类型的顺序,都必须与基类中的完全相同。此外,构 验
造函数不能是虚函数,但析构函数可以是虚函数。
总
函数的重载方法有一参数个数相同,但是类型不同;二参数个数不同;三 coust
实
验 Visual C++的编译环境下,独立完成实验要求的内容,独立完成编写、编译以及运行
原
的过程
理
实
验 安装了 Visual C++的 PC 机器
仪
器
实验5 多态性
实验5 多态性实验目的:理解静态和动态多态性。
掌握运算符重载的基本方法。
掌握虚函数的定义与使用方法。
实验内容:编写程序,定义抽象基类Shape(形状),由它派生出2个派生类: Circle(圆形)和Square (正方形),用函数ShowArea()分别显示各种图形的面积,最后还要显示所有图形的总面积。
要求用基类指针数组,数组的每个元素指向一个派生类对象。
在如下界面中显示信息实验步骤:(基于MFC对话框应用程序实现。
)1、界面设计2、控件变量定义3、在项目中创建“myshape.h”文件;“myshape.h”内容:const double PI = 3.1415926; // 常量PIconst int NUM = 4; // 常量NUM// 声明形状抽象类class MyShape{public:// 公有成员:virtual ~MyShape() { } // 虚析构函数virtual double ShowArea() const = 0; // 纯虚函数, 显示面积};// 声明矩形类class MyRectangle: public MyShape{private:// 数据成员:double height; // 高double width; // 宽public:// 公有函数:MyRectangle(double h, double w): height(h), width(w) { }// 构造函数double ShowArea() const // 显示面积{//cout << "矩形面积:" << height * width << endl;return(height * width);}};// 声明圆形类class MyCircle: public MyShape{private:// 数据成员:double radius; // 半径public:// 公有函数:MyCircle(double r): radius(r) { } // 构造函数double ShowArea() const // 显示面积{//cout << "圆面积:" << PI * radius * radius << endl;return(PI * radius * radius);}};在“*Dlg.cpp”中引用“myshape.h”及进行基类指针数组声明, #include “myshape.h”//引用MyShape * mysha[NUM]; //基类指针数组声明4、加入单击按钮时的事件响应代码4.1添加矩形类图形“添加矩形”按钮程序void CShapeDlg::OnRectangle(){// TODO: Add your control notification handler code here if (m_var1<NUM){UpdateData(true);mysha[m_var1] = new MyRectangle(m_var2,m_var3); // mysha[i]指向矩形对象m_var1++;UpdateData(false);}else{MessageBox("图形已定义完成!");}}4.2添加圆类图形“添加圆”按钮程序void CShapeDlg::OnCircle(){// TODO: Add your control notification handler code hereif (m_var1<NUM){UpdateData(true);mysha[m_var1] = new MyCircle(m_var4); // mysha[i]指向圆对象m_var1++;UpdateData(false);}else{MessageBox("图形已定义完成,不能再定义!");}}4.3计算面积“计算面积”按钮程序void CShapeDlg::OnArea(){// TODO: Add your control notification handler code here CString c1;double s1,s2;int i;if (m_var1==0){return;}m_var5.Format("");s2=0;for (i=0;i<m_var1;i++){s1=mysha[i]->ShowArea();c1.Format("图形%d面积:%f \r\n",i,s1);s2=s2+s1;m_var5 +=c1;}c1.Format("\r\n图形总面积:%f \r\n ",s2);m_var5 +=c1;UpdateData(false);}。
C++实验五 多态性
实验五多态性1.分析并调试下列程序,写出程序的输出结果。
运行结果:
2.编写一个程序,其中设计一个时间类time类,用来保存时,分,秒等私有数据成员,
通过重载操作符“+”实现两个时间的相加。
要求将小时范围限制在大于等于0.分钟范围限制在0~59分钟,秒钟范围限制在0~59秒。
运行结果:
3.给出下面的抽象基类,要求建立3个集成container的派生类,cube,sphere,cylinder,
让每一个派生类都包含虚函数surface-area()和volume(),分别用来计算正方体,球体和圆柱体的表面积及体积。
要求写出主程序,应用c++的多态性,分别计算边长为的正方体,半径为的球体以及半径为5,高位=为6的圆柱体的表面积和体积。
运行结果:。
多态性实验报告
一、实验目的通过本次实验,加深对多态性的理解,掌握多态性的基本概念、实现方式以及在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”方法,使其输出“喵喵”。
实验报告多态性
一、实验目的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”方法会根据对象类型输出相应的移动信息。
人类基因组多态性研究
人类基因组多态性研究人类的基因组多态性是指人类基因组内不同个体间存在的差异。
这些差异可以是单核苷酸多态性(SNP)、基因型、染色体结构的变异等。
基因组多态性可以影响人类遗传性状的表现和发生率,因此对于基因组多态性的研究是非常重要的。
在过去的一段时间里,人类基因组多态性的研究获得了长足的发展。
整个人类基因组已经被精确地测序,使得大规模的比较分析成为可能。
此外,随着高通量测序技术的发展,我们现在能够更加高效地研究基因组多态性。
基因组多态性研究的主要意义在于帮助我们理解个体遗传学和人类进化。
例如,研究人类基因组多态性可以鉴别人群之间的演化历史,从而揭示人类进化的分支、迁徙和起源等。
同样,基因组多态性研究可以帮助我们理解遗传性状和疾病的发病机理。
不同的遗传变异因素,如SNP、CNV和基因突变等,可以引起不同范围和强度的基因表达调节,进而导致特定疾病的发生和风险。
举例而言,肥胖症是一个常见的代谢疾病,其发病率与基因多态性的存在有关。
通过对肥胖相关基因的研究,可以更好地了解这些基因对肥胖的贡献。
基因组多态性研究的另一个重要应用是个性化医疗。
了解个体基因组多态性可以帮助医生确定患者的个性化治疗方案,并提高治疗效果。
例如,对于利用凝血酶抑制剂进行治疗的患者,患者的基因组多态性会影响他们对药物的反应,从而需要根据患者的基因组数据个性化制定用药方案。
然而,基因组多态性研究也存在一些挑战和争议。
首先,基因组多态性的研究成本较高,需要大规模的样本数据和高精度的测序技术。
此外,对于基因多态性的解读和分析也需要复杂的统计算法和生物信息学工具的支持。
同时,慎重考虑和管理基因组多态性的应用也是非常重要的。
例如,应用基因组多态性数据可能会引发个人隐私保护和道德伦理等问题,这些问题需要更加细致的考虑和规划。
总体而言,基因组多态性研究是一项非常有意义和挑战性的研究,对于深化我们对人类遗传性状、疾病和进化的了解,以及促进个性化医疗的发展,都有着重要的意义。
基因多态性研究及其应用
目前动态突变疾病大多是些神经系统的退行性 疾病,也有少数肿瘤。动态突变疾病的发现提 示序列拷贝数的多态性能够成为遗传病的病因。
?突变碱基及对应的正常碱基匀位于寡核苷酸片段的中央严格控制杂交及洗脱条件使只有与探针序列完全互补的等位基因片段才显示杂交信号而与探针中央碱基不同的等位基因片段不显示杂交信号?如果正常和突变探针都可杂交说明突变基因是杂合子如只有突变探针可以杂交说明突变基因为纯合子?若不能与含有突变序列的寡核苷探针杂交但能与相应的正常的寡核苷探针杂交则表示受检者不存在这种突变基因
其原理是:用PCR扩增后,产物进行斑 点杂交或狭缝杂交,针对每种突变分别 合成一对寡核苷酸片段作为探针,其中 一个具有正常序列,另一个则具有突变 碱基。
突变碱基及对应的正常碱 基匀位于寡核苷酸片 段的中央,严格控制杂交及洗脱条件,使只有 与探针序列完全互补的等位基因片段才显示杂 交信号,而与探针中央碱基不同的等位基因片 段不显示杂交信号,
据估计,单碱基变异的频率在1/1000-2/1000。 SNP在基因组中数量巨大,分布频密,检测易 于自动化和批量化,被认为是新一代的遗传标 记。
2. 长度多态性
一类为可变数目串联重复序列(variable number of tandem repeats, VNTRS), 它是由于相同的重复顺序重复次数不同 所致,它决定了小卫星DNA(mini satellite)长度的多态性。
基因多态性研究及其应用ห้องสมุดไป่ตู้
多态性和虚函数 实验报告
淮海工学院计算机科学系实验报告书课程名:《 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、结果分析与实验体会继承时,子类对基类的访问属性,基类的私有成员无论以何种方式继承在子类中都是不可访问的,唯有调用基类中的成员函数方可访问其私有变量。
5-基因多态性检测信息解读及其临床应用(郭瑞臣)
SLCO1B1*15是伊立替康产生腹泻、白细 胞减少和中性粒细胞减少等不良反应的主要 危险因素;
OATP1B1多态性对洛伐他汀血浓度影响
Chinese Malay
与白种人AUC0-t相比,中国人 高于其2.31倍,马来人高于其
1.91倍,印度人高于其1.63倍
Asian-Indian
White
OCT2与顺铂吸收明显相关,可增加其肾脏累积,引起较强 肾毒性。但对卡铂吸收几无作用
ALDH2*1野生型ALDH1活性较高,较多乙醛被代谢,肝硬化较少发生; ALDH2*2突变型ALDH2活性较低,乙醛蓄积,为肝硬化易感人群
突变型酶表达及活性
• 突变型亚基影响四聚体的稳定性,进而影响酶 的正常表达和活性。
• 携带ALDH2*2的纯合子(AA)和杂合子(GA)四 聚ALDH2均无活性。
葡萄糖醛酸化,使SN-38蓄积
Yakugaku Zasshi 2008,128(4): 575-584; Pharmacogenetics and Genomics 2007, 17:497–504
多态性与虚函数实验报告
cout<<"三角形的底为:"<<width<<"高为:"<<height <<"面积为:"<<width*height/2<<endl;
}
private:
float width,height;
};
class Circle:public Base
{
public:
Circle(float r){radius = r;}
p= &obj1;
p->area();
p=&obj2;
p->area();
return 0;
}
【实验结果与数据处理】
【实验结论】
分析:用虚函数实现多态。
【实验器材】
微型计算机、Visual C++ 6.0集成软件平台
【实验步骤】
1.编辑源程序。
2.对源程序进行编译并调试程序。
3.连接并运行程序。
4.检查输出结果是否正确。程序设计如下:
#include<iostream.h>
const float PI = 3.14;
class Base
多态性与虚函数实验报告
实验题目
多态性与虚函数
日期
班级
组别
姓名
类型
【实验目的】
1.理解多态性的概念。
2.了解编译时的多态和运行时的多态。
3.掌握虚函数的定义及实现,掌握虚析构函数的使用方法。
4.了解纯虚函数和抽象类的关系及用法。
【实验原理】
设计一个基类Base,其作用是计算一个图形的面积,它只有一个公有的函数成员虚函数area。再从Base类公有派生一个三角形类Triangle和一个圆类Circle,在类Triangle和类Circle中分别定义自己的area函数,用于计算各自的面积。在主函数中设计一个Base类的对象指针,分别指向类Triangle和类Circle的对象,调用各自的area函数显示相应对象的面积。
C++多态性实验报告含代码和结果截图
C++多态性实验报告含代码和结果截图实验报告课程:面向对象技术学号:姓名:班级:教师:计算机科学与技术系实验六多态性一、实验目的及要求1.掌握运算符重载的方法;2.掌握使用虚函数实现动态多态性。
二、实验环境硬件:计算机软件:Microsoft Visual C++三、实验内容声明一个车(vehicle)基类,有Run、Stop等成员函数,由此派生出自行车(bicycle)类、汽车(motorcar)类,从bicycle和motorcar派生出摩托车(motorcycle)类,它们都有Run、Stop等成员函数。
观察虚函数的作用。
四、实验结果(附截图)五、总结通过本次实验,我对虚函数、多态性有了进一步了解,对多态性也有了更深的认识,实验中还是有很多的问题不是很清楚,平时要认真学习好理论知识,这样才能在做实验时更好的理解代码,才能更快的改正自己调试时遇到的错误。
六、附录(源程序清单)#includeusing namespace std;int sign=0;class vehicle{vehicle(float m,float w){if(m<240&&m>0)MaxSpeed=m;else{cout<<"汽车超速!"<<endl;< p="">sign=1;return;}if(w<500&&w>0)Weight=w;else{cout<<"汽车超重!"<<endl;< p="">sign=1;return;}cout<<"构造了一个vehicle对象"<<endl;< p="">}virtual void Run() { cout<<"vehicle Run 函数被调用"<<endl;}< p="">virtual void Stop(){ cout<<"vehicle Stop 函数被调用"<<endl<<="">float MaxSpeed;float Weight;}class bicycle:virtual public vehicle{public:bicycle(float h,float m,float w):vehicle(m,w){if(h<1.5&&h>0)Height=h;elsecout<<"自行车超高!"<<endl;< p="">sign=1;return;}cout<<"构造了一个bicycle对象"<<endl;< p="">}void Run() { cout<<"bicycle Run 函数被调用"<<endl;}< p=""> void Stop(){ cout<<"bicycle Stop 函数被调用"<<endl<<endl;}< p="">private:float Height;}class motorcar:virtual public vehicle{public:motorcar(float s,float m,float w):vehicle(m,w){if(s<2&&s>0)SeatNum=s;else{cout<<"摩托车超载!"<<endl;< p="">sign=1;return;}cout<<"构造了一个motorcar对象"<<endl;< p="">}void Run() { cout<<"motorcar Run 函数被调用"<<endl;}< p="">void Stop(){ cout<<"motorcar Stop 函数被调用"<<endl<<endl;}< p="">private:float SeatNum;}class motorcycle:public bicycle,public motorcar{public:motorcycle(float h,float s,float m,float w):bicycle(h,m,w),motorcar(s,m,w),vehi cle(m,w){if(sign==0){cout<<"构造了一个motorcycle对象"<<endl;< p="">}}void Run() { cout<<"motorcycle Run 函数被调用"<<endl;}< p="">void Stop(){ cout<<"motorcycle Stop 函数被调用"<<endl<<endl;}< p="">};void main (){float m,w,h,s;int p;do{sign=0;cout<<"请输入参数:"<<endl<<endl;< p="">cout<<"汽车最高时速(km/h)";cin>>m;cout<<"汽车重量(t)";cin>>w;cout<<"自行车高度(m)";cin>>h;cout<<"摩托车座位(个)";cin>>s;motorcycle car(h,s,m,w);if(sign==0){car.Run();car.Stop();}else{cout<<"1—重新输入2——结束程序";cin>>p;if(p==2)return;elsecout<<endl<<endl;< p=""> }}while(sign==1);}</endl<<endl;<></endl<<endl;<></endl<<endl;}<></endl;}<></endl;<></endl<<endl;}<></endl;}<></endl;<></endl;<></endl<<endl;}<></endl;}<></endl;<></endl;<></endl<</endl;}<></endl;<></endl;<></endl;<>。
多态性实验报告
多态性实验报告多态性实验报告引言:多态性是面向对象编程中的一个重要概念,它允许对象在不同的上下文中表现出不同的行为。
本实验旨在通过一系列的实验来探究多态性的概念和应用,以及它对程序设计的影响。
实验一:多态性的概念在本实验的第一部分,我们首先对多态性的概念进行了深入的研究。
多态性是指同一个方法在不同的对象上表现出不同的行为。
例如,在一个动物类中,不同的子类(如狗、猫、鸟)都可以实现一个叫声的方法,但是每个子类的叫声是不同的。
这种灵活性使得我们可以编写更加通用和可扩展的代码。
实验二:多态性的应用在第二个实验中,我们通过一个图形绘制的例子来展示多态性的应用。
我们创建了一个抽象的图形类,并派生出不同的子类,如圆形、矩形和三角形。
每个子类都实现了一个绘制方法,但是绘制的方式和结果是不同的。
通过将这些不同的子类对象存储在一个通用的图形数组中,我们可以轻松地遍历并绘制每个图形,而无需关心具体的子类类型。
实验三:多态性的优势和局限性在第三个实验中,我们深入研究了多态性的优势和局限性。
多态性使得代码更加灵活和可扩展,可以减少代码的重复性。
然而,过度使用多态性可能会导致代码的复杂性增加,降低程序的性能。
因此,在设计和实现中需要权衡多态性的使用。
实验四:多态性在实际项目中的应用在最后一个实验中,我们通过一个实际的项目来展示多态性的应用。
我们选择了一个图书管理系统作为例子,其中包括了不同类型的图书,如小说、教材和杂志。
通过使用多态性,我们可以统一管理这些不同类型的图书,并实现一套通用的借阅和归还功能。
这样,无论新增了多少种类型的图书,我们都可以轻松地扩展和修改代码。
结论:通过本次实验,我们深入了解了多态性的概念和应用,并通过一系列的实验来验证和探究多态性在程序设计中的作用。
多态性的使用可以使代码更加灵活和可扩展,但也需要在设计和实现中进行合理的权衡。
在实际项目中,多态性可以帮助我们更好地管理和处理不同类型的对象,提高代码的可维护性和可扩展性。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
2.
#include<iostream>
using namespace std;
class Vehicle
{public:
virtual void Run()
{cout<<"车会跑\n";}
virtual void Stop()
{cout<<"车会停止\n";}
};
class motorcar:public Vehicle
{cout<<"自行车会停止\n";}
};
class motorcycle:public bicycle,public motorcar
{public:
void Run()
{cout<<"摩托车会跑\n";}
void Stop()
{cout<<"摩托车会停止\n";}
};
void main()
{Vehicle ve;
pclass->Stop();
}
调
试
过
程
及
实
验
结
果
总
结
通过这次试验,我更加理解了多肽是怎么回事了,更加懂得怎么样去写程序。
附
录
(源程序清单等)
bicycle bi;
motorcar mo;
motorcycle mocy;
Vehicle *pclass=&ve;
pclass->Run();
pclass->Stop();来自pclass=&bi;
pclass->Run();
pclass->Stop();
pclass=&mo;
pclass->Run();
2.定义一个车(vehicle)基类,有Run、Stop等成员函数,由此派生出自行车(bicycle)类、汽车(motorcar)类,从bicycle和motorcar派生出摩托车(motorcycle)类,它们都有Run、Stop等成员函数.观察虚函数的作用。
算
法
描
述
及
实
验
步
骤
1.
#include<iostream.h>
class Point
{
public:
Point(int x1,int y1):x(x1),y(y1){}
Point operator ++();
void display()
{
cout<<"之前的x为"<<x<<" "<<"之前的y为"<<y<<endl;
}
void display1()
{
cout<<"之后的x为"<<x<<" "<<"之后的y为"<<y<<endl;
{public:
void Run()
{cout<<"汽车会跑\n";}
virtual void Stop()
{cout<<"汽车会停止\n";}
};
class bicycle :public Vehicle
{public:virtual void Run()
{cout<<"自行车会跑\n";}
void Stop()
}
private:
int x;
int y;
};
Point Point::operator ++()
{
x=x+1;
y=y+1;
return *this;
}
void main()
{
Point Point1(10,2);
Point1.display();
Point1 ++;
Point1.display();
课程名称
C++
班级
实验日期
2012.11
姓名
学号
实验成绩
实验名称
实验五多态性
实
验
目
的
及
要
求
1.掌握运算符重载的方法;
2.在掌握继承与派生关系的基础上,进一步理解虚函数与多态性的关系,实现运行时的多态性;
3.学会定义和使用纯虚函数。
实
验
环
境
VC++ 6.0
实
验
内
容
1.定义Point类,有坐标x,y两个数据成员;对Point类重载“++”,“--”运算符,实现对坐标值的改变。