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()的方式）。
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实验报告继承、多态、接⼝和异常处理实验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．掌握Java中类的继承定义、构造方法链的调用2．理解多态的原理，动态绑定的过程3．掌握super的使用方法4．区别函数覆盖和函数重载【实验原理】或【实验任务】1.完成教材P269页9.11）绘制UML图2）给出代码框架3）充实代码2.完成教材P269页9.31）绘制UML图2）给出代码框架3）充实代码【实验软件环境】（含实验所用软件及版本）Java Jdk 7.0Myeclipse【上机步骤】（含基本步骤，主要程序结果及异常情况记录等）第一题：三角形类T riangle用myeclipse编辑源代码并显示，如下：package jicheng;public class lianxi1 extends Triangle{/*** @param args*/public static void main(String[] args) {// TODO Auto-generated method stubTriangle a=new Triangle(1.0,1.5,1.0);a.setColor("yellow");a.setFilled(true);System.out.println("Area:"+a.getArea());System.out.println("Perimeter:"+a.getPerimeter());System.out.println("Color:"+a.getColor());System.out.println("isFilled:"+a.isFilled());}}class Triangle extends GeometricObject{double side1;double side2;double side3;public double getSide1() {return side1;}public double getSide2() {return side2;}public double getSide3() {return side3;}public Triangle(){this(1.0,1.0,1.0);}public Triangle(double s1,double s2,double s3){this.side1=s1;this.side2=s2;this.side3=s3;}double getArea(){double s=(side1+side2+side3)/2;return Math.sqrt(s*(s-side1)*(s-side2)*(s-side3));}double getPerimeter(){return side1+side2+side3;}public String toString(){String s=("Triangle:side1="+side1+"side2="+side2+"side3="+side3);return s;}}第二题：账户类Account的子类用myeclipse编辑源代码并显示，如下：package jicheng;import java.util.Date;public class lianxi9_3 {public static void main(String[] args) {// TODO Auto-generated method stubAccount account1 = new Account(1122, 20000, 0.045);account1.withDraw(2500);account1.desposit(3000);String output1 = "余额为："+ account1.getBalance() +"\n月利率为：" + account1.getMonthlyInterestRate()*100+"%"+"\n开户日期：" + account1.getDateCreated();System.out.println(output1+"\n");CheckingAccount account2 = new CheckingAccount(1122, 20000, 0.045);account2.desposit(3000);account2.withDraw(23500);String output2 = "余额为："+ account2.getBalance() +"\n月利率为：" + account2.getMonthlyInterestRate()*100+"%"+"\n开户日期：" + account2.getDateCreated();System.out.println(output2+"\n");SavingAccount account3 = new SavingAccount(1122, 20000, 0.045);account3.withDraw(25000);account3.desposit(3000);String output3 = "余额为："+ account3.getBalance() +"\n月利率为：" + account3.getMonthlyInterestRate()*100+"%"+"\n开户日期：" + account3.getDateCreated();System.out.println(output3+"\n");}}class CheckingAccount extends Account{public CheckingAccount(int id, double balance, double annualInterestRate){ this.id = id;this.balance = balance;this.annualInterestRate = annualInterestRate;dateCreated = new Date();}public void withDraw(double count){if(count-this.balance<=1000){balance -= count;} else{System.out.println("超过透支限定额");}}}class SavingAccount extends Account{public SavingAccount(int id, double balance, double annualInterestRate){ this.id = id;this.balance = balance;this.annualInterestRate = annualInterestRate;dateCreated = new Date();}public void withDraw(double count){if(count-this.balance<0){balance -= count;} else{System.out.println("该账户不能透支！");}}}class Account{protected int id;protected double balance;protected double annualInterestRate;protected Date dateCreated;public Account(int id, double balance, double annualInterestRate) { this.id = id;this.balance = balance;this.annualInterestRate = annualInterestRate;dateCreated = new Date();}public Account(){id = 0;balance = 0;annualInterestRate = 0;dateCreated = new Date();}public void setId(int id){this.id = id;}public void setBalance(double balance){this.balance = balance;}public void setAnnualInterestRate(double rate){this.balance = (balance>=0)? balance:0;}public int getId(){return id;}public double getAnnualInterestRate(){return annualInterestRate;}public String getDateCreated(){return dateCreated.toString();}public double getMonthlyInterestRate(){return annualInterestRate/12.0;}public void withDraw(double count){balance -= count;}public void desposit(double count){balance += count;}public double getBalance(){return balance;}}【实验总结】通过这次实验的例题熟悉了继承和多态的应用，掌握Java中类的继承定义、构造方法链的调用理解多态的原理，动态绑定的过程，掌握super的使用方法，区别函数覆盖和函数重载。
类的继承与多态性实验报告
类的继承与多态性实验报告目录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
super(newsurname,newname,newssn);
hourly=newhourly;
hours=newhours;
}
public void weeksalary()
{ week=hourly*hours;
}
public String toString()
{ return surname+name+"\t"+ssn+"\t"+week;
专业班级
通信1102(移动方向)
姓名
学号
时间：2013.11.11
地点：计通学院106机房
实验名称：继承与多态
实验前任务
实验目的：
1.理解继承是如何促进软件重用的
2.理解父类和子类的概念
3.能够通过继承已有的类来创建新类，并能吸收其属性和行为
4.理解访问修饰符protected
5.更够用关键字super访问父类成员
AmericanPeople americanPeople=new AmericanPeople();
BeijingPeople beijingPeople=new BeijingPeople();
chinaPeople.speakHello();
americanPeople.speakHello();
注：用相应的输出语句表示出语义即可。
3.抽象类和抽象方法。定义一个抽象类Shape,类里有一个抽象方法display();定义一个Cricle类，继承了Shape类，并实现抽象方法display();定义一个Rectangle类，继承了Shape类，并实现抽象方法display();定义一个Triangle类，继承了Shape类，并实现抽象方法display();定义一个类，实例化上述几个类的对角，并使用上述几个类的display方法。注：用相应的输出语句表示出语义即可
实验4 继承性和多态
实验四继承性和多态一、实验目的：熟悉JA V A中的继承性和多态性。
掌握子类的定义及用法，继承机制中的隐藏与覆盖。
子类的构造方法的用法，对象的上转型对象，抽象类与抽象方法等。
二、实验要求：1．根据下面的要求，编写Java应用程序实现：编写程序模拟中国人、美国人是人、北京人是中国人。
除主类外，程序中还有4个类：People、ChinaPeople、AmericanPeople和BeijingPeople类。
要求如下：●People类有权限是protected的double型成员变量height和weight，以及public voidspeakHello()、public void averageHeight()和public void averageWeight()方法。
●ChinaPeople类是People的子类，新增了public void chinaGongfu()方法。
要求ChinaPeople重写父类的public void speakHello()、public void averageHeight()和public void averageWeight()方法。
●AmericanPeople类是People的子类，新增public void americanBoxing()方法。
要求AmericanPeople重写父类的public void speakHello()、public void averageHeight()和public void averageWeight()方法。
●BeijingPeople类是ChinaPeople的子类，新增public void beijingOpera()方法。
要求ChinaPeople重写父类的public void speakHello()、public void averageHeight()和public void averageWeight()方法。
Java实验五继承与多态
Java实验五继承与多态实验五继承与多态一、实验目的1.掌握抽象类的声明；2.掌握多态的执行机理；3.掌握上转型的使用；4.掌握构造方法的执行机理；5.面向抽象的编程；二、实验内容1.假定根据学生的3门学位课程的分数决定其是否可以拿到学位，对于本科生，如果3门课程的平均分数超过60分即表示通过，而对于研究生，则需要平均超过80分才能够通过。
根据上述要求，请完成以下Java 类的设计：（1）设计一个基类Student描述学生的共同特征。
（2）设计一个描述本科生的类Undergraduate，该类继承并扩展Student类。
（3）设计一个描述研究生的类Graduate，该类继承并扩展Student类。
（4）设计一个测试类StudentDemo，分别创建本科生和研究生这两个类的对象，并输出相关信息。
2.假定要为某个公司编写雇员(40个雇员)工资支付程序，这个公司有各种类型的雇员（Employee），不同类型的雇员按不同的方式支付工资：（1）经理（Manager）——每月获得一份固定的工资（2）销售人员（Salesman）——在基本工资的基础上每月还有销售提成。
（3）一般工人（Worker）——则按他每月工作的天数计算工资。
根据上述要求试用类的继承和相关机制描述这些功能，并编写一个Java Application程序，演示这些类的用法。
（提示：应设计一个雇员类（Employee）描述所有雇员的共图特性，这个类应该提供一个计算工资的抽象方法ComputeSalary( )，使得可以通过这个类计算所有雇员的工资。
经理、销售人员和一般工人对应的类都应该继承这个类，并重新定义计算工资的方法，进而给出它的具体实现。
（用对象数组）三、实验报告涉及以下内容1.继承中父子构造方法的执行关系2.重写3.super的应用4.上转型5.多态。
实验名称 java类的继承和多态
实验名称 java类的继承和多态实验名称 Java类的继承和多态一、实验目的1、理解Java类的继承和多态的概念2、掌握类的继承机制的实现3、掌握方法的重载，以及多态的实现。
二、实验要求1、本实验属于验证型和设计型实验。
需要根据已给的源程序运行结果，并结合问题进行新的设计;2、对实验过程中提出的问题进行解答;3、完成实验报告。
三、实验内容与过程1、上机运行下面的程序，并回答下面的问题。
public class ClassOne{int num=100;public void compute(){num-=50;}public static void main(String args[]){ClassOne one=new ClassOne();ClassTwo two=new ClassTwo();System.out.println(“num of ClassTwo:”+two.num);System.out.println(“num of ClassOne:”+two.getNum());pute();System.out.println(“num of ClassTwo:”+two.num);System.out.println(“num of ClassOne:”+two.getNum());}}class ClassTwo extends ClassOne{int num=0;public void plus(){num+=50;}public int getNum(){return super.num;}}问题:(1) 请指出Java面向对象编程中三个主要特性。
(2) Java中的继承机制是什么,(3) 请指出程序中关键字super的作用。
2、运行下面的程序，回答问题。
class Monkey{private int age=10;void speak(){System.out.println("I am monkey.");}}class People extends Monkey{void computer(int a,int b){int c=a*b;System.out.println("I can computer "+a+"*"+b+"="+c);}void speak(){System.out.println("I am human.");}}public class Excise7_2{public static void main(String args[]){Monkey monkey=new People();monkey.speak();puter(10,12);People people=(People)monkey;puter(10,12);}}问题:1、上面的程序有一处错误，请改正使其能正确运行。
Java继承与多态实验报告.doc
Java继承与多态实验报告.doc
Java的继承与多态实验报告
本报告致力于分析Java继承与多态的概念、原理和作用，以及相关实验过程及其结果。
继承，又称为分类，是Java面向对象程序设计语言中定义类之间关系的重要技术。
它使一个类可以使用另一个基类中定义的方法和属性，在基类中已经定义了一些功能，子
类可以对基类功能进行拓展与定制。
《Java技术手册》得出结论，继承可以有效提高软件的复用性、可维护性和可重用性，使大型的、复杂的程序有条理层次。
多态是Java中一种特殊的程序结构，允许不同类的对象对相同的消息作出不同的响应，由程序的消息而不是对象的类型来决定对象的行为。
它是Java多态性的基础，使程
序能够在不同对象上进行操作，统一实现。
从实验中，可以明显看出Java继承与多态之间的联系：多态必须依赖于继承，当子
类被创建时，它继承了母类的方法以及特性，这样，它才能以逐渐上升的方式处理所有消息，而多态给了子类独特-->性的功能。
同时，多态也方便了代码重用，因为子类会继承
母类的方法和属性。
此外，结果表明，多态的优点使程序可以提高可重用性，它也减少了代码的重复编写，同时允许特定类之外的类可以得到适用。
它促进了软件不断更新，因为多态给开发人员提
供了以对象层次组织代码的方法。
本练习涉及到Java继承与多态概念的整体概述和实现细节，为完全理解多态的概念
打下了坚实的基础。
它提供了一个理解和使用这些概念的有用方式和指导。
昆明理工大学 java 实验报告 封装、继承和多态
昆明理工大学信息工程与自动化学院学生实验报告（2011 —2012 学年第 1 学期）课程名称：java程序设计开课实验室：信自楼机房445 2011 年11月 3日年级、专业、班计科093 学号200910405310姓名孙浩川成绩实验项目名称封装、继承和多态指导教师周兰江教师评语该同学是否了解实验原理： A.了解□ B.基本了解□ C.不了解□该同学的实验能力： A.强□ B.中等□ C.差□该同学的实验是否达到要求： A.达到□ B.基本达到□ C.未达到□实验报告是否规范： A.规范□ B.基本规范□ C.不规范□实验过程是否详细记录： A.详细□ B.一般□ C.没有□教师签名：年月日一、上机目的及内容上机内容1.把一个数转为二、十六、八进制。
2.获取计算机中的一个日期。
3.产生30个随机数，从小到大排列。
上机目的1.熟悉C++中讲到的类和对象的基本概念，为java程序设计奠定基础。
2.掌握java语言基本知识，实现进制转换、获取日期，排序等程序。
二、实验原理及基本技术路线图（方框原理图或程序流程图）1.把一个数转为二、十六、八进制。
调用java API中的Integer.toHexString(int)，Integer.toOctalString(int)，Integer.toBinaryString(int) 函数进行进制转换。
2.获取计算机中的一个日期。
调用java API 中 java.text.SimpleDateFormat，java.util.Calendar，java.util.Date 函数，获取计算机中的日期、时间。
3.产生30个随机数，从小到大排列。
使用java API中的Math.random()函数产生30个随机数，再用冒泡法从小到大排序。
三、所用仪器、材料（设备名称、型号、规格等或使用软件）1台PC及eclipse软件四、实验方法、步骤（或：程序代码或操作过程）1.进制转换public class exchange {String octal;String hexadecimal;String binary;public static void main(String[] args) {exchange exc = new exchange();System.out.println("5310转成二、八、十六进制");exc.convert(5310);}public void convert(int num) {octal = Integer.toOctalString(num);System.out.println("Convert to Octal is:\t" + octal);hexadecimal = Integer.toHexString(num);System.out.println("Convert to Hexadecimal is:" + hexadecimal);binary = Integer.toBinaryString(num);System.out.println("Convert to Binary is:\t" + binary);}}2.获取系统日期import java.text.SimpleDateFormat;import java.util.Calendar;import java.util.Date;public class GetDate {public String getDate() {SimpleDateFormat Format;Date date;Calendar MyDate = Calendar.getInstance();MyDate.setTime(new java.util.Date());date = MyDate.getTime();Format = new SimpleDateFormat( "yyyy-MM-dd HH:mm "); String gRtnStr = Format.format(date);return gRtnStr;}public static void main(String[] args){GetDate gd=new GetDate();String time=gd.getDate();System.out.println("当前日期为： "+time);}}3.产生30个随机数，从小到大排列public class PaiXu{private int num[] ;public PaiXu(int max){this.num = new int[max] ;System.out.println (max + "个随机数是: ") ;for (int i = 0; i<max; i++){num[i] = this.getRandomNum() ;System.out.print (num[i] + " ") ;}System.out.println () ;this.getTop10(this.num) ;}public int getRandomNum(){//产生0-99的随机数return ((int)(Math.random()*100)) ;}public void getTop10(int[] num){//进行冒泡排序并且输出int temp = 0 ;for (int j = 0; j<num.length; j++){for (int i = 0; i<num.length; i++){if(num[i] > num[j]){temp = num[i] ;num[i] = num[j] ;num[j] = temp ;}}}System.out.println ("排序后的数字是: ") ;for (int i = 0; i<num.length; i++){System.out.print (num[i] + " ") ;}System.out.println () ;}public static void main(String[] args){ new PaiXu(30) ;}}五、实验过程原始记录( 测试数据、图表、计算等)1.进制转换运行结果2.获取计算机中的一个日期3.产生30个随机数，从小到大排列六、实验结果、分析和结论（误差分析与数据处理、成果总结等。
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())
(4) 实验四 继承与多态
Java语言使用extends关键字在两个类之间建立这种类似与父子血缘关系的“继承”关系：在定义类时，使用extends来指明它的父类。
值得注意的是，Java中的继承只能是单继承即单根继承。
语法格式：
class SubClass extens SuperClass{//只能有一个父类
……
System.out.pri!~”);
}
public void fB(){
System.out.println(“method fB() from class B!”);
fA();
System.out.println(“x is”+ x);
}
}
public class Test{
2）什么时候需要使用super语句来显式调用父类构造？
（二）多态
多态是面向对象编程的重要技巧，它也是面向对象的重要特征之一。多态的本意是“同一个操作，不同的行为”，也就是使用同一个方法名，运行的实际是不同的方法。在Java语言中，多态主要通过方法的重载（Overloading）和重写（Overriding）实现。
public static void main(String[] args){
B b;
System.out.println(“====类已加载完毕=====”);
b = new B(10);
b.fB();
}
}
问题：
1）请结合运行结果分析Java中创建对象过程。(分析类的不同区域的运行前后次序，提示：类加载时或创建对象时，父类静态成员、实例成员、构造方法和子类静态成员、实例成员、构造方法的执行先后次序)
当程序运行并通过向上转型后的对象来调用方法时，Java会根据实际的对象类型来调用实际类型所对应的方法。这种运行时的多态，我们也成为动态绑定。
继承实验报告总结分析(3篇)
第1篇一、实验背景与目的在面向对象的编程中，继承是一种基本且重要的特性，它允许子类继承父类的属性和方法。
通过继承，我们可以复用代码，提高软件的可维护性和扩展性。
本次实验旨在通过实践，加深对Java中类继承机制的理解，包括单继承、多继承（通过接口实现）以及继承中可能出现的问题和解决方法。
二、实验内容与步骤1. 单继承实践：- 创建一个父类`Animal`，包含基本属性`name`和`age`，以及方法`eat()`和`sleep()`。
- 创建一个子类`Dog`，继承自`Animal`，并添加特有的属性`breed`和特有方法`bark()`。
2. 多继承实践：- 创建一个接口`CarFeature`，包含方法`startEngine()`和`stopEngine()`。
- 创建两个类`BM`和`QQ`，都实现`CarFeature`接口，并分别实现特有方法。
3. 继承中重名问题处理：- 在`Dog`类中，故意将`name`属性与`Animal`类的`name`属性重名。
- 使用`super`关键字访问父类中的`name`属性。
4. 多态实践：- 创建一个`Car`类的引用，指向实现了`CarFeature`接口的`BM`和`QQ`对象。
- 通过`Car`类的引用调用`startEngine()`和`stopEngine()`方法，观察多态效果。
三、实验结果与分析1. 单继承结果：- `Dog`类正确地继承了`Animal`类的属性和方法。
- `Dog`类可以访问`Animal`类中定义的`name`和`age`属性，以及`eat()`和`sleep()`方法。
2. 多继承结果：- `BM`和`QQ`类都正确实现了`CarFeature`接口，并实现了各自的`startEngine()`和`stopEngine()`方法。
- 通过多态，可以创建`Car`类的引用，指向不同实现类的对象，并调用相应的方法。
java实验报告2继承多态封装
实验报告学生姓名：学号：专业班级：实验类型：□验证□综合□设计□创新实验日期：实验成绩：一、实验项目名称抽象、封装与类（一）二、实验目的1.掌握抽象、封装、继承和多态2.熟练掌握如何自定义一个类。
3.掌握类的访问权限4.掌握类成员的访问控制1三、实验基本原理四、主要仪器设备及耗材Myclipse五、实验步骤1、调试程序例3-42、编写如下程序。
（1）定义一个表示学生的类Student，包括属性“学号”、“班号”、“姓名”、“性别”、“年龄”；方法“获得学号”、“获得班号”、“获得姓名”、“获得性别”、“获得年龄”、“修改年龄”。
（2）为Student类定义构造函数初始化所有属性，增加一个方法public String toString()，把Student类对象的所有属性信息组合成一个字符串输出。
（3）在main()中创建Student类对象，测试自定义类。
六、实验数据及处理结果1、package ncu;2public class Exam3_4 {s tatic double d;p ublic static void main(String args[]){int i;Exam3_4 pt=new Exam3_4();i=5;(i);"int type value is:"+i);=;(pt);"double type value is"+d);}public void changeInt(int v){v=10;}p ublic void changeDouble(Exam3_4 ref){=;}}32、package ncu;public class student {p rivate int id;p rivate String name;p rivate String tel;p rivate String addr;p rivate static int total;p ublic int getid(){return ;}p ublic void setid(int id){4=id;}p ublic String getname(){return name;}public void setname(String name){=name;}public String gettel(){return tel;}public void settel(String tel){=tel;}public String getaddr(){return addr;}public void setaddr(String addr){=addr;}public student(){total++;id=total;}public student(String name){total++;id=total;=name;5}public String toString(){S tring s="id:"+id+" name:"+name+" tel:"+tel+" addr:"+addr;r eturn s;}public static void main(String[]args){s tudent stu1=new student ("zhangsan");("123456");("nanchang");七、思考讨论题或体会或对改进实验的建议八、参考资料6。
java类的继承与多态实验报告
this.c=c;
}
doublearea() {
doubleL=(a+b+c)/2;
//TODOAuto-generated method stub
returnMath.sqrt(L*(L-a)*(L-b)*(L-c));
}
doublelength() {
//TODOAuto-generated method stub
return4*a;
}
}
packageruanjian.zhaihaiyang.shiyan3;
publicclassCircleextendsShape {
privatedoubler;
publicCircle(doubler,Stringname){
super(name);
this.r=r;
}
doublearea() {
doubleL=(a+b+c)/2;
return2*L;
}
packageruanjian.zhaihaiyang.shiyan3;
publicclassShapeDemo {
publicstaticvoidmain(String[]args) {
Shapes1=null;
s1=newCircle(5,"圆形");
源代码：
packageruanjian.zhaihaiyang.shiyan3;
publicabstractclassShape {
protectedStringname;
publicShape(){
name="图形类";
}
publicShape(Stringname){
实验报告二 Java类的封装、继承、多态
System.out.println （"坐标为:"+this.get_x()+" "+this.get_z()); } } "+this.get_y()+"
3. 思考题
1． 什么是类的多态性。 同一操作作用于不同的对象，可以有不同的解释，产生不 同的执行结果，这就是多态性。 编译时的多态性：编译时的多态性是通过重载来 实现的。对于非虚的成员来说，系统在编译时， 根据传递的参数、返回的类型等信息决定实现何 种操作。 运行时的多态性：运行时的多态性就是指直到系 统运行时，才根据实际情况决定实现何种操作。 四．程序代码
} } for(i=0;i<10;i++){ System.out.print("第"+(i+1)+"个点"); array[i].print(); } } }
2． 创建一个数组，随机生成Point2D或者Point3D的对 象放于其中。最后依次调用数组中每个对象的“打 印方法”，显示数组中存储的对象是什么。 提示：ng..Math.random()方法 或者 java.util.Random类 2.2 设计工作 设计思路： 构造Point 2D类，私有成员x,y存放2D点位置坐标，构造函 数传入坐标值。Offset()函数平移2D点，get_x(),get_y()分别 返回x,y坐标。Print()函数打印2D点坐标。再构造继承了2D类 的Point3D类，将上述2D点函数覆盖扩充到3D。创建Point 2D的对象数组，存放随机产生的Point 2D或Point 3D对象。 用 java.util.Random方法产生随机数。 类图：
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
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;
{
System.out.println(name+", "+number);
}
}
（2）编译Student.java，产生类文件Student.class。
2．创建继承的类Undergraduate
（1）程序功能：通过Student类产生子类undergraduate，其不仅具有父类的成员变量
name（姓名）、number（学号），还定义了新成员变量academy（学院）、department
if (userName!=null)
s="用户名："+userName;
else
s="用户名不能为空！";
if (password!="12345678")
s=s+"口令无效！";
else
s=s+"口令：********";
System.out.println(s);
}
}
public classRunDemo{
{
int x1, y1, x2, y2;
public void init() {
addMouseListener(this);
addMouseMotionListener(this);
}
public void paint(Graphics g) {
【代码2】//画一条直线
}
public void mousePressed(MouseEvent e) { //记录起点坐标
</applet >
</html>
(三)构造方法的重载
（1）编写构造方法User的重载程序文件RunDemo，源代码如下。
classUser{
private String userName, password;
【代码1】//定义一个无参构造方法的头部
{
System.out.println("全部为空!");
}
public String sort(int a, int b, int c) {
int swap;
if (a<b) {
swap=a;
a=b;
b=swap;
}
if (a<c) {
swap=a;
a=c;
c=swap;
}
54
if (b<c) {
swap=b;
b=c;
c=swap;
}
return a+""+b+""+c;
使用之前必须先声明，因为声明了，运行时计算机才能划分计算机空间给他。根据变量不同，或者在堆里，或者在栈里。但是没有声明的话，连存在的空间都没有，那么读写也就无从谈起。不是必须先赋值，因为会自动赋默认值。
2．什么是构造方法。
构造方法是一种特殊的方法，它是一个与类同名且没有返回值类型的方法。对象的创建就是通过构造方法来完成，其功能主要是完成对象的初始化。当类实例化一个对象时会自动调用构造方法。构造方法和其他方法一样也可以重载。
二、实验要求
1.编写体现类的继承性（成员变量、成员方法、成员变量隐藏）的程序。
2.编写体现类的多态性（成员方法重载）的程序。
3.编写体现类的多态性（构造方法重载）的程序。
4.编写使用接口的程序。
三、实验内容
（一）类的继承
1.创建公共类Student.
（1）编写程序文件Student.java，源代码如下:
x1=e.getX();
y1=e.getY();
}
public void mouseClicked(MouseEvent e) {}
public void mouseEntered(MouseEvent e) {}
public void mouseExited(MouseEvent e) {}
public void mouseReleased(MouseEvent e) {}
}
public String sort(int arr[]) {
String s="";
int swap;
for (int i=0; i<arr.length; i++)
for (int j=0; j<arr.length-1; j++)
if (arr[j]>arr[j+1]) {
swap=arr[j];
（1）编写实现接口的程序文件Interface.java，源代码如下。
import java.applet.Applet;
import java.awt.*;
import java.awt.event.*;
【代码1】//定义一个实现接口MouseListener, MouseMotionListener并继承Applet的一个类的头部，类名为Interface
public void mouseMoved(MouseEvent e) {}
public void mouseDragged(MouseEvent e) { //记录终点坐标
x2=e.getX();
y2=e.geபைடு நூலகம்Y();
repaint();
}
}
编译Interface.java文件。
编写Interface.html文件，源代码如下。
西安邮电大学
（计算机学院）
课内实验报告
实验名称：继承与多态
专业名称：计算机科学与技术
班级：计科1405班
学生姓名：高宏伟
学号：04141152
指导教师：刘霞林
实验日期：2016.10.13
一、实验目的
通过编程和上机实验理解Java语言的继承和多态特性，掌握变量的隐藏、方法的覆盖、重载，掌握抽象类和接口的使用。
arr[j]=arr[j+1];
arr[j+1]=swap;
}
for (int i=0; i<arr.length; i++)
s=s+arr[i]+"";
return s;
}
}
public classSortextends Applet {
IntSort s=new IntSort();
public void paint(Graphics g) {
int a=30, b=12, c=40;
int arr[]={34,8,12,67,44,98,52,23,16,16};
g.drawString("两个数的排序结果："+s.sort(a,b),30,30);
g.drawString("三个数的排序结果："+s.sort(a,b,c),30,60);
g.drawString("数组的排序结果："+s.sort(arr),30,90);
}
}
（3）编译并运行程序
（4）编写Sort类文件的页面文件sort.html
<html>
<applet codebase=e:/java/程序code=KY3_11.class width=420 height=380>
public static void main(String[] args) {
newUser();
new User("刘新宇");
new User(null,"邵丽萍");
new User("张驰","12345678");
}
}
（2）编译并运行程序
（四）实现 MouseListener 和 MouseMotionListener 两个接口
}
【代码2】//定义一个构造方法，参数为name，用name初始化成员变量userName
【代码3】//定义一个构造方法的头部，参数为name和pwd
{
【代码4】//调用上个构造方法初始化userName
【代码5】//初始化成员变量password
check();
}
void check() {
String s=null;
（系）。在程序中调用父类的print方法。
（2）编写Undergraduate程序:
classUndergraduateextendsStudent
{
【代码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