福建农林大学计算机与信息学院实验报告
实验（四）继承和多态
一、实验目的和要求
1.掌握面向对象的继承关系
2.理解面向对象的多态
3.掌握方法的重写
4.掌握接口的实现
二、实验内容和原理
设计一个抽象类Shape，包括2个抽象方法，分别是计算形状的周长和面积。设计具体类Rectangle和Circle，分别表示矩形和圆，它们都是Shapes的子类。使Rectangle和Circle都实现Comparable接口（根据面积比较大小），编写一个通用的排序程序和一个通用的二分查找程序（自己写代码实现），能对这二种类型的数组进行排序并查找指定的对象。
三、实验环境
1.硬件环境：
2.软件环境：JDK1.5
四、算法描述及实验步骤
1.算法描述（可以用类图、流程图、伪代码或源程序描述）
…
对实现了Comparable接口的对象数组data进行排序
public static void sort(Comparable[] data)
在实现了Comparable接口的对象数组data中查找元素element
public int binarySearch(Comparable[] data, Comparable element)
2.实验步骤
●创建一个UML项目，并设计类Shape、Rectangle和Circle，并建立
描述Shape、Rectangle、Circle和Comparable间关系的类图
●创建一个Java应用项目
●把UML项目中的类自动生成代码到Java应用项目中
●实现类中的方法及通用的排序和检索程序
●进行编译
●进行测试，使用的测试用例：
输入：预期输出：
…
五、调试过程
1.编译过程
改为：
2.调试过程
记录算法实现中发现的逻辑错误及改正，对每个测试用例，记录实际输出，并与预期输出进行比较，如果不同，分析产生错误的原因并改正。
输入：
预期输出：
【排序面积从小到大】：
【圆形数组】【长度】5【位置】0【圆形】【半径】：2.0【面积】12.57【周长】：12.57
【位置】1【圆形】【半径】：3.0【面积】28.27【周长】：18.85
【位置】2【圆形】【半径】：4.0【面积】50.27【周长】：25.13
【位置】3【圆形】【半径】：5.0【面积】78.54【周长】：31.42
【位置】4【圆形】【半径】：6.0【面积】113.10【周长】：37.70
【矩形数组】【长度】5
【位置】0【矩形】【长】：1.0【宽】:2.0【面积】:2.00【周长】：4.00
【位置】1【矩形】【长】：2.0【宽】:3.0【面积】:6.00【周长】：12.00
【位置】2【矩形】【长】：3.0【宽】:4.0【面积】:12.00【周长】：24.00
【位置】3【矩形】【长】：4.0【宽】:5.0【面积】:20.00【周长】：40.00
【位置】4【矩形】【长】：5.0【宽】:6.0【面积】:30.00【周长】：60.00
【二分法查找】：
【对象】【圆形】【半径】：6.0【面积】113.10【周长】：37.70位于【圆形】数组的第【4】位。
【对象】【矩形】【长】：10.0【宽】:10.0【面积】:100.00【周长】：200.00不存在【矩形】数组中。
实际输出：
分析：
实验的输出结果和预期输出的结果相同，程序无错误。
六、实验结果
用与测试用例不同的输入数据运行算法，写出得到的结果，并分析结果是否正确。
输入：
输出结果：
结果分析：
程序换个用例测试所得的结果与题目要求的完全一致，程序无错误。
七、总结
通过这次上机使我对JA V A的继承类和接口有了更进一步的认识，使我对运用JA V A有了更深的体会。
附录：
测试Main类：
package javaapplication1;
/**
*
* @author Administrator
*/
import java.text.*;
public class Main {
public static void main(String[] args){
/*Shape[] shape1={new Circle(2.0),new Circle(3.0),new Circle(4.0),
new Circle(5.0),new Circle(6.0)};
Shape[] shape2={new Rectangle(1.0,2.0),new Rectangle(2.0,3.0),new Rectangle(3.0,4.0),
new Rectangle(4.0,5.0),new Rectangle(5.0,6.0)};
Shape shape3=new Circle(6.0);
Shape shape4=new Rectangle(10.0,10.0);*/
Shape[] shape1={new Circle(1.1),new Circle(1.2),new Circle(1.3),
new Circle(1.4),new Circle(1.5)};
Shape[] shape2={new Rectangle(1.0,4.0),new Rectangle(7.0,3.0),new Rectangle(3.0,5.0),
new Rectangle(9.0,5.0),new Rectangle(5.0,4.0)};
Shape shape3=new Circle(2.0);
Shape shape4=new Rectangle(9.5,5.0);
System.out.print("【排序面积从小到大】：\n");
sort(shape1);
sort(shape2);
System.out.print("【圆形数组】【长度】"+shape1.length);
for(int i=0;i System.out.println("【位置】"+i+shape1[i].toString()); } System.out.println("【矩形数组】【长度】"+shape2.length); for(int i=0;i System.out.println("【位置】"+i+shape2[i].toString()); } int index=BinarySearch(shape1,shape3); System.out.println("\n【二分法查找】："); if(index==0){ System.out.println("【对象】"+shape3.toString()+"不存在【圆形】数组中。"); } else{ System.out.println("【对象】"+shape3.toString()+ "位于【圆形】数组的第【"+index+"】位。"); } index=BinarySearch(shape2,shape4); if(index==0){ System.out.println("【对象】"+shape4.toString()+ "不存在【矩形】数组中。"); } else{ System.out.println("【对象】"+shape4.toString()+ "位于【矩形】数组的第【"+index+"】位。"); } } public static void sort(Comparable[] list) { Comparable com; int n = list.length; for (int i = 0; i < n- 1; i++) { int m = i; for (int j = i + 1; j < list.length; j++) { if (list[j].compareTo(list[m]) == -1) { m = j; } } if (m != i) { com = list[i]; list[i] = list[m]; list[m] = com; } } } public static int BinarySearch(Comparable[] list,Comparable com){ int low =0; int high = list.length-1; int mid =0; while(low<=high){ mid=(low+high)/2; if(list[mid].compareTo(com)==0){ return mid; } else if(list[mid].compareTo(com)==1){ high=mid-1; } else{ low=mid+1; } } return 0; } } Shape类： package javaapplication1; /** * * @author Administrator */ import java.text.*; public abstract class Shape implements Comparable{ public Shape(){ } public abstract double getPerimeter(); public abstract double getArea(); public abstract String toString(); } Cricle类： package javaapplication1; /** * * @author Administrator */ import java.text.*; public class Circle extends Shape{ private double radius; public Circle(){ radius = 0.0; } public Circle(double radius){ this.radius=radius; } public double getRadius(){ return radius; } public void setRadius(double val){ this.radius=val; } public double getArea(){ return Math.PI*radius*radius; } public double getPerimeter(){ return 2.0*Math.PI*radius; } public String toString(){ String str; DecimalFormat d1=new DecimalFormat("0.00"); str="【圆形】【半径】："+radius+"【面积】"+ d1.format(getArea())+"【周长】："+d1.format(getPerimeter()); return str; } public int comparaTo(Object o){ if(this.getArea()>((Circle)o).getArea()){ return 1; } else if(this.getArea()==((Circle)o).getArea()){ return 0; } else{ return -1; } } public int compareTo(Object o) { if(this.getArea()>((Circle)o).getArea()) return 1; else if(this.getArea()==((Circle)o).getArea()) return 0; else return -1; } } Rectangle类： package javaapplication1; /** * * @author Administrator */ import java.text.*; public class Rectangle extends Shape{ private double length; private double width; public Rectangle(){ width=0.0; length=0.0; } Rectangle(double length, double width) { this.length=length; this.width=width; //throw new UnsupportedOperationException("Not yet implemented"); } public double getLength(){ return length; } public void setLength(double val){ this.length=val; } public double getWidth(){ return width; } public void setWidth(double val){ this.width=val; } public double getArea(){ return length*width; } public double getPerimeter(){ return 2.0*length*width; } public String toString(){ String str; DecimalFormat d1=new DecimalFormat("0.00"); str="【矩形】【长度】："+length+"【宽】:"+width+"【面积】:"+ d1.format(getArea())+"【周长】："+d1.format(getPerimeter()); return str; } public int comparaTo(Object obj){ if(this.getArea()>((Circle)obj).getArea()){ return 1; } else if(this.getArea()==((Circle)obj).getArea()){ return 0; } else{ return -1; } } public int compareTo(Object o) { if(this.getArea()>((Rectangle)o).getArea()) return 1; else if(this.getArea()==((Rectangle)o).getArea()) return 0; else return -1; } } 福建农林大学实验报告 实验6 多态性（一） 一、实验目的和要求 （1）掌握虚函数的定义与使用方法，进一步理解多态性的概念和分类。 （2）了解纯虚函数和抽象类的使用方法。 二、实验内容和原理 1、分析并调试下列程序，回答以下问题：（1）指出抽象类（2）指出虚函数，并说明它的作用（3）每个类的作用是什么？整个程序的作用是什么？ 2、使用虚函数编写程序求球体、圆柱体和圆锥的体积，由于球体、圆柱体和圆锥都可以看做由圆继 承而来，所以可以定义圆类作为基类。在圆类中定义数据成员半径和一个求体积的虚函数。由圆类 派生出球体类、圆柱体类和圆锥类，在派生类中对圆类中的虚函数重新定义。编写一个外部函数求 各类形状的总体积。最后在main（）函数中构造若干形状，并求它们的体积和。 三、实验环境 1. 硬件：PC机； 2. 软件：Windows操作系统、Visual C++ 6.0 四、算法描述及实验步骤 1、算法描述及步骤如下： （1）根据题目要求编写好程序代码并在VC环境下输入源程序。 （2）检查程序有无错误(包括语法错误和逻辑错误)，有则改之。 （3）编译和连接，仔细分析编译信息，如有错误应找出原因并改正之。本题改正后的代码如下： #include 实验项目名称：继承和多态 （所属课程：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(){ 实验四类的继承与多态 一、实验目的 1.掌握构造方法和成员方法重载的应用。 2.理解类的继承性的作用 3.领会面向对象编程的多态性。 二、实验内容与要求 基本概念 1．进一步理解继承的含义 新类可从现有的类中产生，并保留现有类的成员变量和方法并可根据需要对它们加以修改。新类还可添加新的变量和方法。这种现象就称为类的继承。 当建立一个新类时，不必写出全部成员变量和成员方法。只要简单地声明这个类是从一个已定义的类继承下来的，就可以引用被继承类的全部成员。被继承的类称为父类或超类（superclass），这个新类称为子类。 Java 提供了一个庞大的类库让开发人员继承和使用。设计这些类是出于公用的目的，因此，很少 有某个类恰恰满足你的需要。你必须设计自己的能处理实际问题的类，如果你设计的这个类仅仅实现了继承，则和父类毫无两样。所以，通常要对子类进行扩展，即添加新的属性和方法。这使得子类要比父类大，但更具特殊性，代表着一组更具体的对象。继承的意义就在于此。 2．了解成员变量的隐藏方式 所谓隐藏是指子类重新定义了父类中的同名变量，在子类L ine 中重新定义了x为x1，y 为y1，隐藏了父类Point 中的两个成员变量x 和y。子类执行自己的方法时，操作的是子类的变量，子类执行父类的方法时，操作的是父类的变量。在子类中要特别注意成员变量的命名，防止无意中隐藏了父类的关键成员变量，这有可能给程序带来麻烦。 3．了解成员方法的覆盖方式 （1）方法覆盖的定义与作用通过继承子类可以继承父类中所有可以被子类访问的成员方法，但如果子类的方法与父类方法同名，则不能继承，此时称子类的方法覆盖了父类的方法，简称为方法覆盖（override）。方法覆盖为子类提供了修改父类成员方法的能力。 4．理解类的多态性类的继承发生在多个类之间，而类的多态只发生在同一个类上。在一个类中，可以定义多个同名的方法，只要确定它们的参数个数和类型不同。这种现象称为类的多态。多态使程序简洁，为程序员带来很大便利。在O OP 中，当程序要实现多个相近的功能时，就给相应的方法起一个共同的名字，用不同的参数代表不同的功能。这样，在使用方法时不论传递什么参数，只要能被程序识别就可以得到确定的结果。 类的多态性体现在方法的重载（overload）上，包括成员方法和构造方法的重载。 实践应用 继承与多态习题 一.基本概念与基础知识自测题 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 关键字只对紧随其后的基类名起作用。 湖北工业大学工程技术学院实验报告 课程名称：面向对象程序设计实验内容：实验六继承性与多态性 学院：工程技术学院专业班级： 姓名：学号：指导教师： 实验日期：实验地点： 一、实验目的 1、1、了解多态性的概念。 2、2、了解虚函数的作用及使用方法。 3、3、了解纯虚函数和抽象类的概念和用法。 二、实验步骤 1.设计一个类层次，其中的基类为Date，它拥有一个相关数据成员及一个虚函 数print，从Date类派生ShortE、MediumDate和LongDate类，Date的print 函数使用日期格式：11-26-2015， ShortE的print函数使用日期格式：26-11-2015 MediumDate的print函数使用日期格式：Nov.26,2015 LongDate的print函数使用日期格式：November 26, 2015 编写一个程序来测试各个类的print函数。 #include day=d; } virtual void print() { cout< 西安邮电大学 （计算机学院） 课内实验报告 实验名称：继承与多态 专业名称：计算机科学与技术 班级：计科1405班 学生姓名：高宏伟 学号：04141152 指导教师：刘霞林 实验日期：2016.10.13 一、实验目的 通过编程和上机实验理解Java 语言的继承和多态特性，掌握变量的隐藏、方法的覆盖、重载，掌握抽象类和接口的使用。 二、实验要求 1.编写体现类的继承性（成员变量、成员方法、成员变量隐藏）的程序。 2.编写体现类的多态性（成员方法重载）的程序。 3.编写体现类的多态性（构造方法重载）的程序。 4.编写使用接口的程序。 三、实验内容 （一）类的继承 1.创建公共类Student. （1）编写程序文件Student.java，源代码如下: public class Student { protected String name; //具有保护修饰符的成员变量 protected int number; void setData(String m,int h) //设置数据的方法 { name =m; number= h; } public void print() //输出数据的方法 { System.out.println(name+", "+number); } } （2）编译Student.java，产生类文件Student.class。 2．创建继承的类Undergraduate （1）程序功能：通过Student 类产生子类undergraduate，其不仅具有父类的成员变量name（）、number（学号），还定义了新成员变量academy（学院）、department （系）。在程序中调用父类的print 方法。 （2）编写Undergraduate 程序: class Undergraduate extends Student { 【代码1】//定义成员变量academy 【代码2】//定义成员变量department public static void main(String args[]) { 【代码3】//创建一个学生对象s 【代码4】//用父类的setData方法初始化对象s 【代码5】//对象s调用print方法 【代码6】//创建一个大学生对象u 【代码7】//调用父类的成员方法setData初始化对象u 【代码8】//设置对象u的成员变量academy 【代码9】//设置对象u的成员变量department System.out.print(https://www.doczj.com/doc/b94926777.html,+", "+u.number+", "+u.academy+", "+u.department); } } （3）编译并运行程序 注意：公共类Student 与undergraduate 类要在同一文件夹（路径）。 (二)方法的重载 （1）程序功能：对不同的数进行排序输出。在IntSort 类中定义3 个同名的方法sort。 （2）编写Sort.java 文件，源代码如下。 import java.awt.Graphics; import java.applet.Applet; class IntSort { public String sort(int a, int b) { if (a>b) return a+""+b; else return b+""+a; } public String sort(int a, int b, int c) { int swap; if (a 实验四多态性 一、实验目的 1、掌握运算符重载的基本方法。 2、掌握友元运算符函数和成员运算符函数的使用方法及两者之间的不同。 3、学习虚函数的定义与使用方法。 4、了解静态多态性和动态多态性。 5、学习使用虚函数和继承实现动态多态性。 二、试验内容 1、编写一个程序，要求： （1）生明一个类Complex（复数类），定义类Complex的两个对象c1和c2，对象c1通过构造函数直接指定复数的实部和虚部（类私有数据成员为double类型：real和imag）为2.5及3.7，对象c2通过构造函数直接指定复数的实部和虚部为4.2及6.5； （2）定义友元运算符重载函数，它以c1、c2对象为参数，调用该函数时能返回两个复数对象相加操作； （3）定义成员函数print，调用该函数时，以格式“real+imag i”输出当前对象的实部和虚部，例如：对象的实部和虚部分别是4.2和6.5，则调用print函数输出格式为：4.2+6.5 i； （4）编写主程序，计算出复数对象c1和c2相加结果，并将其结果输出。 #include complex::complex(double r,double i) { real=r; imag=i; } complex operator+(complex &a,complex &b) {complex temp; temp.imag=a.imag+b.imag; temp.real=a.real+b.real; return temp; } void complex::print() { cout< 实验报告类的重载继承和多态 篇一：实验三_类的重载继承和多态_() 篇二：实验三_类的重载继承和多态 篇三：C++实验报告(类和对象重载与继承多态和模板异常和流) C++实验报告 目录 C++实验报告 ................................................ ................................................... (4) 实验一：类和对象 ................................................ ................................................... . (4) 1．................................................ ................................................... . (4) 代码 ................................................ ................................................... .. (4) 运行结果 ................................................ ................................................... (5) 2.................................................. ................................................... (5) 思路： .............................................. ................................................... . (5) 代码 ................................................ ................................................... (5) 运行结果 ................................................ ................................................... 实验2 类的封装性和继承性设计实验 一、实验目的 理解面向对象封装性、继承性和多态性的基本概念，掌握声明类、封装类、继承类以及运行时多态性的实现方法。 二、实验内容 1.程序理解： 1)设计复数类 2)在构造方法中使用this 3)Static 关键字的使用: 2.编程题： (1) 请按照以下要求设计一个Student类,并进行测试。 要求如下： 1）Student类中包含姓名、成绩两个属性。 2）分别给这两个属性定义两个方法，一个方法用于设置值，另一个方 法用于获取值。 3）Student类中定义一个无参的构造方法和一个接受两个参数的构造 方法，两个参数分别为姓名和成绩属性赋值。 4）在测试类中创建两个Student对象，一个使用无参构造方法，然 后调用方法给姓名和成绩赋值，另一个使用有参的构造方法，在构造 方法中给姓名和成绩赋值。 （提示：注意成员变量和成员方法的访问权限设置，使用this解决成 员变量与局部变量名称冲突的问题） （2） 1) 设计一个类，设计它的一个无参数构造方法，构造方法中打印一条消息。main方法创建这个类的一个对象，观察打印结果。 2) 在练习1)的基础上增加一个重载的构造方法，采用一个String 参数，并在构造方法中把这个String消息打印出来。创建这个类的 对象，观察打印结果。 3) 以练习2）创建的类为基础上，创建属于它的实例对象的一个数组， 但不要实际创建对象并分配到数组里。运行程序时，注意是否打印出 来自构建方法调用的初始化消息？为数组中每个变量创建对象，观察 打印结果？ (3) 请按照以下要求设计一个Outer类。 要求如下： 1)定义一个外部类Outer，并在该类中定义一个静态内部类Inner。 福建农林大学计算机与信息学院实验报告 实验（四）继承和多态 一、实验目的和要求 1.掌握面向对象的继承关系 2.理解面向对象的多态 3.掌握方法的重写 4.掌握接口的实现 二、实验内容和原理 设计一个抽象类Shape，包括2个抽象方法，分别是计算形状的周长和面积。设计具体类Rectangle和Circle，分别表示矩形和圆，它们都是Shapes的子类。使Rectangle和Circle都实现Comparable接口（根据面积比较大小），编写一个通用的排序程序和一个通用的二分查找程序（自己写代码实现），能对这二种类型的数组进行排序并查找指定的对象。 三、实验环境 1.硬件环境： 2.软件环境：JDK1.5 四、算法描述及实验步骤 1.算法描述（可以用类图、流程图、伪代码或源程序描述） package test; import javax.swing.JOptionPane; import java.util.Scanner; public class Test { public static void main(String[] args) { System.out.println("要创建几个圆？："); Scanner a1 = new Scanner(System.in); int a = a1.nextInt(); System.out.println("总共创建了" + a + "个圆\n请输入各个圆的半径："); Shape[] circle = new Shape[a]; Scanner input2 = new Scanner(System.in); for (int i = 0; i < a; i++) { circle[i] = new Circle(input2.nextDouble()); } System.out.println("要创建几个矩形？："); Scanner b2 = new Scanner(System.in); int b = b2.nextInt(); Shape[] rectangle = new Shape[b]; System.out.println("总共创建了" + b + "个矩形\n请依次输入各个矩形的长和宽："); Scanner c3 = new Scanner(System.in); for (int i = 0; i < b; i++) { rectangle[i] = new Rectangle(c3.nextDouble(), c3.nextDouble()); } Shape.sort(circle); String str1 = ""; for (int i = 0; i < circle.length; i++) { str1 += String.valueOf(i + 1) + circle[i] + "\n"; } System.out.println("您所创建的圆按半径由小到大排序如下：\n" + str1); Shape.sort(rectangle); String str2 = ""; for (int i = 0; i < rectangle.length; i++) { str2 += String.valueOf(i + 1) + rectangle[i] + "\n"; } System.out.println("您所创建的矩形按面积由小到大排序如下：\n" + str2); C++的封装性、继承性和多态性概念 封装的目的是增强安全性和简化编程，使用者不必了解具体的实现细节，而只是要通过外部接口，一特定的访问权限来使用类的成员。例如，在抽象的基础上，我们可以将时钟的数据和功能封装起来，构成一个时钟类。按c++的语法，时钟类的声明如下：class Clock { public: //共有成员，外部借口void SetTime(int NewH,int NewM,int NewS); void ShowTime(); private: //私有成员，外部无法访问int Hour,Minute,Second; } 可以看到通过封装使一部分成员充当类与外部的接口，而将其他的成员隐蔽起来，这样就达到了对成员访问权限的合理控制，使不同类之间的相互影响减少到最低限度，进而增强数据的安全性和简化程序的编写工作。什么是多态（Polymorphisn）？按字面的意思就是“多种形状”。引用Charlie Calverts对多态的描述——多态性是允许你将父对象设置成为和一个或更多的他的子对象相等 的技术，赋值之后，>>>父对象就可以根据当前赋值给它的子对象的特性以不同的方式运作<<<（摘自“Delphi4 编程技术内幕”）。简单的说，就是一句话：允许将子类类型的指针赋值给父类类型的指针。多态性在Object Pascal和C++中都是通过虚函数（Virtual Function）实现的。好，接着是“虚函数”（或者是“虚方法”）。虚函数就是允许被其子类重新定 义的成员函数。而子类重新定义父类虚函数的做法，称为“覆盖”（override），或者称为“重写”。“继承”是面向对象软件技术当中的一个概念。如果一个类A继承自另一个类B，就把这个A称为"B的子类"，而把B称为"A的父类"。继承可以使得子类具有父类的各种属性和方法，而不需要再次编写相同的代码。在令子类继承父类的同时，可以重新定义某些属性，并重写某些方法，即覆盖父类的原有属性和方法，使其获得与父类不同的功能。 ... 继承是指一个对象直接使用另一对象的属性和方法。事实上，我们遇到的很多实体都有继承的含义。例如，若把汽车看成一个实体，它可以分成多个子实体，如：卡车、公共汽车等。这些子实体都具有汽车的特性，因此，汽车是它们的"父亲"，而这些子实体则是汽车的"孩子"。19. 多态的作用？主要是两个：1. 隐藏实现细节，使得代码能够模块化；扩展代码模块，实现代码重用； 2. 接口重用：为了类在继承和派生的时候，保证使用家族中任一类的实例的某一属性时的正确调用。 实验4 类的继承和多态机制 一、实验目的 1、掌握类的继承机制； 2、掌握子类对父类构造方法的调用； 3、掌握方法覆盖和方法重载的区别。 二、实验内容 1、定义点类Point、圆类Circle、圆柱体类Cylinder。实现继承关系。 2、定义交通工具类Vehicle，一个小车类Car。实现Car对Vehicle的继承。 三、实验步骤 1、定义点类Point、圆类Circle、圆柱体类Cylinder。实现继承关系。 设计一个表示二维平面上点的类Point，包括表示坐标位置的成员变量x和y，获取和设置x和y值的方法。 设计一个表示二维平面上圆的类Circle，它继承自类Point，还包括表示圆半径的成员变量r、获取和设置r值的方法、计算圆面积的方法。 设计一个表示圆柱体的类Cylinder,它继承自类Circle，还包括表示圆柱体高的成员h、获取和设置h的方法、计算圆柱体表面积的方法、计算圆柱体体积的方法。 建立若干个Cylinder对象，输出其轴心位置坐标、半径、高、表面积及其体积的值。 class Point{ int x; int y; ;public Point(int x,int y){ this.x =x; this.y=y; } public int getX(){ return x; } public int getY(){ return y; } } class Circle extends Point{ double r; final double PI=3.1416; public Circle(int x,int y,double m){ super(x,y); r=m; } public double getR(){ return r; } public double circlearea(){ return PI*r*r; 实验三继承和多态 一、实验目的 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方法，分别用于设置和获取教师的工资。 （2）定义一个研究生类Graduate，实现StudentInterface接口和TeacherInterface 接口，它定义的成员变量有name（姓名）、sex（性别）、age（年龄）、fee（每学期学费）、pay（月工资）。 （3）创建一个姓名为"zhangsan"的研究生，统计他的年收入和学费，如果收入减去学费不足2000元，则输出“provide a loan”（需要贷款）信息。 1.编辑、编译、运行和调试以下程序，说明程序功能；改变变量n的初值，观察运行结果变化；若“for(i=1;i 实验六多态性和虚函数 一、实验目的 1、了解多态性的概念。 2、了解虚函数的作用及其使用方法。 3、了解静态关联和动态关联的概念和用法。 4、了解纯虚函数和抽象类的概念和用法。 二、实验要求 1、分析程序运行结果，掌握虚函数的使用。 程序一： #include { Base bc,*p; SubClass sc; p=&bc; p->fn(); p=≻ p->fn(); } 2、实现一个类A，在A中有两个私有的整型变量a和b，定义构造函数对a和b进行初始化，并实现成员函数geta（）取得a的值和getb（）取b的值。实现类B从A继承，覆盖geta（），使其返回a的2倍。主函数中声明类B对象，调用类B中的geta（）并将结果输出。 3、声明抽象基类Shape，由它派生出3个派生类：Cirle（圆形）、Rectangle（矩形）、Triangle （三角形），用一个函数printArea分别输出以上三者的面积，3个图形的数据在定义对象是给定。 第四章 面向对象的概念和 Java 实现-2 回顾 ?类是具有相同属性和行为的一组对象的集合 , 对象是类的实例 ?封装是隐藏对象实现细节的过程，以便不让用户看到实现的细节 ?类可用Class 来定义，类的变量和方法可被该类的实例访问, 圆点符号用于访问对象的成员，构造函数在创建对象时初始化对象 ?包可用package 来申明，可用import 来导入包 目标 ?理解继承及其特点 ?运用JAVA程序实现继承 ?理解多态及其特点设计 ?运用JAVA程序实现多态 ?掌握访问修饰符和方法修饰符 继承 继承的特点 继承的优点 继承的JAVA实现 子类构造方法 2-1 子类构造方法 2-2 ?调用父类构造方法的语法为： super() 或 super(参数列表) ; ?super () 方法始终指向调用类的父类 调用父类构造方法 演示：示例 3 多态性 2-1 ?多态性是指?°多种形式?± ?它使用不同的实例而执行不同操作 ?多态包括方法重写和方法重载 多态性 2-2 方法重载 2-1 方法重载 2-2 演示：示例 4 方法重写 2-1 方法重写 2-2 访问修饰符 3-1 ?信息隐藏是 OOP 最重要的功能之一，也是使用访问修饰符的原因 ?信息隐藏的原因包括： ?对任何实现细节所作的更改不会影响使用该类的代码 ?防止用户意外删除数据 ?此类易于使用 访问修饰符 3-2访问修饰符 3-3 ?访问修饰符可访问性 方法修饰符 static 修饰符 3-1 ?static修饰符修饰的方法叫静态方法 ?目的 ?使该方法独立于类的实例，使用类去访问，而不是类实例，所以也叫类方法 static 修饰符 3-2 ?调用静态方法的语法为： classname.methodname( ); static 修饰符 3-3 演示：示例 6 final 修饰符 abstract 修饰符 3-1 ?由abstract修饰的方法叫抽象方法；由abstract修饰的类叫抽象类 ?抽象方法必须声明在抽象类中 ?抽象方法语法： abstract type method_name(parameter_list); ?声明抽象类语法： abstract class{…… } ?使用：父类中的某些抽象不包含任何逻辑，并需要在子类中重写，子类提供这种抽象方法的实现细节 abstract 修饰符 3-2 ?抽象类可以具有指向子类对象的对象引用 abstract 修饰符 3-3 演示：示例 7 接口 ?接口就是某个事物对外提供的一些功能的申明 ?可以利用接口实现多态，同时接口也弥补了Java单一继承的弱点 ?使用interface关键字定义接口 ?一般使用接口声明方法或常量，接口中的方法只能是声明，不能是具体的实现 创建接口的步骤 2-1 // 定义方法的接口 public interface myinterface { public void add(int x, int y); public void volume(int x,int y, int z); } // 定义程序使用的常量的接口 public interface myconstants { public static final double price = 1450.00; public static final int counter = 5; } 创建接口的步骤 2-2 接口使用示例 实验08：继承与多态 实验学时：6 实验类型：验证、设计 实验要求：必修 一、实验目的 1．理解继承的概念，了解面向对象设计中继承和多态的合理性； 2．掌握派生类的构造与析构； 3．掌握在对象中使用类层次和继承思想进行设计、实现和测试； 4．区别运行时的多态性的实现，理解重载与同名覆盖的差异； 5．理解虚函数与多态性； 6．实现运行时多态性的程序设计。 二、实验内容 1．Difine a class called PartFileledArrayWMax that is a derived class of the class PartFilledArray. The class PartFilledArrayWMax has one additional member variable named max_value that holds the maximum value stored in the array. Define a member accessor function named get_max that returns the maximum value stored in the array. Redefine the member function add_value and define two constructors, one of which has an int argument for the maximum number of entries in the array. Also define a copy constructor, an overloaded assignment operator, and a destructor. (A real class would have more member functions, but these will do for an exercise.) 2．某公司雇员（employee）包括经理（Manager）、技术人员（Technician）和销售员（Saleman）。开发部经理（developermanager）既是经理也是技术人员，销售部经理（salesmanager）既是经理也是销售员。 以employee类为虚基类，派生出manager、technician和saleman类，再进一步派生出developermanager和salesmanager类。 Employee类的属性包括姓名、职工号、工资级别、月薪（实发基本工资加业绩工资）；操作包括月薪计算函数pay()，该函数要求输入请假天数，扣除应扣工实验6 多态性(一)
JAVA继承和多态实验报告
实验04 类的继承与多态
继承与多态习题
实验六继承性与多态性
Java继承与多态实验报告
实验四 多态性
实验报告类的重载继承和多态
实验2 类的封装性和继承性设计实验
实验报告(四)继承和多态 (完整代码)
C 的封装性、继承性和多态性概念
实验4 类的继承和多态机制
实验三 继承和多态
实验六 多态性和虚函数
《java面向对象程序设计-继承和多态》教案
实验8_继承和多态
相关主题
文本预览