Java实验报告 继承、多态、接口和异常处理
java实验报告——继承与接口
System.out.print('\t'+"平均分");
System.out.println('\t'+"成绩等级");
for(int i=0; i<pg.length;i++) {
System.out.print(pg[i].Name); System.out.print('\t'+pg[i].Stu_type); System.out.print('\t'+String.valueOf(pg[i].C_score)); System.out.print('\t'+String.valueOf(pg[i].English_score)); System.out.print('\t'+String.valueOf(pg[i].Java_score)); System.out.print('\t'+String.valueOf(pg[i].score)); System.out.println('\t'+pg[i].sco_Level); } System.out.println(); } }
String Name=""; String Stu_type=""; int C_score; int English_score; int Java_score; int score; // String sco_Level=""; Sco_Level sco_Level;
public Student(String name,String stu_type,int sco1,int sco2,int sco3) {
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中覆盖不仅仅发生在类的继承/扩展上，还可能发生在接口的实现上。
Java实验指导4继承与多态
《Java程序设计》实验指导实验四继承与多态一、实验目的：1．掌握类的继承方法。
2．掌握变量的继承和覆盖。
3．掌握方法的继承、重载和覆盖。
4．了解接口的实现方法。
二、实验原理新类可从现有的类中产生，并保留现有类的成员变量和方法，并可根据需要对它们加以修改。
新类还可添加新的变量和方法。
这种现象就称为类的继承。
当建立一个新类时，不必写出全部成员变量和成员方法。
只要简单地声明这个类是从一个已定义的类继承下来的，就可以引用被继承类的全部成员。
被继承的类称为父类或超类（superclass），这个新类称为子类。
Java 提供了一个庞大的类库让开发人员继承和使用。
设计这些类是出于公用的目的，因此，很少有某个类恰恰满足你的需要。
你必须设计自己的能处理实际问题的类，如果你设计的这个类仅仅实现了继承，则和父类毫无两样。
所以，通常要对子类进行扩展，即添加新的属性和方法。
这使得子类要比父类大，但更具特殊性，代表着一组更具体的对象。
继承的意义就在于此。
语法格式：类访问限定符子类名extends 父类名｛……｝三、实验内容及要求：1. 定义一个接口（ShapeArea），其中包含返回面积的方法（getArea）。
定义一个矩形类（Rectangle），派生出一个正方形类（Square），再定义一个圆类（Circle），三者都要求实现接口ShapeArea，自行扩充成员变量和方法。
在主方法中建一数组，数组中放入一些上述类型的对象，并计算它们的面积之和。
2. 运行下面的程序，理解成员变量的继承与隐藏，方法的覆盖与重载。
class A{int sum,num1,num2;public A(){num1=10;num2=20;sum=0;}void sum1(){sum=num1+num2;System.out.println("sum="+num1+"+"+num2+"="+sum);}void sum2(int n){num1=n;sum=num1+num2;System.out.println("sum="+num1+"+"+num2+"="+sum);}}class B extends A{int num2;public B(){num2=200;}void sum2(){sum=num1+num2;System.out.println("sum="+num1+"+"+num2+"="+sum);}void sum2(int n){num1=n;sum=num1+num2;System.out.println("sum="+num1+"+"+num2+"="+sum);}void sum3(int n){super.sum2(n);System.out.println("sum="+num1+"+"+num2+"="+sum);}}public class test{public static void main (String arg[]){B m=new B();m.sum1();m.sum2();m.sum2(50);m.sum3(50);}}。
java异常处理实验报告
java异常处理实验报告Java异常处理实验报告一、实验目的本次实验旨在通过编写Java程序，学习和掌握异常处理的相关知识和技巧，提高代码的健壮性和可靠性。
二、实验环境本次实验使用的开发环境为Eclipse，使用Java语言进行编程。
三、实验内容1. 异常的概念异常是指程序在运行过程中出现的意外情况，例如除零错误、数组越界等。
Java中的异常是以类的形式存在的，所有异常类都是Throwable类的子类。
2. 异常处理的方法Java提供了try-catch-finally语句用于处理异常。
在try块中编写可能会抛出异常的代码，如果发生异常，则会跳转到对应的catch块进行处理。
finally块中的代码无论是否发生异常都会被执行。
3. 异常的分类Java中的异常分为两种类型：受检异常（Checked Exception）和非受检异常（Unchecked Exception）。
受检异常需要在代码中显式地进行处理，否则编译器会报错；而非受检异常不需要强制处理。
4. 自定义异常除了使用Java提供的异常类，我们还可以根据需要自定义异常类。
自定义异常类需要继承Exception类或RuntimeException类，并重写相应的方法。
5. 异常处理的最佳实践在实际的软件开发中，异常处理是非常重要的一部分。
以下是一些异常处理的最佳实践：- 尽早捕获异常：在代码中尽量早地捕获异常，以避免异常的传播和影响其他部分的代码。
- 适当处理异常：根据具体情况，选择合适的处理方式，可以是打印日志、返回默认值、抛出新的异常等。
- 避免捕获过宽的异常：捕获异常时要尽量精确，避免捕获过宽的异常类型，以免屏蔽了真正的问题。
四、实验步骤1. 创建一个Java项目，并新建一个类用于实现异常处理的实验。
2. 编写代码，在try块中编写可能会抛出异常的代码。
3. 使用catch块捕获异常，并进行相应的处理，例如打印异常信息。
4. 在finally块中编写必要的代码，例如资源的释放。
java类的继承实验报告
java类的继承实验报告Java类的继承实验报告引言：在面向对象的编程语言中，继承是一种重要的概念。
Java作为一种面向对象的编程语言，也提供了类的继承机制。
本实验旨在通过编写Java程序，深入理解和掌握Java类的继承。
实验目的：1. 理解继承的概念和原理；2. 掌握Java中类的继承的语法和用法；3. 实践继承的实际应用。
实验过程：1. 创建父类和子类在实验中，我们首先创建一个父类和一个子类。
父类可以是一个基本的类，子类则继承了父类的属性和方法。
这样，子类就可以在不改变父类的基础上，扩展自己的功能。
2. 继承的语法和用法Java中，使用关键字"extends"来实现类的继承。
子类通过继承父类，可以获得父类的属性和方法，并且可以在子类中添加新的属性和方法。
在实验中，我们可以通过创建子类对象，并调用继承自父类的方法来验证继承的正确性。
3. 方法的重写在继承中，子类可以重写父类的方法。
这样，当子类调用该方法时，实际上执行的是子类重写后的方法。
通过方法的重写，我们可以实现多态性的效果。
4. 实际应用在实验中，我们可以选择一个具体的应用场景，例如动物类的继承。
我们可以创建一个父类Animal，包含基本的属性和方法，然后创建子类Dog和Cat，分别继承Animal类，并添加自己的特有属性和方法。
通过这个实例，我们可以更好地理解继承的实际应用。
实验结果：通过实验，我们成功地创建了父类和子类，并验证了继承的正确性。
我们还成功地重写了父类的方法，实现了多态性的效果。
最后，我们还通过实际应用的例子，更好地理解了继承的实际应用。
实验总结：通过本次实验，我们深入理解和掌握了Java类的继承。
继承是面向对象编程中的重要概念，通过继承，我们可以实现代码的重用和扩展。
在实际应用中，继承也可以帮助我们更好地组织代码，提高代码的可读性和可维护性。
然而，继承也有一些限制和注意事项。
首先，Java中只支持单继承，即一个子类只能继承一个父类。
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 类要在同一文件夹（路径）内。
java实验报告
java实验报告Java 实验报告一、实验目的本次 Java 实验的主要目的是通过实际编程操作，深入理解和掌握Java 语言的基本语法、面向对象编程的概念和方法，以及常用类库的使用。
同时，培养我们的问题解决能力、逻辑思维能力和代码规范意识，为今后的软件开发工作打下坚实的基础。
二、实验环境1、操作系统：Windows 102、开发工具：Eclipse IDE for Java Developers3、 JDK 版本：JDK 18三、实验内容本次实验共包括以下三个部分：1、 Java 基本语法练习变量与数据类型运算符与表达式控制流语句（ifelse、for、while、dowhile）数组2、面向对象编程实践类与对象的定义和使用构造函数与方法重载封装、继承与多态抽象类与接口3、 Java 常用类库应用String 类与字符串操作集合框架（ArrayList、HashMap）文件输入输出（File、FileReader、FileWriter）四、实验步骤及代码实现1、 Java 基本语法练习变量与数据类型：｀｀｀javapublic class VariableDataType ｛public static void main(String args) ｛int age ＝ 20;double salary ＝ 50005;String name ＝＂张三"；boolean isStudent ＝ true;Systemoutprintln(＂年龄：＂＋ age)；Systemoutprintln(＂工资：＂＋ salary)；Systemoutprintln(＂姓名：＂＋ name)；Systemoutprintln(＂是否是学生：＂＋ isStudent)；｝｝｀｀｀运算符与表达式：｀｀｀javapublic class OperatorExpression ｛public static void main(String args) ｛int num1 ＝ 10;int num2 ＝ 5;int sum ＝ num1 ＋ num2;int difference ＝ num1 num2;int product ＝ num1 num2;int quotient ＝ num1 ／ num2;int remainder ＝ num1 ％ num2; Systemoutprintln(＂和：＂＋ sum)；Systemoutprintln(＂差：＂＋ difference)；Systemoutprintln(＂积：＂＋ product)；Systemoutprintln(＂商：＂＋ quotient)；Systemoutprintln(＂余数：＂＋ remainder)；｝｝｀｀｀控制流语句：｀｀｀javapublic class ControlFlowStatement ｛public static void main(String args) ｛／／ ifelse 语句int score ＝ 80;if （score ＞＝ 90) ｛Systemoutprintln(＂优秀"）；｝ else if （score ＞＝ 80) ｛Systemoutprintln(＂良好"）；｝ else if （score ＞＝ 70) ｛Systemoutprintln(＂中等"）；｝ else if （score ＞＝ 60) ｛Systemoutprintln(＂及格"）；｝ else ｛Systemoutprintln(＂不及格"）；｝／／ for 循环for （int i ＝ 1; i ＜＝ 5; i+＋）｛Systemoutprintln(＂第" ＋ i ＋＂次循环"）；｝／／ while 循环int j ＝ 1;while （j ＜＝ 5) ｛Systemoutprintln(＂第" ＋ j ＋＂次 while 循环"）；j+＋；｝／／ dowhile 循环int k ＝ 1;do ｛Systemoutprintln(＂第" ＋ k ＋＂次 dowhile 循环"）；k+＋；｝ while （k ＜＝ 5)；｝｝｀｀｀数组：｀｀｀javapublic class ArrayExample ｛public static void main(String args) ｛／／一维数组int numbers ＝｛1, 2, 3, 4, 5}；for （int num ： numbers) ｛Systemoutprintln(num)；｝／／二维数组int matrix ＝｛｛1, 2, 3}，｛4, 5, 6}，｛7, 8, 9}｝；for （int row ： matrix) ｛for （int num ： row) ｛Systemoutprint(num ＋＂＂）；｝Systemoutprintln(）；｝｝｝｀｀｀2、面向对象编程实践类与对象的定义和使用：｀｀｀javapublic class Person ｛private String name;private int age;public Person(String name, int age) ｛thisname ＝ name;thisage ＝ age;｝public void showInfo(）｛Systemoutprintln(＂姓名：＂＋ name ＋＂，年龄：＂＋ age)；｝public static void main(String args) ｛Person person1 ＝ new Person(＂张三"， 20)；person1showInfo(）；｝｝｀｀｀构造函数与方法重载：｀｀｀javapublic class ConstructorOverloading ｛private String name;private int age;public ConstructorOverloading(String name) ｛thisname ＝ name;｝public ConstructorOverloading(String name, int age) ｛thisname ＝ name;thisage ＝ age;｝public void showInfo(）｛if （age ＝＝ 0) ｛Systemoutprintln(＂姓名：＂＋ name)；｝ else ｛Systemoutprintln(＂姓名：＂＋ name ＋＂，年龄：＂＋ age)；｝｝public static void main(String args) ｛ConstructorOverloading person1 ＝ new ConstructorOverloading(＂张三"）；person1showInfo(）；ConstructorOverloading person2 ＝ new ConstructorOverloading(＂李四"， 25)；person2showInfo(）；｝｝｀｀｀封装、继承与多态：｀｀｀java／／父类class Animal ｛private String name;public Animal(String name) ｛thisname ＝ name;｝public void eat(）｛Systemoutprintln(name ＋＂正在吃东西"）；｝｝／／子类继承父类class Dog extends Animal ｛public Dog(String name) ｛super(name)；｝public void bark(）｛Systemoutprintln(name ＋＂在叫"）；｝｝public class InheritancePolymorphism ｛public static void main(String args) ｛Animal animal ＝ new Dog(＂小黑"）；animaleat(）；／／向下转型为 Dog 类型调用 bark 方法if （animal instanceof Dog) ｛Dog dog ＝（Dog) animal;dogbark(）；｝｝｝｀｀｀抽象类与接口：｀｀｀java／／抽象类abstract class Shape ｛abstract void draw(）；｝／／实现抽象类的子类class Circle extends Shape ｛＠Overridevoid draw(）｛Systemoutprintln(＂画一个圆"）；｝｝／／接口interface Moveable ｛void move(）；｝／／实现接口的类class Car implements Moveable ｛＠Overridepublic void move(）｛Systemoutprintln(＂汽车在移动"）；｝｝public class AbstractInterfaceExample ｛public static void main(String args) ｛Shape shape ＝ new Circle(）；shapedraw(）；Moveable car ＝ new Car(）；carmove(）；｝｝｀｀｀3、 Java 常用类库应用String 类与字符串操作：｀｀｀javapublic class StringOperation ｛public static void main(String args) ｛String str1 ＝＂Hello, ＂；String str2 ＝＂World!＂；String str3 ＝ str1 ＋ str2;Systemoutprintln(str3)；int length ＝ str3length(）；Systemoutprintln(＂字符串长度：＂＋ length)；char charAt ＝ str3charAt(5)；Systemoutprintln(＂第 5 个字符：＂＋ charAt)；boolean contains ＝ str3contains(＂World"）；Systemoutprintln(＂是否包含 World：＂＋ contains)；｝｝｀｀｀集合框架（ArrayList、HashMap）：｀｀｀javaimport javautilArrayList;import javautilHashMap;import javautilMap;public class CollectionFramework ｛public static void main(String args) ｛／／ ArrayListArrayList<String> names ＝ new ArrayList<＞（）；namesadd(＂张三"）；namesadd(＂李四"）；namesadd(＂王五"）；for （String name ： names) ｛Systemoutprintln(name)；｝／／ HashMapHashMap<String, Integer> ages ＝ new HashMap<＞（）；agesput(＂张三"， 20)；agesput(＂李四"， 25)；agesput(＂王五"， 30)；for （MapEntry<String, Integer> entry ： agesentrySet(））｛Systemoutprintln(entrygetKey(）＋＂的年龄是" ＋entrygetValue(））；｝｝｝｀｀｀文件输入输出（File、FileReader、FileWriter）：｀｀｀javaimport javaioFile;import javaioFileReader;import javaioFileWriter;import javaioIOException;public class FileIOExample ｛public static void main(String args) ｛／／写入文件try （FileWriter writer ＝ new FileWriter(＂outputtxt"））｛writerwrite(＂这是写入文件的内容"）；｝ catch （IOException e) ｛eprintStackTrace(）；｝／／读取文件try （FileReader reader ＝ new FileReader(＂outputtxt"））｛int character;while （（character ＝ readerread(））！＝－1) ｛Systemoutprint(（char) character)；｝｝ catch （IOException e) ｛eprintStackTrace(）；｝｝｝｀｀｀五、实验结果与分析1、 Java 基本语法练习变量与数据类型：能够正确定义和使用各种数据类型的变量，并进行基本的运算和输出。
实验名称 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实训总结报告6篇
大学生java实训总结报告6篇篇1一、实训背景与目标本次Java实训旨在通过实践操作，加深大学生对Java编程语言的理解与掌握，提高实际项目开发能力。
在为期一个月的实训期间，我们小组围绕Java SE基础、Java Web开发、数据库操作等内容进行了系统学习和实践。
通过本次实训，我们期望达到以下目标：1. 深入理解Java核心技术与编程思想。
2. 掌握Java Web开发的基本流程和关键技术。
3. 学会使用至少一种数据库进行Java程序与数据库的交互。
4. 具备一定的项目开发和团队协作能力。
二、实训内容与过程1. Java SE基础实训在实训初期，我们重点复习和巩固了Java SE基础知识，包括数据类型、运算符、流程控制、面向对象编程等。
通过编写简单的控制台程序，我们实践了异常处理、集合类、泛型以及多线程编程。
2. Java Web开发实训随后，我们转向Java Web开发的学习。
通过学习和实践，掌握了基于Servlet和JSP的Web开发技术。
同时，学习了HTML、CSS和JavaScript等前端技术，并练习了前后端数据的交互。
此外，还了解了MVC设计模式在Web开发中的应用。
3. 数据库操作实训在数据库操作方面，我们主要学习了SQL语言以及JDBC操作数据库的技术。
通过实践操作，我们能够在Java程序中实现数据的增删改查，并学会了使用ORM框架进行对象与数据库表的映射。
4. 项目开发实践在实训的最后阶段，我们以小组形式进行了一个小型项目——在线图书管理系统。
通过项目的开发，我们综合运用了前面学到的知识，包括Web开发技术、数据库操作等。
在项目开发过程中，我们学会了如何分工合作，如何进行有效的项目管理。
三、实训收获与体会1. 提升了编程能力。
通过实训，我们对Java编程语言有了更深入的了解，编程能力得到了显著提高。
2. 增强了项目开发经验。
项目开发的实践让我们体验到了软件开发的流程，学会了如何在项目中运用所学知识。
Java继承与多态实验报告.doc
Java继承与多态实验报告.doc
Java的继承与多态实验报告
本报告致力于分析Java继承与多态的概念、原理和作用，以及相关实验过程及其结果。
继承，又称为分类，是Java面向对象程序设计语言中定义类之间关系的重要技术。
它使一个类可以使用另一个基类中定义的方法和属性，在基类中已经定义了一些功能，子
类可以对基类功能进行拓展与定制。
《Java技术手册》得出结论，继承可以有效提高软件的复用性、可维护性和可重用性，使大型的、复杂的程序有条理层次。
多态是Java中一种特殊的程序结构，允许不同类的对象对相同的消息作出不同的响应，由程序的消息而不是对象的类型来决定对象的行为。
它是Java多态性的基础，使程
序能够在不同对象上进行操作，统一实现。
从实验中，可以明显看出Java继承与多态之间的联系：多态必须依赖于继承，当子
类被创建时，它继承了母类的方法以及特性，这样，它才能以逐渐上升的方式处理所有消息，而多态给了子类独特-->性的功能。
同时，多态也方便了代码重用，因为子类会继承
母类的方法和属性。
此外，结果表明，多态的优点使程序可以提高可重用性，它也减少了代码的重复编写，同时允许特定类之外的类可以得到适用。
它促进了软件不断更新，因为多态给开发人员提
供了以对象层次组织代码的方法。
本练习涉及到Java继承与多态概念的整体概述和实现细节，为完全理解多态的概念
打下了坚实的基础。
它提供了一个理解和使用这些概念的有用方式和指导。
java异常处理实验报告
java异常处理实验报告Java异常处理实验报告实验目的：通过实验，掌握Java中异常处理的基本原理和方法，能够编写能够处理各种异常情况的程序。
实验环境：使用Java编程语言，Eclipse集成开发环境。
实验内容：1. 异常的基本概念异常是指在程序执行过程中出现的错误情况，包括编译时异常和运行时异常。
编译时异常是在编译阶段就会被检测出来的异常，如IOException、SQLException等；而运行时异常是在程序运行过程中才会出现的异常，如NullPointerException、ArrayIndexOutOfBoundsException等。
在Java中，异常是以类的形式存在的，所有的异常类都是Throwable类的子类。
2. 异常处理的方法在Java中，异常处理的方法主要有try-catch语句和throws关键字。
try-catch 语句用于捕获和处理异常，可以将可能发生异常的代码放在try块中，然后在catch块中处理异常；throws关键字用于声明方法可能抛出的异常，让调用该方法的代码处理异常。
3. 编写能够处理异常的程序通过实验，我们编写了一段能够处理异常的程序。
在程序中，我们使用了try-catch语句来捕获可能发生的异常，并且在catch块中输出异常信息，以便程序的调用者能够得到相应的反馈。
实验结果：经过实验，我们成功掌握了Java中异常处理的基本原理和方法，能够编写能够处理各种异常情况的程序。
实验总结：异常处理是Java编程中非常重要的一部分，能够有效地提高程序的健壮性和可靠性。
通过本次实验，我们深入理解了异常处理的原理和方法，为今后的Java编程打下了坚实的基础。
希望通过不断的实践和学习，能够更加熟练地运用异常处理的技巧，编写出高质量的Java程序。
Java实验三实验报告
实验报告课程名称面向对象课程设计实验项目名称类的继承班级与班级代码13计算机科学与技术1班实验室名称（或课室）SS1 205专业计算机科学与技术任课教师尹华学号：12251102120姓名：林淑英实验日期：2014 年4 月28 日广东财经大学教务处制姓名林淑英实验报告成绩评语：指导教师（签名）年月日说明：指导教师评分后，实验报告交院（系）办公室保存。
实验三类的继承、多态、接口、访问控制符与修饰符实验目的：通过编程练习掌握类的继承，多态，接口，访问控制符与修饰符的使用方法。
实验原理：类的继承，接口。
实验设备：计算机，Eclipse。
实验题目：1.设计一个Person 类，其成员变量有：姓名(name)、性别(gender)、年龄(age)；再设计一个Student类，它是类Person的子类，其成员变量有：学号(id)、班名(cname)、成绩(score)，类Student中要有一个方法 display()，用来显示一个学生的信息。
编写一个测试程序，创建一个Student类的对象，要求name和id 是自己的姓名和学号，输出学生的各种信息，学生的基本信息在类Student的带参数的构造方法中设定。
2.定义一个类A，该类有一个方法f，方法f可以输出英文字母，再定义一个类B是A的子类，子类B不能重写父类A的方法f，子类有一个方法g，可以输出中文字符串。
编写测试程序，创建B的对象，输出英文字母和中文字符串。
3.定义一个坐标类Pointer，成员变量包括x和y；成员方法有：（1）构造方法（2）setX、setY、getX、getY、display方法（3）类方法distance用来计算两点之间的距离编写测试程序，创建Pointer的两个对象并计算两个点坐标的距离。
4. 定义一个抽象类Area、两个Area的子类RectArea和RoundArea，以及一个实现类ImpleArea。
要求如下（1）抽象类Area类中只包含一个抽象方法double area()。
JAVA 继承和多态实验报告
实验项目名称：继承和多态（所属课程：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(){return"The Area is:" + getCircleArea()+ "\nThe Perimeter is:" + getCirclePerimeter();}}package Class;public class Rectangle extends Shape{private double width;private double height;public Rectangle(String color,double width,double height) { super(color);this.width = width;this.height = height;}public void setWidth(double width){this.width = width;}public double getWidth(){return width;}public void setHeight(double height){this.height = height;}public double getHeight(){return height;}public double getRectangleArea(){return width*height;}public double getRectanglePerimeter(){return 2*(width + height);}public String toString(){return"The Area is:" + getRectangleArea()+ "\nThe Perimeter is:" + getRectanglePerimeter();}}package Class;public class Triangle extends Shape{private double a;private double b;private double c;private double s;public Triangle(String color,double a,double b,double c, double s){ super(color);this.a = a;this.b = b;this.c = c;this.s = s;}public void setA(double a){this.a = a;}public double getA(){return a;}public void setB(double b){this.b = b;}public double getB(){return b;}public void setC(double c){this.c = c;}public double getC(){return c;}public double getTriangleArea(){return Math.sqrt(s*(s-a)*(s-b)*(s-c));}public double getTrianglePerimeter(){return a + b + c;}public String toString(){return"The Area is:" + getTriangleArea()+ "\nThe Perimeter is:" + getTrianglePerimeter();}}Main包package Main;import Class.Shape;import Class.Circle;import Class.Rectangle;import Class.Triangle;import java.util.Scanner;public class test {public static void main(String[] args) {Scanner input = new Scanner(System.in);System.out.print("请输入圆的半径： ");double radius = input.nextDouble();Circle circle = new Circle(null, radius);System.out.println(circle.toString());System.out.print("\n请输入矩形的宽： ");double width = input.nextDouble();System.out.print("请输入矩形的高： ");double height = input.nextDouble();Rectangle rectangle = new Rectangle(null, width, height);System.out.println(rectangle.toString());System.out.print("\n请输入三角形的第一条边 a： ");精选文库double a = input.nextDouble();System.out.print("请输入三角形的第二条边 b： ");double b = input.nextDouble();System.out.print("请输入三角形的第三条边 c： ");double c = input.nextDouble();double s = (a + b + c)/2;Triangle triangle = new Triangle(null, a, b, c, s);System.out.println(triangle.toString());}}运行结果为：4．实验总结（1）通过实验掌握了类的继承机制。
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())
继承、多态、接口、异常(DOC)
一、继承面向对象的三大特征：封装、继承、多态1、定义：继承是软件可重用性的一种表现，新类可以在不增加自身代码的情况下，通过从现有的类中继承其属性和方法。
继承最基本的作用就是使得代码课重用，增加软件的可扩充性。
2、语法：访问修饰符 class 子类名 extends 父类名{}3、注意：●子类不能继承父类的构造方法、private成员和子类与父类不同包且使用默认访问权限的成员。
●每个类只能有一个直接父类。
4、特点：●可以继承public和protected修饰的属性和方法，不论子类和父类是否在同一个包里。
●可以继承默认访问修饰符修饰的属性和方法，但是子类和父类必须在同一个包里●无法继承父类的构造方法（可以通过super关键字调用，且调用时必须是子类构造方法的第一句）。
●继承表达的是“**is a**”的关系。
●可以使用super关键字调用父类成员：super只能出现在子类的方法和构造方法中，可以访问父类的属性、方法、构造方法；●继承是多态的基础，没有继承就没有多态。
5、补充：访问修饰符本类同包子类其他private √默认的（Friendly）√√protected √√√public √√√√注：protected：不同包中只有实例化子类的对象可以调用protected成员。
6、实例化子类对象●子类在实例化时，会首先执行其父类的构造方法，然后才执行子类的构造方法。
●一个类的构造方法在两种情况中总是会执行：创建该类的对象和创建该类的子类的对象。
●子类继承父类时构造方法的调用规则：如果子类的构造方法中没有通过super调用父类的有参构造方法，也没有通过this调用自身的其他构造方法，则系统会默认先调用父类的无参构造方法。
如果子类的构造方法中通过super调用父类的构造方法，那么将执行父类相应的构造方法。
如果子类的构造方法中通过this调用自身的其他构造方法，在相应构造方法中应用以上两条规则。
7、方法的重写如果从父类继承的方法不能满足子类的需求，可以在子类中对父类的同名方法进行重写即覆盖。
实验报告二 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方法产生随机数。 类图：
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)。
实验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) { = 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) { = 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","无效日期",RMATION_MESSAGE);break;}}catch (Exception e1) {// TODO: handle exceptionJOptionPane.showMessageDialog(null, "您输入的不是整数","无效日期",RMA TION_MESSAGE);}}}}public void keyReleased(KeyEvent e) {}public void keyTyped(KeyEvent e) {}}2.编译运行五、实验结果●实验内容一结果：●实验内容二结果：●实验内容三结果：六、实验小结1.这次实验的内容比较多，需要掌握Java的类和对象的声明和使用方法、Java的类的继承和实现方法、多态性在类的继承中的运用、接口的定义与使用、基本异常的处理机制、try语句与catch语句的搭配使用等等；2. 在实验过程中，重点是要区分好实例和类，灵活掌握类的调用。