实验报告 继承、多态与接口
实验三 继承和多态
实验三继承和多态一、实验目的1.熟练掌握封装性，多态性的概念。
2.熟练掌握抽象类abstract的概念。
3.熟练掌握接口interface的概念。
4.熟练包package的概念以及编译运行的方法。
二、实验内容1.编写一个Java Application程序，该程序有个点Point类，它包含横坐标x和纵坐标y 两个属性，再给Point定义两个构造方法和一个打印点坐标的方法Show。
定义一个圆Circle 类，它继承Point类（它是一个点，圆心（Center）），除此之外，还有属性半径Radius，再给圆定义2个构造方法、一个打印圆的面积的方法PrintArea和一个打印圆中心、半径的方法Show（其中显示圆心可以用super.Show()的方式）。
package实验三;public class Point {double x,y;public Point(){x=0;y=0;}public Point(double x,double y){this.x=x;this.y=y;}public String Show(){return"横坐标为："+this.x+"，纵坐标为："+this.y;}/*** @param args*/public static void main(String[] args) {// TODO Auto-generated method stubPoint a=new Point(3.0,4.0);System.out.println(a.Show());}}package实验三;public class Circle extends Point {double Radius;public Circle(){super(0,0);Radius=0;}public Circle(double x,double y,double z){super(x,y);Radius=z;}public String Show(){System.out.println("圆心的"+super.Show()+"半径为："+Radius);return"圆心的"+super.Show()+"半径为："+Radius;}public String PrintArea(){System.out.println("圆的面积为："+Math.PI*Radius*Radius);return"圆的面积为："+Math.PI*Radius*Radius;}/*** @param args*/public static void main(String[] args) {// TODO Auto-generated method stubCircle a=new Circle(3,4,5);a.Show();a.PrintArea();}}2.编写一测试类，对其进行编译、运行。
继承与接口实验报告
继承与接口实验报告
实验目的：掌握Java中继承与接口的基本概念和使用方法，能够灵活运用继承和接口设计类和实现多态。
实验环境：Java语言编译器和JDK环境。
实验步骤：
1. 创建一个父类Animal，包含属性name和age，以及方法eat()和sleep()。
2. 创建两个子类Cat和Dog，继承自Animal类。
在子类中重写父类的方法，并添加特有的方法和属性。
3. 创建一个接口Jumpable，包含方法jump()。
4. 在Cat类中实现Jumpable接口，使其具有跳跃的能力。
5. 创建一个测试类Test，通过实例化Cat和Dog对象，调用它们的方法进行测试。
实验结果：
1. 父类Animal成功创建，子类Cat和Dog成功继承父类，并添加特有的方法和属性。
2. 接口Jumpable成功创建，并被Cat类实现。
3. 测试类Test成功实例化Cat和Dog对象，并调用它们的方法进行测试。
实验结论：
1. 继承是Java中实现代码重用的重要手段，通过继承可以快速创建具有相似特性的子类。
2. 接口是Java中实现多态的重要手段，通过接口可以使类具有更多的行为特性。
3. 在实际开发中，应根据需求灵活运用继承和接口，设计出合理的类结构和实现多态的方式。
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.什么是多态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方法，分别用于设置和获取教师的工资。
Java继承与多态实验报告
西安邮电大学（计算机学院）课内实验报告实验名称：继承与多态专业名称：计算机科学与技术班级：计科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】//定义成员变量departmentpublic static void main(String args[]){【代码3】//创建一个学生对象s【代码4】//用父类的setData方法初始化对象s【代码5】//对象s调用print方法【代码6】//创建一个大学生对象u【代码7】//调用父类的成员方法setData初始化对象u【代码8】//设置对象u的成员变量academy【代码9】//设置对象u的成员变量departmentSystem.out.print(+", "+u.number+", "+u.academy+", "+u.department);}}（3）编译并运行程序注意：公共类Student 与undergraduate 类要在同一文件夹（路径）内。
实验4 继承、多态、抽象类、接口
实验4 继承、多态、抽象类、接口注意：有些程序由于Word的关系，复制后，tab缩位可能会变成其它符号。
需要你去调整一下，删除缩位，重新Tab一、实验目的 (1)二、实验要求 (1)三、实验内容 (2)1. 类的继承与覆盖练习 (2)1.0 父类的哪些成员可以被继承？ (2)1.1 父类Student（学生）与子类HiStudent（大学生） (2)1.2 实例方法为什么需要覆盖 (4)1.3 验证成员方法的覆盖方式 (5)1.4 this、super和super()的使用 (6)1.5 变量、静态方法的隐藏。
(9)1.6 隐藏与覆盖的综合性实例 (10)2. 类的多态性练习 (11)2.1 普通方法的重载（实验3，本实验略） (11)2.2 构造方法的重载（实验3，本实验略） (11)2.3 运行时多态与动态绑定 (11)3. 抽象类 (13)4. 接口 (15)一、实验目的通过编程和上机实验理解Java语言的面向对象特性，了解类的继承性和多态性的作用，掌握它们的实现方法，了解数据域和静态方法的隐藏，了解抽象类和接口的作用。
二、实验要求1、编写体现类的继承性（成员变量、成员方法、成员变量隐藏）的程序；2、编写体现类的多态性的程序；3、编写体现抽象类和接口功能的程序。
三、实验内容1. 类的继承与覆盖练习例如，圆是一种形状。
圆类Circle是形状类Shape的子类。
父类也叫基类、超类，子类也叫次类、扩展类、派生类。
子类可从父类中产生，保留父类的成员变量和方法，并可根据需要对它们加以修改。
新类还可添加新的变量和方法。
这种现象就称为类的继承。
当建立一个父类时，不必写出全部成员变量和成员方法。
只要简单地声明这个类是从一个已定义的类继承下来的，就可以引用被继承类的全部成员。
Java 提供了一个庞大的类库让开发人员继承和使用。
设计这些类是出于公用的目的，因此，很少有某个类恰恰满足你的需要。
你必须设计自己的能处理实际问题的类，如果你设计的这个类仅仅实现了继承，和父类一样，那样没什么用。
02实验二--继承和接口报告模板 (1)
publicbooleanisFilled() {
returnfilled;
}
/** Set a new filled */
publicvoidsetFilled(booleanfilled) {
this.filled= filled;
publicString getColor() {
returncolor;
}
/** Set a new color */
publicvoidsetColor(String color) {
this.color= color;
}
/** Return filled. Since filled is boolean,
2．用Eclipse工具编辑、编译、执行Java程序。
3．程序编写尽量规范化。在程序中添加适当的注释；类的命名、Field的命名、方法的命名应符合命名规则。
4．每个类都包含无参和有参的构造器。子类的构造器调用父类的构造器
实验内容
实验内容：
1．编写类之间具有继承关系的程序。
2．编写有抽象类和一般类的程序。
重写toString()方法返回三角形的字符串描述，返回值如：Triangle：side1=1.0，side2=2.0，side3=2.1
实验要求：
提供Triangle类的UML设计
实现该类的Java代码实现Triangle.java，并编写一个测试程序TestTriangle.java，在测试程序中创建一个Triangle对象，其边长分别为1.0，1.5和1.0，颜色为yellow，filled为true，然后显示其面积、周长、颜色以及是否被填充。
继承与多态实验报告心得
继承与多态实验报告心得
在进行继承与多态的实验过程中，我深刻理解了这两个面向对象编程的重要概念，并且在实践中体会到了它们的实际应用。
首先，继承是面向对象编程的一个基本特性，它允许创建新的类从已有的类中继承属性和方法。
在实验中，我创建了一个基类，然后通过继承来创建了多个子类。
这样，我可以在基类中定义一些通用的属性和方法，然后在子类中进行扩展或覆盖，实现了代码的重用和灵活性的提高。
通过继承，我可以很方便地创建出一个对象的不同类型的实例，从而满足不同的需求。
其次，多态是继承的一个重要特性，它允许使用基类类型的引用来引用一个子类的对象。
在实验中，我通过多态实现了一个统一的接口，使得可以以一种统一的方式处理不同类型的对象。
这样，我可以将具有相同行为的对象进行统一管理，提高了代码的灵活性和可扩展性。
在实验中，我还学会了使用抽象类和接口来实现多态。
抽象类提供了一种定义通用行为的方式，而接口则定义了一组方法的规范。
通过使用抽象类和接口，我可以定义一些通用的方法和属性，然后在具体的子类中进行实现和具体化。
这种方式可以有效地提高代码的可读性和可维护性。
继承与多态的实验为我提供了一个很好的学习机会，让我更深入地理解了面向对象编程的原理和思想。
通过实际操作，我不仅加深了对这两个概念的理解，还提升了自己的编程能力。
我相信，在以后的学习和工作中，我会继续运用这些知识，开发出更加高效和灵活的程序。
继承接口与多态的实验
实验三面向对象程序一、实验目的：1．掌握类的定义、对象的声明和构造函数的使用与类的成员的访问控制2．掌握类的继承关系和派生方法，掌握多态的概念与使用，掌握包的概念与使用二、实验时间：三、实验地点：四、实验内容与步骤：1．运行下列程序，分析super关键字的使用，以及父类与子类之间的隐藏和重写关系class superClass{int x;superClass( ){x = 3;System.out.println("in superClass : x = "+x);}void doSomething( ){System.out.println("in superClass.doSomething( )");}}class subClass extends superClass{int x;subClass( ){super( ); //call constructor of superClassx = 5;System.out.println("in subClass : x = "+x);}void doSomething( ){super.doSomething( ); //call method of superClassSystem.out.println("in subClass.doSomething( )");//call x of superClassSystem.out.println("super.x = "+super.x+" sub.x = "+x);}}public class inheritance{public static void main( String args[ ] ){subClass subC = new subClass( );subC.doSomething( );}}Super() 为父类的缺省的构造方法，子类调用父类的构造方法，同时子类也重写了父类的doSomething( )方法，如果子类没有用super调用父类的构造方法，则父类的构造方法将被子类重写的方法隐藏。
java继承与多态实验报告总结 -回复
java继承与多态实验报告总结-回复
Java的继承和多态机制是其面向对象特性中非常重要的一部分，深入理解和熟练应用这两个机制对于Java程序设计是至关重要的。
在进行本次实验之前，我们首先需要清楚Java继承和多态机制的概念和基本用法，下面对实验内容和结果进行总结。
实验内容：
本次实验主要涉及Java的继承和多态机制，并通过实践的方式加深对这两个机制的理解。
具体来说，本次实验包含以下部分：
1.构建一个简单的继承结构
2.掌握多态的实现方式
3.探索Java的抽象类和接口
4.了解Java中的重载和重写
5.熟练掌握Java继承和多态在实际编程中的运用
实验结果：
通过本次实验，我对Java的继承和多态机制有了更深入的理解。
在实践过程中，我发现继承可以简化我们的代码实现，通过重写父类方法可以实现子类的特定需求。
而多态可以大大减轻代码的复杂度，提高代码的可扩展性和可复用性，使得程序的设计更加灵活。
在实验过程中，我还学习了Java的抽象类和接口，发现它们在Java程序设计中的应用非常广泛，可以通过它们实现对多态的更加深入的理解与应用，同时也可以提高代码的可维护性和代码的可读性。
总的来说，通过本次实验，我对Java的继承和多态机制有了更加深入的理解，也更加熟练地掌握了这两个机制在实践中的应用，有助于我后续Java程序设计的实践和工作。
接口的应用实验报告(3篇)
第1篇一、实验目的1. 理解接口的概念和作用。
2. 掌握接口的使用方法，包括接口的定义、实现和继承。
3. 通过实际应用，加深对接口的理解和应用能力。
二、实验环境1. 操作系统：Windows 102. 编程语言：Java3. 开发工具：Eclipse三、实验内容1. 接口的基本概念2. 接口的定义和实现3. 接口的继承和多态4. 接口的应用实例四、实验步骤1. 接口的基本概念（1）打开Eclipse，创建一个名为“InterfaceDemo”的Java项目。
（2）在项目中创建一个名为“Shape”的接口，包含一个抽象方法“draw()”。
```javapublic interface Shape {void draw();}```2. 接口的定义和实现（1）在项目中创建一个名为“Circle”的类，实现“Shape”接口。
```javapublic class Circle implements Shape {@Overridepublic void draw() {System.out.println("Drawing a circle.");}}```（2）在项目中创建一个名为“Rectangle”的类，实现“Shape”接口。
```javapublic class Rectangle implements Shape {@Overridepublic void draw() {System.out.println("Drawing a rectangle.");}}```3. 接口的继承和多态（1）在项目中创建一个名为“Triangle”的类，继承“Circle”类，并实现“Shape”接口。
```javapublic class Triangle extends Circle implements Shape {public void draw() {System.out.println("Drawing a triangle.");}}```（2）创建一个名为“Main”的类，用于测试接口的应用。
Java实验报告(四)继承和多态
int index=BinarySearch(shape1,shape3);
System.out.println("\n【二分法查找】：");
if(index==0){
System.out.println("【对象】"+shape3.toString()+"不存在【圆形】数组中。");
}
else{
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);
}
public double getRadius(){
return radius;
}
public void setRadius(double val){
this.radius=val;
}
public double getArea(){
return Math.PI*radius*radius;
}
public double getPerimeter(){
}
else{
return -1;
}
}
public int compareTo(Object o) {
if(this.getArea()>((Circle)o).getArea())
return 1;
else if(this.getArea()==((Circle)o).getArea())
继承与多态实验报告
继承与多态实验报告继承与多态实验报告在面向对象编程中，继承和多态是两个重要的概念。
通过继承，我们可以创建新的类，并从现有的类中继承属性和方法。
而多态则允许我们使用父类的引用来指向子类的对象，实现同一操作具有不同的行为。
本实验旨在通过实际的编程实践，加深对继承和多态的理解。
实验一：继承在这个实验中，我们创建了一个动物类（Animal），并从它派生出了两个子类：狗类（Dog）和猫类（Cat）。
动物类具有一些共同的属性和方法，如名字（name）和发出声音（makeSound）。
子类继承了父类的属性和方法，并可以添加自己的特定属性和方法。
在编写代码时，我们首先定义了动物类，并在其中实现了共同的属性和方法。
然后，我们创建了狗类和猫类，并分别在这两个类中添加了自己的特定属性和方法。
通过继承，我们可以在子类中直接使用父类的方法，并且可以根据需要进行重写。
实验二：多态在这个实验中，我们使用多态的概念来实现一个动物园的场景。
我们定义了一个动物园类（Zoo），并在其中创建了一个动物数组。
这个数组可以存储不同类型的动物对象，包括狗、猫等。
通过多态，我们可以使用动物类的引用来指向不同类型的动物对象。
例如，我们可以使用动物类的引用来指向狗对象，并调用狗类特有的方法。
这样，我们可以统一处理不同类型的动物对象，而不需要为每种类型编写特定的处理代码。
实验三：继承与多态的结合应用在这个实验中，我们进一步探索了继承和多态的结合应用。
我们定义了一个图形类（Shape），并从它派生出了三个子类：圆形类（Circle）、矩形类（Rectangle）和三角形类（Triangle）。
每个子类都实现了自己的特定属性和方法。
通过继承和多态，我们可以在图形类中定义一些通用的方法，如计算面积和周长。
然后，我们可以使用图形类的引用来指向不同类型的图形对象，并调用相应的方法。
这样，我们可以轻松地对不同类型的图形进行统一的处理。
结论：通过本次实验，我们进一步理解了继承和多态的概念，并学会了如何在编程中应用它们。
实验9继承与多态(抽象类和接口)
实验9 继承与多态、实验目的(1) 理解类的继承，掌握变量隐藏、方法覆盖的概念。
(2 )理解引用类型的变量的赋值转换原则。
(3 )理解多态概念，掌握方法的匹配调用原则；(4 )理解抽象类的使用；(5 )理解this 和super 的含义及使用。
(6 )理解访问控制符的使用二、知识要点1、继承的概念通过类的继承，祖先类的所有成员均将成为子类拥有的“财富”。
但是能否通过子类对象直接访问这些成员则取决于访问权限设置。
Object 类是所有类的祖先。
2、构造方法与继承关系构造方法不存在继承关系，子类中是如何给父类继承的属性赋初值呢？子类通过调用父类的构造方法给父类的属性赋值，在子类的构造方法的第1 行可以通过super 去调用父类的构造方法，如果没有super 调用，则默认调用父类的无参构造方法。
所以，在父类中编写构造方法通常均要提供无参构造方法。
3、对象引用变量赋值原则可以将子类的对象引用赋值给父类引用变量，由于父类能操作访问属性和方法的子类已全部继承。
但将父类引用变量的值赋给子类引用变量就受到限制，必须进行强制转换，编译总是认可强制转换，但运行程序时如果不能正确转换就会报错。
4、多态的两种表现形式( 1) 同一类中的方法多态(方法重载)：同一类中允许多个同名方法，通过参数的数量、类型的差异进行区分。
( 2) 子类对父类方法的重新定义 (方法覆盖) ：方法名、返回值和参数形态完全一样。
( 3) 方法调用的匹配原则。
首先查找有否有参数一致的方法，也就是精确匹配；如果没有，再检查实参是否能自动转换为形参类型，能转换也可以匹配调用，这种匹配称为转换匹配。
5、继承关系中对成员的访问(最近匹配原则) 由于继承关系的存在，一个对象的属性和方法中有自己新定义的，也有从祖先类继承的。
允许子类对父类定义的属性和方法重新定义，一个对象查找其属性和方法时按什么原则查找呢，实际也是“最近匹配原则”。
（1）在子类中访问属性和方法时将优先查找自己定义的属性和方法。
实验报告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）将以上程序尝试改成通过调用基类构造方法的方式来初始化编号和姓名，并总结调用基类构造方法的应用要点。
java实验 2 (2) 继承、多态与接口
实验2 面向对象编程(继承、多态、接口)2.1实验目的通过编程和上机实验理解Java 语言是如何体现面向对象编程基本思想，了解类的封装方法，以及如何创建类和对象，了解成员变量和成员方法的特性，掌握OOP 方式进行程序设计的方法，了解类的继承性和多态性的作用。
2.2实验要求1．理解继承，类和子类，子类对象构造过程，方法重载和方法重写等概念。
2．掌握接口概念及作用，理解抽象类、多态。
3．深入理解在运行时环境中，通过向上转型，JVM采用的邦定原则。
4．能够读懂程序2.3实验内容2.3.1用户自定义类import java.util.*;public class EmployeeTest{public static void main(String[] args){// fill the staff array with three Employee objectsEmployee[] staff = new Employee[3];staff[0] = new Employee("Carl Cracker", 75000, 1987, 12, 15);staff[1] = new Employee("Harry Hacker", 50000, 1989, 10, 1);staff[2] = new Employee("Tony Tester", 40000, 1990, 3, 15);// raise everyone's salary by 5%for (int i=0;i<staff.length;i++){staff[i].raiseSalary(5);}// print out information about all Employee objectsfor (int i=0;i<staff.length;i++){System.out.println("name=" + staff[i].getName()+ ",salary=" + staff[i].getSalary()+ ",hireDay=" + staff[i].getHireDay());}}}class Employee{public Employee(String n, double s, int year, int month, int day){name = n;salary = s;GregorianCalendar calendar = new GregorianCalendar(year, month - 1, day);// GregorianCalendar uses 0 for JanuaryhireDay = calendar.getTime();}public String getName(){return name;}public double getSalary(){return salary;}public Date getHireDay(){return hireDay;}public void raiseSalary(double byPercent){double raise = salary * byPercent / 100;salary += raise;}private String name;private double salary;private Date hireDay;}2.3.2类的继承性class Employee {String name ;int salary;public Employee(String name,int salary){ = name;this.salary = salary;}public String getDetails( ){return "Name: "+name+"\nSalary: "+salary;}}class Manager extends Employee {private String department ;public Manager(String name,int salary,String department){ super(name,salary);this.department = department;}public String getDetails( ){return "Name: "+name+"\nSalary: "+salary+"\nDepartment: "+ department;}}class Secretary extends Employee{public Secretary(String name,int salary){super(name,salary);}}public class TestOverriding{public static void main(String[] srgs){Manager m = new Manager("Tom",2000,"Finance");Secretary s = new Secretary("Mary",1500);System.out.println(m.getDetails());System.out.println(s.getDetails());}}2.3.3类的多态性import java.util.*;//定义Shape类class Shape {void draw() {}void erase() {}}//定义Circle类class Circle extends Shape {void draw() {System.out.println("Calling Circle.draw()"); }void erase() {System.out.println("Calling Circle.erase()"); }}//定义Square类class Square extends Shape {void draw() {System.out.println("Calling Square.draw()"); }void erase() {System.out.println("Calling Square.erase()"); }}//定义Triangle类class Triangle extends Shape {void draw() {System.out.println("Calling Triangle.draw()"); }void erase() {System.out.println("Calling Triangle.erase()"); }}//包含main()的测试类public class Shapes{static void drawOneShape(Shape s){s.draw();}static void drawShapes(Shape[] ss){for(int i = 0; i < ss.length; i++){ss[i].draw();}}public static void main(String[] args) {Random rand = new Random(); //阅读JDK API 文档Shape[] s = new Shape[9];for(int i = 0; i < s.length; i++){switch(rand.nextInt(3)) { //rand.nextInt(3)随机生成0、1、2三个整数case 0: s[i] = new Circle();break;case 1: s[i] = new Square();break;case 2: s[i] = new Triangle();break;}}drawShapes(s);}}//思考题：将Shape改成接口类型，再试2.3.4 属性隐藏与方法重写//这是一个向上转型，实现多态的例子//阅读程序，理解JVM的绑定规则class Base{String var="BaseVar"; //实例变量static String staticVar="StaticBaseVar"; //静态变量void method(){ //实例方法System.out.println("Base method");}static void staticMethod(){ //静态方法System.out.println("Static Base method");}}public class Sub extends Base{String var="SubVar"; //实例变量static String staticVar="StaticSubVar"; //静态变量void method(){ //覆盖父类的method()方法System.out.println("Sub method");}static void staticMethod(){ //隐藏父类的staticMethod()方法System.out.println("Static Sub method");}String subVar="Var only belonging to Sub";void subMethod(){System.out.println("Method only belonging to Sub");}public static void main(String args[]){Base who=new Sub(); //who被声明为Base类型，引用Sub实例System.out.println("who.var="+who.var); //打印Base类的var变量System.out.println("who.staticVar="+who.staticVar); //打印Base类的staticVar变量who.method(); //打印Sub实例的method()方法whpillar;pillar;pillar;pillar;pillar;。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
实验三继承、多态与接口一、实验目的1.掌握Ja v a的继承机制；2.掌握对象引用的多态方法；3.掌握接口的特点、结构和调用；4.掌握接口和继承的混合使用。
二、实验要求1.编写体现类的继承性（成员变量、成员方法、成员变量隐藏）的程序。
2.编写体现类的多态性（成员方法重载、构造方法重载）的程序。
3.编程使用系统接口的技术和创建自定义接口的方法。
三、实验内容（一）类的继承性练习1．理解继承的含义新类可从现有的类中产生，并保留现有类的成员变量和方法并可根据需要对它们加以修改。
新类还可添加新的变量和方法。
这种现象就称为类的继承。
当建立一个新类时，不必写出全部成员变量和成员方法。
只要简单地声明这个类是从一个已定义的类继承下来的，就可以引用被继承类的全部成员。
被继承的类称为父类或超类（su pe rc la ss），这个新类称为子类。
J a va 提供了一个庞大的类库让开发人员继承和使用。
设计这些类是出于公用的目的，因此，很少有某个类恰恰满足你的需要。
你必须设计自己的能处理实际问题的类，如果你设计的这个类仅仅实现了继承，则和父类毫无两样。
所以，通常要对子类进行扩展，即添加新的属性和方法。
这使得子类要比父类大，但更具特殊性，代表着一组更具体的对象。
继承的意义就在于此。
2．创建公共类S Y3_1_P编写程序文件S Y3_1_P.ja va，源代码如下：pu bl ic c la ss SY3_1_P{pr ote c te d St ri ng x m;//具有保护修饰符的成员变量pr ote c te d in t xh;vo id s et da ta(S tr in g m,in t h) { //设置数据的方法xm =m;xh = h;}pu bl i c vo id p ri nt(){//输出数据的方法Sy st em.o ut.pr i nt ln(x m+", "+xh);}}●编译S Y3_1_P.j av a，产生类文件SY3_1_P.cl as s。
3．创建继承的类●程序功能：通过SY3_1_P类产生子类SY3_2，其不仅具有父类的成员变量x m（姓名）、xh（学号），还定义了新成员变量xy（学院）、x i（系）。
在程序中调用了父类的pr in t 方法，同时可以看出子类也具有该方法。
●编写S Y3_2.j av a 程序，源代码如下：c l as s SY3_2ex tend s SY3_1_P{pr ot ect e d St ri ng x y;pr ot ect e d St ri ng x i;pu bl ic s ta ti c vo id m ain(St ri ng a rg s[]) {SY3_1_P p1 = ne w S Y3_1_P();p1.se td at a("帅零",12321) ;p1.pr in t();SY3_2s1 = ne w SY3_2() ;s1.se td at a("郭丽娜",12345); //调用父类的成员方法s1.xy="经济管理学院"; //访问本类的成员变量s1.xi="信息管理系"; //访问本类的成员变量s1.pr in t();S y st em.o ut.p ri nt(s1.xm+", "+s1.xy+","+s1.x i);}}●编译并运行程序注意：公共类S Y3_1_P与SY3_2类要在同一文件夹（路径）内。
（二）类的多态性练习1．理解类的多态性类的继承发生在多个类之间，而类的多态只发生在同一个类上。
在一个类中，可以定义多个同名的方法，只要确定它们的参数个数和类型不同。
这种现象称为类的多态。
多态使程序简洁，为程序员带来很大便利。
在OO P 中，当程序要实现多个相近的功能时，就给相应的方法起一个共同的名字，用不同的参数代表不同的功能。
这样，在使用方法时不论传递什么参数，只要能被程序识别就可以得到确定的结果。
类的多态性体现在方法的重载（ov erl o ad）上，包括成员方法和构造方法的重载。
2．方法的重载方法的重载是指对同名方法的不同使用方式。
●程序功能：对不同的数进行排序输出。
在I nt So rt类中定义3个同名的方法so rt，●编写SY3_3.j a va 文件，源代码如下：i m po rt j av a.aw t.G r ap hi cs;i m po rt j av a.ap ple t.A pp le t;c l as s In tS or t {p u bl ic S tr in g sor t(i nt a, in t b) {i f (a>b)r e tu rn a+" "+b;e l ser e tu rn b+" "+a;}p u bl ic S tr in g sor t(i nt a, i n t b, i nt c) {i n t sw ap;i f (a<b) {s w ap=a;a=b;b=sw ap;}i f (a<c) {s w ap=a;a=c;c=sw ap;}i f (b<c) {s w ap=b;b=c;c=sw ap;}r e tu rn a+" "+b+" "+c;}p u bl ic S tr in g sor t(i nt a rr[]) {S t ri ng s=" ";i n t sw ap;f o r (i nt i=0; i<a r r.le ng th; i++)f o r (i nt j=0; j<a r r.le ng th-1; j++)i f (ar r[j]>a rr[j+1]) {s w ap=a rr[j];a r r[j]=a rr[j+1];a r r[j+1]=s wa p;}f o r (i nt i=0; i<a r r.le ng th; i++)s=s+ar r[i]+" ";r e tu rn s;}}p u bl ic c la ss S Y3_3e xt en ds A pp let{I n tS or t s=ne w Int S or t();p u bl ic v oi d pa int(Gr ap hi cs g) {i n t a=30, b=12, c=40;i n t ar r[]={34,8,12,67,44,98,52,23,16,16};g.dr aw St ri ng("两个数的排序结果："+s.so rt(a,b),30,30);g.dr aw St ri ng("三个数的排序结果："+s.so rt(a,b,c),30,60);g.dr aw St ri ng("数组的排序结果："+s.so rt(a rr),30,90);}}●编译并运行程序●三个同名方法p u bl ic S tr in g sor t (in t a, i nt b)p u bl ic S tr in g sor t (in t a, i nt b,in t c)p u bl ic S tr in g sor t (in t ar r[])●编写SY3_3类文件的页面文件SY3_3.ht ml<h tm l><a pp le t co de ba se=e:/ja va/程序c od e=S Y3_3.c la ssw i dt h=420 he ig ht=380></ap pl et ></ht ml>3．构造方法的重载构造方法的名称和类同名，没有返回类型。
尽管构造方法看起来和一般的成员方法没有差别，但它不是方法，也不是类的成员。
因此，构造方法不能直接调用，只能由ne w 操作符调用。
构造方法对于类是十分重要的，对象的初始化任务要靠构造方法来完成。
重载构造方法的目的是提供多种初始化对象的能力，使程序员可以根据实际需要选用合适的构造方法来初始化对象。
●编写构造方法Ru nD em o 的重载程序文件SY3_4，源代码如下：c l as s Ru nD em o {p r iv at e St ri ng us e rN am e, p as sw ord;R u nD em o() {S y st em.o ut.p ri ntl n("全部为空!");}R u nD em o(St ri ng na m e) {u s er Na me=n am e;}R u nD em o(St ri ng na m e, S tr in g pw d) {t h is(n am e);p a ss wo rd=p wd;c h ec k();}v o id c he ck() {S t ri ng s=n ul l;i f (us er Na me!=nul l)s="用户名："+u ser N am e;e l ses="用户名不能为空！";i f (pa ss wo rd!="12345678")s=s+" 口令无效！";e l ses=s+" 口令：********";S y st em.o ut.p ri ntl n(s);}}p u bl ic c la ss S Y3_4 {p u bl ic s ta ti c voi d m ai n(St ri ng[] a rg s) {n e w Ru nD em o();n e w Ru nD em o("刘新宇");n e w Ru nD em o(nu ll,"邵丽萍");n e w Ru nD em o("张驰","12345678");}}●编译并运行程序。
●三个构造方法，其中第一个无参构造方法Ru nD em o()的实际作用是对成员变量赋缺省初值，由于us er Na m e和p a ss wo rd都是S tri n g 类，所以它们的缺省初值为nu ll。
第二个构造方法Ru n De mo(S tr in g) 只有一个参数，用来对成员变量us er Na me赋初值。
第三个构造方法R u nD em o(St ri ng, S t ri ng) 有两个参数，并有更多的内容，首先调用th is(n am e)，其实际作用就是调用当前类的构造方法Ru nD em o(St ri n g na me)；然后对成员变量pa ss wo r d赋值；最后调用ch e ck 方法来检查u s er Na me 和p a ss wo rd，类似于一般程序的口令验证。