java实验报告——继承与接口
005-实验五 继承和接口(实验报告内容)
实验五继承和接口（实验报告）一、目的1．掌握Java语言继承机制。
二、实验内容定义一个超类，定义一个子类，实例化子类对象，调用超类的属性和方法，体会继承机制。
三、实验环境JDK1.6+dos环境四、实验原理1．继承机制五、实验步骤1、定义一个Person类，有属性姓名，年龄，性别。
Person具有吃饭，睡觉的行为。
定义一个Student类继承Person类，Student具有学习，看书的行为。
定义一个接口，能够输出自己的基本信息。
完成所设计的类的测试。
class Person{private String name;private int age;private String sex;public void setName( String name){ =name;}public String getName( ){return name;}public void setAge( int age){this.age=age;}public int getAge( ){return age ;}public void setSex( String sex){this.sex=sex;}public String getSex( ){return sex;}public void tell01(){System.out.println("会吃饭，能睡觉"); }public void tell02(){System.out.println("姓名:"+this.getName()+"性别:"+this.getSex()+"年龄:"+this.getAge());}}interface A{public void print01();public void print02();}class Student extends Person implements A{private int number;public void setNumber(int number){this.number=number;}public int getNumber( ){return number;}public void tell03(){System.out.println("姓名:"+this.getName()+"\n性别:"+this.getSex()+"\n年龄:"+this.getAge()+"\n学号:"+this.getNumber());}public void tell04(){System.out.println("爱学习，喜欢看书");}public void print01(){System.out.println("巴黎下着小雨!!!");}public void print02(){System.out.println("吉大正在飚雨!!!");}}public class mytest01{public static void main(String args[]){Student stu = new Student();stu.setName("张三");stu.setAge(20);stu.setSex("男");stu.setNumber(2011);stu.tell01();stu.tell03();stu.tell04();stu.print01();stu.print02();}}六、实验小结。
java实验报告 类的继承
java实验报告类的继承一、实验目的1、深入理解 Java 中类的继承概念和机制。
2、掌握通过继承实现代码复用和功能扩展。
3、学会使用 super 关键字和方法重写。
二、实验环境1、操作系统：Windows 102、开发工具：Eclipse 或 IntelliJ IDEA三、实验内容1、创建一个父类｀Animal`包含属性：｀name`（字符串类型），｀age`（整数类型）包含方法：｀eat(）｀（打印出动物正在吃东西），｀sleep(）｀（打印出动物正在睡觉）2、创建子类｀Dog` 继承自｀Animal`新增属性：｀breed`（字符串类型，表示狗的品种）重写父类的｀eat(）｀方法，打印出狗吃东西的特有方式新增方法：｀bark(）｀（打印出狗在叫）3、创建子类｀Cat` 继承自｀Animal`新增属性：｀color`（字符串类型，表示猫的颜色）重写父类的｀sleep(）｀方法，打印出猫睡觉的特有姿势新增方法：｀meow(）｀（打印出猫在叫）四、实验步骤1、在 Java 项目中创建一个名为｀Animal` 的类：｀｀｀javapublic class Animal ｛private String name;private int age;public Animal(String name, int age) ｛thisname ＝ name;thisage ＝ age;｝public void eat(）｛Systemoutprintln(name ＋＂ is eating＂）；｝public void sleep(）｛Systemoutprintln(name ＋＂ is sleeping＂）；｝｝｀｀｀2、创建一个名为｀Dog` 的类继承自｀Animal`：｀｀｀javapublic class Dog extends Animal ｛private String breed;public Dog(String name, int age, String breed) ｛super(name, age)；thisbreed ＝ breed;｝＠Overridepublic void eat(）｛Systemoutprintln(supergetName(）＋＂ the ＂＋ breed ＋＂ dog is eating greedily＂）；｝public void bark(）｛｝｝｀｀｀3、创建一个名为｀Cat` 的类继承自｀Animal`：｀｀｀javapublic class Cat extends Animal ｛private String color;public Cat(String name, int age, String color) ｛super(name, age)；thiscolor ＝ color;｝＠Overridepublic void sleep(）｛Systemoutprintln(supergetName(）＋＂ the ＂＋ color ＋＂ cat is sleeping curled up＂）；｝public void meow(）｛｝｝｀｀｀4、在｀Main` 类中进行测试：｀｀｀javapublic class Main ｛public static void main(String args) ｛Dog dog ＝ new Dog(＂Buddy"， 3, ＂Labrador"）；dogeat(）；dogbark(）；dogsleep(）；Cat cat ＝ new Cat(＂Mimi"， 2, ＂White"）；cateat(）；catsleep(）；catmeow(）；｝｝｀｀｀五、实验结果1、运行｀Main` 类后，输出结果如下：｀Buddy the Labrador dog is eating greedily｀｀Buddy is barking｀｀Buddy is sleeping｀｀Mimi is eating｀｀Mimi the White cat is sleeping curled up｀｀Mimi is meowing｀2、可以看到，子类｀Dog` 重写了父类｀Animal` 的｀eat(）｀方法，展示了狗特有的吃东西方式；子类｀Cat` 重写了父类的｀sleep(）｀方法，展示了猫特有的睡觉姿势。
java实验报告——继承与接口
南京理工大学泰州科技学院实验报告书课程名称：《Java 面向对象程序设计》实验题目：实验四继承与接口班级：09计算机(2)学号：0909030218姓名：尤源指导教师：李丛一、实验目的1.掌握Java语言的类的继承的概念。
2.掌握Java语言中抽象类的使用。
3.掌握Java语言中接口的使用4.掌握eclipse集成开发环境的使用。
二、实验内容1.类的继承，具体要求如下：(1)定义一Person类，该类具有属性人名、年龄、身份证号等信息以及将属性信息作为字符串返回的一方法；(2)定义一Student类，让该类继承Person类，该类除了具有属性人名、年龄、身份证号等信息以外还有学号，所在学校等信息；该类也具有将属性信息作为字符串返回的一方法；(3)编写测试类，测试这两个类2.定义一个动物抽象类Animal,该类有一个抽象的方法cry()；定义一个小猫类Cat,该类继承了Animal类并实现了cry()方法，当调用cry()方法时打印“小猫喵喵叫”，定义一个小狗类Dog,该类也继承了Animal类并实现了cry()方法，当调用cry()方法时打印“小狗汪汪叫”。
3. 接口的运用。
定义一接口接口名叫Usb,该接口声明了两个方法分别为start()和stop()方法，定义一U 盘类UsbDiskWriter，一照相机类Camera、一手机类Mobile，让它们都实现该接口。
三、实验步骤实验（1）编写代码实验（2）编写代码实验（3）编写代码四、实验结果实验（1）运行结果实验（2）运行结果实验（3）运行结果五、结果分析1. 子类若想调用父类的构造函数必须要用super关键字。
2.接口体中只能运用抽象类。
3.在同一个java文件中只能在入口函数的类中用public。
Java实验3 继承与接口
实验3 继承与接口[实验目的]1、掌握java 继承中父类及其子类的定义方法。
2、掌握子类重写父类同名方法的方法。
3、掌握接口的用法。
[实验要求]1、复习理论教学中所学的内容。
2、认真进行实验预习，查阅参考书，书写源程序，书写实验预习报告。
3、认真总结实验并书写实验报告。
[实验课时] 2学时[实验教学方式] 学生上机实验，教师随堂指导。
[实验内容]1、定义父类People，分别定义People类的子类ChinaPeople，AmericanPeople和BeijingPeople 并分别重写父类中的各个方法。
最后在主方法中分别创建各子类的对象并调用各自的方法打印输出信息。
该程序的模板代码如下：请将其补充完整并调试运行。
class People{protected double weight,height;public void speakHello(){System.out.println("yayawawa");}public void averageHeight(){height=173;System.out.println("average height:"+height);}public void averageWeight(){weight=70;System.out.println("average weight:"+weight);}}class ChinaPeople extends People{【代码1】 //重写public void speakHello()方法，要求输出类似“你好，吃了吗”这样的//汉语信息【代码2】 //重写public void averageHeight()方法，要求输出类似//“中国人的平均身高：168.78厘米”这样的汉语信息【代码3】 //重写public void averageWeight()方法，//要求输出类似“中国人的平均体重：65公斤”这样的汉语信息public void chinaGongfu(){【代码4】//输出中国武术的信息，例如："坐如钟,站如松,睡如弓"等}}class AmericanPeople extends People{【代码5】 //重写public void speakHello()方法，要求输出类似//“How do you do”这样的英语信息。
Java实验报告四继承与接口
南昌航空大学实验报告2019 年 4 月 4 日课程名称：Java语言程序设计A 实验名称：继承与接口班级：学生姓名：学号：指导教师评定：签名：一、实验目的1.掌握Java语言的类的继承的概念。
2.掌握Java语言中抽象类的使用。
3.掌握Java语言中接口的使用4.掌握eclipse集成开发环境的使用二、实验内容(1)定义一Person类，该类具有属性人名、年龄、身份证号等信息以及将属性信息作为字符串返回的方法。
(2)定义一Student类，让该类继承Person类，该类除了具有属性人名、年龄、身份证号等信息以外还有学号，所在学校等信息；该类也具有将属性信息作为字符串返回的方法。
(3)编写测试类，测试这两个类三、实验过程实验代码如下：package shiyan;class Person{ //定义Person类private String name;private int age;private String idno;public Person() {}public Person(String name,int age,String idno) {=name;this.age=age;this.idno=idno;}public String getName() { //取得name属性return name;}public void setName(String name) { //设置name属性=name;}public int getAge() { //取得age属性return age;}public void setAge(int age) { //设置age属性this.age=age;}public String getIdno() { //取得idno属性return idno;}public void setIdno(String idno) { //设置idno属性this.idno=idno;}public String getInfo() { //取得信息抽象方法return" 姓名: "+getName()+" 年龄: "+getAge()+" 身份证号:"+getIdno();}}class Student1 extends Person { //Student1是Person的子类private String school; //定义两个私有属性private int sNo;public String getSchool() { //取得school属性return school;}public void setSchool(String school) { //设置school属性this.school=school;}public int getSNo() { //取得sNo属性return sNo;}public void setSNo(int sNo) { //设置sNo属性this.sNo=sNo;}public String getInfo() { //取得信息抽象方法return" 姓名: "+getName()+" 年龄: "+getAge()+" 身份证号:"+getIdno()+" 学校: "+getSchool()+" 学号: "+getSNo();}}public class Detect { //测试类public static void main(String[] args) {Person p=new Person("王五",20,"362204************"); //实例化Person对象System.out.println(p.getInfo()); //输出P的信息Student1 s=new Student1(); //实例化Student1对象s.setName("和二");s.setAge(20);s.setIdno("362204************");s.setSchool("南昌航空大学");s.setSNo(10001);System.out.println(s.getInfo()); //输出S的信息}}四、实验结果五、实验分析JAVA的继承与C++类似，掌握了继承，便可以通过继承父类方法增强功能的灵活性，而且可以减少代码量。
java类的继承实验报告
java类的继承实验报告Java类的继承实验报告引言：在面向对象的编程语言中，继承是一种重要的概念。
Java作为一种面向对象的编程语言，也提供了类的继承机制。
本实验旨在通过编写Java程序，深入理解和掌握Java类的继承。
实验目的：1. 理解继承的概念和原理；2. 掌握Java中类的继承的语法和用法；3. 实践继承的实际应用。
实验过程：1. 创建父类和子类在实验中，我们首先创建一个父类和一个子类。
父类可以是一个基本的类，子类则继承了父类的属性和方法。
这样，子类就可以在不改变父类的基础上，扩展自己的功能。
2. 继承的语法和用法Java中，使用关键字"extends"来实现类的继承。
子类通过继承父类，可以获得父类的属性和方法，并且可以在子类中添加新的属性和方法。
在实验中，我们可以通过创建子类对象，并调用继承自父类的方法来验证继承的正确性。
3. 方法的重写在继承中，子类可以重写父类的方法。
这样，当子类调用该方法时，实际上执行的是子类重写后的方法。
通过方法的重写，我们可以实现多态性的效果。
4. 实际应用在实验中，我们可以选择一个具体的应用场景，例如动物类的继承。
我们可以创建一个父类Animal，包含基本的属性和方法，然后创建子类Dog和Cat，分别继承Animal类，并添加自己的特有属性和方法。
通过这个实例，我们可以更好地理解继承的实际应用。
实验结果：通过实验，我们成功地创建了父类和子类，并验证了继承的正确性。
我们还成功地重写了父类的方法，实现了多态性的效果。
最后，我们还通过实际应用的例子，更好地理解了继承的实际应用。
实验总结：通过本次实验，我们深入理解和掌握了Java类的继承。
继承是面向对象编程中的重要概念，通过继承，我们可以实现代码的重用和扩展。
在实际应用中，继承也可以帮助我们更好地组织代码，提高代码的可读性和可维护性。
然而，继承也有一些限制和注意事项。
首先，Java中只支持单继承，即一个子类只能继承一个父类。
梳理java中继承与接口的关系,并举例说明用途。
一、引言在面向对象的编程语言中，继承和接口是两个重要的概念。
在Java中，继承和接口的关系是非常紧密的，它们对于构建灵活而强大的代码结构至关重要。
本文将对Java中继承与接口的关系进行梳理，并通过实际的例子来说明它们的用途。
二、继承与接口的概念1. 继承的概念继承是面向对象编程中的重要特性，它允许一个类（子类）继承另一个类（父类）的属性和方法。
子类可以继承父类的属性和方法，也可以重写父类的方法，从而实现代码的复用和扩展。
2. 接口的概念接口是一种抽象的数据类型，它定义了一个类所具有的方法，但不包括方法的具体实现。
类可以实现一个或多个接口，从而拥有接口中定义的方法。
接口可以帮助我们实现多重继承，提高代码的灵活性。
三、继承与接口的关系1. 继承与接口的相似之处继承和接口都可以实现代码的复用和扩展，它们都允许子类或实现类使用父类或接口的属性和方法。
2. 继承与接口的区别（1）继承是一种类与类之间的关系，它可以帮助我们构建类的层次结构，从而实现代码的复用。
而接口是一种约定，它定义了一组方法的规范，所有实现了该接口的类都必须实现这些方法。
（2）一个类只能继承一个父类，但是可以实现多个接口。
3. 继承与接口的关系在Java中，一个类既可以继承一个父类，又可以实现多个接口。
这种灵活的设计可以帮助我们构建更加强大和灵活的代码结构。
四、继承与接口的实际用途1. 继承的用途（1）代码复用：通过继承，子类可以直接使用父类的属性和方法，从而减少代码的重复编写。
（2）代码扩展：通过继承，子类可以重写父类的方法，从而实现对方法的灵活扩展。
例子：```class Animal {void sound(){System.out.println("动物发出叫声");}}class Dog extends Animal {void sound(){System.out.println("狗汪汪叫");}}```2. 接口的用途（1）实现多重继承：通过实现多个接口，一个类可以拥有多个接口中定义的方法。
Java继承与接口
实验四Java继承与接口一．实验目的1）理解继承原理与机制及类继承的声明方法2）掌握掌握成员变量的隐藏及方法的重写3）掌握抽象类与抽象方法4）掌握super关键字5）掌握final关键字6）理解多态的内涵及实现代码7）掌握4种访问修饰符的区别8）掌握接口声明及使用二．实验环境JDK1.6+Eclpise3.2三．实验准备1）复习课件中理论知识2）练习课堂所讲的例子四．实验内容1、编写一个Java应用程序，除了主类（TestOne）外，该程序中还有3个类：People、ChinaPeople和AmericanPeople。
该程序具体要求如下：1）People类有public void speakHello()、public void averageHeight() 和public void averageWeight()方法。
2）ChinaPeople类是People的子类，新增了public void chinaGongfu()方法。
要求ChinaPeople重写父类的public void speakHello()、public void averageHeight()和public void averageWeight()方法。
3）AmericanPeople类是People的子类，新增public void americanBoxing()方法。
要求AmericanPeople重写父类的public void speakHello()、public void averageHeight()和public void averageWeight()方法。
4）在TestOne类的主方法中分别创建各子类的对象并调用各自的方法打印输出信息。
实验过程：1）People类有public void speakHello()、public void averageHeight()和public void averageWeight()方法。
继承和接口的实验报告
深圳大学实验报告课程名称：JA V A程序设计实验项目名称：继承和接口学院：计算机与软件学院专业：指导教师：**报告人：侯锦辉学号：********** 班级：01 实验时间：2016-10-11实验报告提交时间：2016.10.22教务处制一、实验目的（1）理解继承的概念，掌握继承的语法；（2）学习定义和使用子类；（3）学习定义和使用抽象类；（4）学习定义和使用接口；（5）学习实现接口；（6）掌握继承过程中的方法覆盖，区分它与方法重载的不同；（7）掌握如何利用接口间接实现多重继承；（8）掌握对象类型之间的转换规则；（9）掌握多态与动态绑定。
二、实验内容本次实验内容有两题：第一题：（1）编写图形接口Shape，该接口包含一个常量pi（pi=3.14）和三个抽象方法：一个是getCircumference()，功能为求图形的周长；一个是getArea()，功能为求图形的面积；一个是getShapeName()，功能为返回图形的名称。
（2）编写类Show，该类有一个方法：printShape(Shape sh)，功能为输出图形参数sh的名称、周长和面积。
（3）编写Show的两个子类，一个是圆形类Circle，另一个是矩形类Rectangle，要求这两个类都要实现图形接口Shape。
Circle类有一个成员变量：radius（圆的半径）；Rectangle类有两个成员变量：height（长方形的高）和width（长方形的宽）。
并且，Rectangle类包含一个内部类JudgeSquare，它有一个方法judge()，判断这个长方形是否为一个正方形，并输出判断结果。
（4）编写测试类Test，生成一个Circle对象和两个Rectangle对象（一个为长方形，一个为正方形），三个对象分别调用父类的printShape方法，输出各自的周长和面积；其中Rectangle 对象还要调用内部类JudgeSquare的方法judge来判断自己是否为正方形；输出结果类似如下所示：（提示：实现一个接口的类的对象，可利用接口回调直接赋值给接口，和上转型类似（子类对象可直接赋值给父类对象））第二题：请设计3个类，分别是学生类Student，本科生类Undergraduate，研究生类Postgraduate，其中Student类是一个抽象类，它包含一些基本的学生信息，如姓名、类别（本科生还是研究生）、所学课程（这里假定为3门课，用一维数组表示）成绩和成绩等级等，而Undergraduate 类和Postgraduate都是Student类的子类，它们之间的主要差别是计算3门课程平均成绩等级的方法有所不同，研究生的标准要比本科生的标准高一些，如下表所示：80~100 优秀90~100 优秀70~80 良好80~90 良好60~70 一般70~80 一般50~60 及格60~70 及格50以下不及格60以下不及格假设某班级里既有本科生（3个）也有研究生（2个），请编写程序统计全班学生的成绩等级并显示出来。
java实验,继承与接口
一、实验目的与要求实验目的：1、掌握类的继承关系。
2、掌握接口的定义与使用。
实验要求：按下列要求编写Java程序：1、定义接口Printx，其中包括一个方法printMyWay()，这个方法没有形参，返回值为空。
2、编写矩形类，矩形类要求实现Printx接口，有求面积、求周长的方法，printMyWay()方法要能显示矩形的边长、面积和周长。
3、编写正方形类作为矩形类的子类，正方形类继承了矩形类求面积和周长的方法，新增加求对角线长的方法，重写printMyWay()方法，要求该方法能显示正方形的边长、面积、周长和对角线长。
二、实验方案/** To change this template, choose Tools | Templates* and open the template in the editor.*/package 继承与接口;interface Printx{void printMyWay();}class rectangle implements Printx{double length = 0,wide=0;public rectangle(double l, double w){length=l;wide=w;}double area(){double area = length * wide;return area;}double peritemer(){double peritemer=(length+wide)*2;return peritemer;}public void printMyWay(){System.out.println("长方形边长是:"+length+" "+wide);System.out.println("长方形面积是:"+area());System.out.println("长方形周长是:"+peritemer());}}class square extends rectangle{public square(double l,double w){super(l,w);}double diagonal(){return Math.sqrt(length*length*2);}@Overridepublic void printMyWay(){System.out.println("正方形边长是:"+length);System.out.println("正方形面积是:"+area());System.out.println("正方形周长是:"+peritemer());System.out.println("正方形的对角线长是:"+diagonal());}}public class Main{static double length = 0,wide=0;public static void main(String[] args) {rectangle a=new rectangle(8,4);square b=new square(6,6);a.printMyWay();b.printMyWay();// TODO code application logic here}}三、实验结果和数据处理将长方形的长和宽设置为8和4，正方形边长设置为6，输出结果如下:四、结论接口是Java实现部分多继承功能的体现。
继承与接口实验报告
继承与接口实验报告实验名称：继承与接口实验实验目的：通过编写一个Java程序，探究继承与接口的相关概念、特点和应用。
实验过程：在实验过程中，我们创建了一个Java程序，包含了多个类和接口，用于说明继承和接口的相关概念和应用。
其中，类之间的继承关系如下所示：``` Animal ├── Mammal │ ├── Cat │ └── Dog └── Reptile └── Snake ```注：以上为继承关系图，箭头指向父类/超类。
在该程序中，所有的动物（Animal）都有以下属性：- 名称（name） - 年龄（age）除此之外，猫（Cat）、狗（Dog）和蛇（Snake）都有自己的属性和方法。
其中，猫和狗都是哺乳动物（Mammal），而蛇是爬行动物（Reptile）。
我们使用了两个接口，分别是：- 可以发声的（Soundable） - 可以移动的（Movable）这两个接口分别定义了两个方法：发声（makeSound）和移动（move）。
在这些类和接口的基础上，我们编写了一个测试类（TestAnimals），测试了每个类和接口的功能。
实验结果：- Animal类：Animal类是所有动物的“祖先”类，它包含了所有动物共有的属性。
- Mammal类：Mammal类是哺乳动物的基类，它包含了所有哺乳动物共有的属性和方法。
- Reptile类：Reptile类是爬行动物的基类，它包含了所有爬行动物共有的属性和方法。
- Cat类：Cat类继承了Mammal类，它包含了猫的属性和方法。
- Dog类：Dog类继承了Mammal类，它包含了狗的属性和方法。
- Snake类：Snake类继承了Reptile类，它包含了蛇的属性和方法。
- Soundable接口：Soundable接口定义了makeSound 方法，用于让实现了该接口的类发出声音。
- Movable接口：Movable接口定义了move方法，用于让实现了该接口的类移动。
继承与接口实验报告
继承与接口实验报告本次实验主要涉及到Java中的继承和接口的使用。
通过实验，我们可以更好地理解和掌握继承和接口的概念、特点和使用方法。
实验步骤：1. 创建一个父类Animal，其中包含成员变量name和age，以及方法eat()和sleep()。
2. 创建两个子类Cat和Dog，它们分别继承自Animal类，并分别实现自己的eat()和sleep()方法。
3. 创建一个接口Swim，其中包含一个swim()方法。
4. 在Dog类中实现Swim接口，并实现swim()方法。
5. 创建一个测试类Test，其中包含main()方法。
在main()方法中，创建一个Cat对象和一个Dog对象，并分别调用它们的eat()和sleep()方法。
6. 在main()方法中，创建一个Swim类型的变量s，将Dog对象赋值给它，并调用s的swim()方法。
实验结果：通过实验，我们成功地创建了Animal类和它的两个子类Cat和Dog，它们分别继承了Animal类的成员变量和方法，并实现了自己的eat()和sleep()方法。
同时，我们还创建了Swim接口，并在Dog类中实现了它。
在测试类Test中，我们成功地创建了Cat和Dog对象，并调用了它们的eat()和sleep()方法。
同时，我们还创建了一个Swim 类型的变量s，将Dog对象赋值给它，并调用了s的swim()方法。
实验结论：通过本次实验，我们深入理解了Java中的继承和接口的概念和使用方法。
其中，继承可以让子类继承父类的成员变量和方法，从而避免了重复编写代码的问题；而接口则可以让类实现共同的方法，提高代码的重用性和可维护性。
同时，我们还学会了如何在子类中实现接口，并在测试类中使用。
这些知识对于我们今后的Java程序开发将有很大的帮助。
实验5 继承与接口
实验5 继承与接口[实验目的]1、掌握java 继承中父类及其子类的定义方法。
2、掌握子类重写父类同名方法的方法。
3、掌握接口的用法。
(1) 学习如何定义接口 ;(2) 掌握接口的实现方式 ;(3) 使用实现了接口的类 ;(4) 理解接口与抽象类的区别。
[实验要求]1、复习理论教学中所学的内容。
2、认真进行实验预习，查阅参考书，书写源程序，书写实验预习报告。
3、认真总结实验并书写实验报告。
[实验课时] 2学时[实验教学方式] 学生上机实验，教师随堂指导。
[实验内容]1、类的继承性练习(一）创建将被继承的类(1) 程序源代码如下。
public class EXP5_7{protected String xm; //姓名，具有保护修饰符的成员变量protected int xh;//学号void setdata(String xm,int xh) //设置数据的方法{this.xh=xh;this.xm=xm;}public void print() //输出数据的方法{System.out.println(xm+", "+xh);}}(2) 编译源程序。
（二）创建将被继承的类(1) 程序功能：通过EXP5_7类产生子类EXP5_8，其不仅具有父类的成员变量xm（姓名）、xh（学号），还定义了新成员变量xy（学院）、bj（bj）。
在程序中调用了父类的print 方法，同时可以看出子类也具有该方法。
(2) 程序源代码如下。
class EXP5_8 extends EXP5_7{protected String xy;protected String bj;public static void main(String args[]){EXP5_7 p1 = new EXP5_7();p1.setdata("李四",12321) ;p1.print();EXP5_8 s1 = new EXP5_8() ;s1.setdata("张三",12345); //调用父类的成员方法s1.xy="山西大学计算机学院"; //访问本类的成员变量s1.bj="2008级计算机科学与技术"; //访问本类的成员变量s1.print();System.out.print(s1.xm+", "+s1.xy+", "+s1.bj);}}(1)编译并运行，结果如图5.7所示。
java实验-----接口和继承
实验五继承与接口实验目的：掌握继承机制；掌握super、this等关键字的使用实验内容:1．有一个程序如下所示。
若要输出父类成员x的值（25）如何完成？补充程序（用尽可能多的方法完成）。
class A1{int x=25;}public class Chap4 extends A1{ int x=15;public static void main(String[] args)………}提示：方法1——创建父类对象进行成员值的输出方法2——创建子类对象时，利用构造方法进行初始化，并初始化成父类成员的值方法3——定义显示方法，利用super方式输出2．有一个类定义如下：class Mankind{char sex;int salary;public void manOrWoman(){switch(sex){case 'm':System.out.println("a man");break;case 'w':System.out.println("a woman");break;default:System.out.println("not a man or a woman");}}public void employed(int salaryValue){if(salaryValue==0) System.out.println("no job");else System.out.println("job");}}再设计一个类(Kids)，表示儿童群体。
对于每一个儿童而言：有sex和age属性；可以打印年龄；判断出是男孩、女孩在输出是否被雇佣信息时，一律打印“kids shoud study and no work”充分利用继承的关系完成程序设计，要求打印出某一个孩子的年龄、根据性别（’m’or’w’）输出“is a boy”or“is a girl”，输出雇佣情况。
Java程序设计 实验05 继承和接口
实验51、实验名称：继承和接口2、实验班级：软件08013、指导老师：陈欲勐4、实验环境4.1 实验室：教学楼68084.2 软件环境：win2000 Server，Eclipse 3.2,JDK 1.5/1.65、实验目的1.掌握继承的概念，以及子类对象的创建、成员变量的继承/隐藏,还有方法的继承和重写。
2.掌握向上转型对象的使用；3.掌握接口回调技术；6、实验任务6.1 提高性实验任务完成实验指导教材中的相关实验任务（源代码可以参照补充资料“实验指导_习题解答”）1.实验 1 继承（源程序在所提供的包chap4.exercise2下的文件TestInheritance.java，正确程序在所提供的包chap4.exercise下的文件TestInheritance.java）2.实验2 向上转型对象（源程序在所提供的包chap4.exercise2下的文件TestUpcast.java，正确程序在所提供的包chap4.exercise下的文件TestUpcast.java）3.实验 3 接口回调（源程序在所提供的包chap4.exercise2下的文件TestInterface.java，正确程序在所提供的包chap4.exercise下的文件TestInterface.java）6.2 验证性实验任务对教材中的相关例子在Eclipse开发平台中进行验证（源代码可以参照补充资料“教材源代码”）：1.第4章中的例子，在包chap4.example中。
1)Example4_19相关知识点:向上转型；2)Example4_20相关知识点:多态；3)Example4_21和 Example4_22相关知识点:抽象类和抽象方法；4)Example4_23和 Example4_24相关知识点:super关键字；5)Example4_24和 Example4_25相关知识点:接口的定义和实现；6)Example4_25和 Example4_26相关知识点:接口回调；7)Example4_33相关知识点:异常类；8)Example4_34相关知识点:自定义异常类；9)Example4_35相关知识点:Class类；7、思考题1.什么是继承？不同的访问限定符（如public）所定义的属性或方法，都能被继承么，哪些能继承哪些不能不被继承？2.什么是多态？3.什么是向上转型？为什么要使用向上转型；向上转型在抽象类和接口中的定义和使用是如何实现的？。
继承与接口实验
继承与接⼝实验深圳⼤学实验报告课程名称：Java实验序号：实验2实验名称：继承与接⼝班级：计算机3 姓名：卢志敏同组⼈：实验⽇期：2008 年11 ⽉16 ⽇教师签字：⼀、实验⽬的1.继承●⼦类的继承性●⼦类对象的创建过程●成员变量的继承与隐藏●⽅法的继承与重写2.上转型对象掌握上转型对象的使⽤3.接⼝回调掌握接⼝回调技术⼆、实验环境JDK1.5 Winxp三、实验步骤与⽅法实验1编写⼀个Java应⽤程序，除了主类外，该程序中还有4个类：People、ChinaPeople、AmericanPeople类。
该程序具体要求如下：●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是ChinaPelple的⼦类，新增public void beijingOpera()⽅法。
要求ChinaPeople重写⽗类的public void speakHello()、public void averageHeight()和public void averageWeight()⽅法。
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) {
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，然后显示其面积、周长、颜色以及是否被填充。
java上机实践继承与接口
java上机实践继承与接口继承与接口是Java语言中的两个重要概念，也是面向对象编程的核心特性之一。
在Java中，继承和接口的使用可以帮助我们实现代码的重用和扩展，提高程序的灵活性和可维护性。
本文将从继承和接口的概念入手，详细介绍它们的特点和使用方法。
一、继承继承是面向对象编程中的一种机制，通过继承，子类可以继承父类的属性和方法，并可以在此基础上进行扩展或修改。
在Java中，使用关键字extends来实现类的继承关系。
1. 单继承Java中，一个类只能继承自一个父类，这种继承方式称为单继承。
单继承可以使类的层次结构更加清晰，避免了多继承可能带来的复杂性和歧义性。
2. 继承的特点继承具有以下几个特点：（1）子类继承了父类的属性和方法，可以直接使用父类中的代码；（2）子类可以在继承的基础上添加新的属性和方法，实现代码的扩展；（3）子类可以重写父类的方法，实现对父类行为的修改；（4）子类可以通过super关键字调用父类的构造方法；（5）子类的对象可以赋值给父类的引用。
3. 继承的示例下面通过一个简单的示例来说明继承的使用。
假设有一个父类Animal，有一个子类Dog继承自Animal，代码如下：```javaclass Animal {protected String name;public Animal(String name) { = name;}public void eat() {System.out.println(name + " is eating");}}class Dog extends Animal {public Dog(String name) {super(name);}public void bark() {System.out.println(name + " is barking");}}public class Main {public static void main(String[] args) {Dog dog = new Dog("Tom");dog.eat();dog.bark();}}```在上述示例中，Animal是一个父类，Dog是它的子类。
java类的继承实验报告
java类的继承实验报告Java类的继承实验报告引言：在面向对象的编程语言中，继承是一种重要的概念。
Java作为一门面向对象的编程语言，也支持类的继承。
本篇实验报告将介绍Java类的继承的基本概念、语法以及实际应用。
一、继承的基本概念继承是指一个类可以派生出另一个类，被派生出的类称为子类，派生出子类的类称为父类。
子类可以继承父类的属性和方法，并且可以在此基础上进行扩展或修改。
继承的关系可以形成类的层次结构，使得代码的复用性和可维护性得到提高。
二、继承的语法在Java中，使用关键字"extends"来实现类的继承关系。
子类通过继承父类来获得父类的属性和方法。
语法格式如下：```javaclass 子类名 extends 父类名 {// 子类的成员变量和方法}```在子类中可以重写父类的方法，以实现自己的逻辑。
使用关键字"super"可以调用父类的构造方法和成员变量。
三、继承的实际应用1. 代码复用继承的一个主要优势是可以实现代码的复用。
子类可以继承父类的属性和方法，避免了重复编写相同的代码。
例如，假设有一个父类"Animal"，子类"Dog"和"Cat"可以继承父类的一些通用属性和方法，如"eat()"和"sleep()"。
2. 多态性继承也为多态性的实现提供了基础。
多态性是指一个对象可以根据不同的类型表现出不同的行为。
通过继承，可以将不同的子类对象赋给父类引用，实现对不同子类对象的统一操作。
例如，有一个父类"Shape"，子类"Circle"和"Rectangle"可以继承父类的方法"draw()"，并在自己的类中实现具体的绘制逻辑。
通过将子类对象赋给父类引用，可以统一调用"draw()"方法，实现对不同形状的绘制。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
成绩：面向对象原理与Java实践课程实验报告实验2：继承与接口姓名 ____班级 ____学号 ____实验地点 ____实验时间 ____指导教师 ____一、实验目的：●掌握类的继承机制，掌握成员变量的隐藏与方法的重写●掌握接口的定义和实现方法二、实验要求：●复习类的继承以及接口的设计方法●注意保证类的封装性●编写程序完成以下实验内容并上交实验报告三、实验内容：1、P153：习题42、P153：习题53、P153：习题64、在程序包packageOne中编写至少含一个方法的公有接口InterfaceOne。
在程序包packageTwo中定义公有类SuperClass，该类含有一个受保护的内部类InnerClass，这个类实现接口InterfaceOne。
在程序包packageThree中定义公有类SubClass继承SuperClass，类SubClass 定义一个返回类型为InterfaceOne的方法返回内部类InnerClass的对象实例。
请正确使用程序包组织以上类和接口，编译并运行，并观察编译器生成的字节码文件的命名方式。
四、设计思路：习题4的设计思路是设计一个抽象类作为父类，并设计相关字段以及计算成绩等级的抽象方法，然后再设计本科生类和研究生类作为子类继承，并且各自实现其计算成绩等级的抽象方法，最终将结果输出。
习题5的设计思路跟习题4相同，只需额外设计一个枚举类存储学生的成绩等级，并对相关代码作少许修改即可。
习题6的设计思路是习题4的延伸，在习题4的类结构基础上，将原来的计算成绩等级的抽象方法提取出来，放在一个公有接口中，然后再分别设计计算本科生和研究生成绩等级的类实现接口的抽象方法。
五、程序源代码：习题4的源代码：package Package_4;public abstract class Student{String Name="";String Stu_type="";int C_score;int English_score;int Java_score;int score;String sco_Level="";public Student(String name,String stu_type,int sco1,int sco2,int sco3){Name=name;Stu_type=stu_type;C_score=sco1;English_score=sco2;Java_score=sco3;score=(sco1+sco2+sco3)/3;}}package Package_4;public class Undergraduate extends Student{public Undergraduate(String name,String stu_type,int sco1,int sco2,int sco3) {super(name,stu_type,sco1,sco2,sco3);if(score>=85&score<=100){sco_Level="优秀";}else if(score>=75&score<85){sco_Level="良好";}else if(score>=65&score<75){sco_Level="中等";}else if(score>=60&score<65){sco_Level="及格";}else if(score>=0&score<60){sco_Level="不及格";}else{sco_Level="未知等级";}}static void Output(Undergraduate[] udg){System.out.println("**********本科生**********");// System.out.println("————");System.out.print("姓名");System.out.print('\t'+"学生类型");System.out.print('\t'+"C语言成绩");System.out.print('\t'+"英语成绩");System.out.print('\t'+"Java成绩");System.out.print('\t'+"平均分");System.out.println('\t'+"成绩等级");for(int i=0; i<udg.length;i++){System.out.print(udg[i].Name);System.out.print('\t'+udg[i].Stu_type);System.out.print('\t'+String.valueOf(udg[i].C_score));System.out.print('\t'+String.valueOf(udg[i].English_score));System.out.print('\t'+String.valueOf(udg[i].Java_score));System.out.print('\t'+String.valueOf(udg[i].score));System.out.println('\t'+udg[i].sco_Level);}System.out.println();}}package Package_4;public class Postgraduate extends Student{public Postgraduate(String name,String stu_type,int sco1,int sco2,int sco3) {super(name,stu_type,sco1,sco2,sco3);if(score>=90&score<=100){sco_Level="优秀";}else if(score>=80&score<90){sco_Level="良好";}else if(score>=70&score<80){sco_Level="中等";}else if(score>=60&score<70){sco_Level="及格";}else if(score>=0&score<60){sco_Level="不及格";}else{sco_Level="未知等级";}}static void Output(Postgraduate[] pg){System.out.println("**********研究生**********");// System.out.println("————");System.out.print("姓名");System.out.print('\t'+"学生类型");System.out.print('\t'+"C语言成绩");System.out.print('\t'+"英语成绩");System.out.print('\t'+"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();}}package Package_4;public class Test{public static void main(String[] args){Undergraduate[] udg=new Undergraduate[5];udg[0]=new Undergraduate("小明","本科生",80,95,79);udg[1]=new Undergraduate("小红","本科生",60,82,76);udg[2]=new Undergraduate("小白","本科生",90,49,67);udg[3]=new Undergraduate("小黑","本科生",56,74,65);udg[4]=new Undergraduate("小军","本科生",68,81,84);Postgraduate[] pg=new Postgraduate[5];pg[0]=new Postgraduate("小明","研究生",80,95,79);pg[1]=new Postgraduate("小红","研究生",60,82,76);pg[2]=new Postgraduate("小白","研究生",90,49,67);pg[3]=new Postgraduate("小黑","研究生",56,74,65);pg[4]=new Postgraduate("小军","研究生",68,81,84);Undergraduate.Output(udg);Postgraduate.Output(pg);}}习题5的源代码：package Package_5;public enum Sco_Level{A("优秀"),B("良好"),C("中等"),D("及格"),E("不及格"),X("未知等级");private String signal;Sco_Level(String level){this.signal=level;}public String getSignal(){return signal;}}package Package_5;public abstract class Student{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) {Name=name;Stu_type=stu_type;C_score=sco1;English_score=sco2;Java_score=sco3;score=(sco1+sco2+sco3)/3;}}package Package_5;public class Undergraduate extends Student{public Undergraduate(String name,String stu_type,int sco1,int sco2,int sco3) {super(name,stu_type,sco1,sco2,sco3);if(score>=85&score<=100){sco_Level=Sco_Level.A;}else if(score>=75&score<85){sco_Level=Sco_Level.B;}else if(score>=65&score<75){sco_Level=Sco_Level.C;}else if(score>=60&score<65){sco_Level=Sco_Level.D;}else if(score>=0&score<60){sco_Level=Sco_Level.E;}else{sco_Level=Sco_Level.X;}}static void Output(Undergraduate[] udg){System.out.println("**********本科生**********");// System.out.println("————");System.out.print("姓名");System.out.print('\t'+"学生类型");System.out.print('\t'+"C语言成绩");System.out.print('\t'+"英语成绩");System.out.print('\t'+"Java成绩");System.out.print('\t'+"平均分");System.out.println('\t'+"成绩等级");for(int i=0; i<udg.length;i++){System.out.print(udg[i].Name);System.out.print('\t'+udg[i].Stu_type);System.out.print('\t'+String.valueOf(udg[i].C_score));System.out.print('\t'+String.valueOf(udg[i].English_score));System.out.print('\t'+String.valueOf(udg[i].Java_score));System.out.print('\t'+String.valueOf(udg[i].score));System.out.println('\t'+udg[i].sco_Level.getSignal());}System.out.println();}}package Package_5;public class Postgraduate extends Student{public Postgraduate(String name,String stu_type,int sco1,int sco2,int sco3) {super(name,stu_type,sco1,sco2,sco3);if(score>=90&score<=100){sco_Level=Sco_Level.A;}else if(score>=80&score<90){sco_Level=Sco_Level.B;}else if(score>=70&score<80){sco_Level=Sco_Level.C;}else if(score>=60&score<70){sco_Level=Sco_Level.D;}else if(score>=0&score<60){sco_Level=Sco_Level.E;}else{sco_Level=Sco_Level.X;}}static void Output(Postgraduate[] pg){System.out.println("**********研究生**********");// System.out.println("————");System.out.print("姓名");System.out.print('\t'+"学生类型");System.out.print('\t'+"C语言成绩");System.out.print('\t'+"英语成绩");System.out.print('\t'+"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.getSignal());}System.out.println();}}package Package_5;public class Test{public static void main(String[] args){Undergraduate[] udg=new Undergraduate[5];udg[0]=new Undergraduate("小明","本科生",80,95,79);udg[1]=new Undergraduate("小红","本科生",60,82,76);udg[2]=new Undergraduate("小白","本科生",90,49,67);udg[3]=new Undergraduate("小黑","本科生",56,74,65);udg[4]=new Undergraduate("小军","本科生",68,81,84);Postgraduate[] pg=new Postgraduate[5];pg[0]=new Postgraduate("小明","研究生",80,95,79);pg[1]=new Postgraduate("小红","研究生",60,82,76);pg[2]=new Postgraduate("小白","研究生",90,49,67);pg[3]=new Postgraduate("小黑","研究生",56,74,65);pg[4]=new Postgraduate("小军","研究生",68,81,84);Undergraduate.Output(udg);Postgraduate.Output(pg);}}习题6的源代码：package Package_6;public interface Sco_Level{abstract String getLevel(int score);}package Package_6;public class ugd_Level implements Sco_Level {public String getLevel(int score){String sco_Level="";if(score>=85&score<=100){sco_Level="优秀";}else if(score>=75&score<85){sco_Level="良好";}else if(score>=65&score<75){sco_Level="中等";}else if(score>=60&score<65){sco_Level="及格";}else if(score>=0&score<60){sco_Level="不及格";}else{sco_Level="未知等级";}return sco_Level;}}package Package_6;public class pg_Level implements Sco_Level{public String getLevel(int score){String sco_Level="";if(score>=90&score<=100){sco_Level="优秀";}else if(score>=80&score<90){sco_Level="良好";}else if(score>=70&score<80){sco_Level="中等";}else if(score>=60&score<70){sco_Level="及格";}else if(score>=0&score<60){sco_Level="不及格";}else{sco_Level="未知等级";}return sco_Level;}}package Package_6;public abstract class Student{String Name="";String Stu_type="";int C_score;int English_score;int Java_score;int score;String sco_Level="";public Student(String name,String stu_type,int sco1,int sco2,int sco3){Name=name;Stu_type=stu_type;C_score=sco1;English_score=sco2;Java_score=sco3;score=(sco1+sco2+sco3)/3;}}package Package_6;public class Undergraduate extends Student{public Undergraduate(String name, String stu_type, int sco1, int sco2,int sco3) {super(name, stu_type, sco1, sco2, sco3);ugd_Level ugd_level=new ugd_Level();sco_Level=ugd_level.getLevel(score);}static void Output(Undergraduate[] udg){System.out.println("**********本科生**********");// System.out.println("————");System.out.print("姓名");System.out.print('\t'+"学生类型");System.out.print('\t'+"C语言成绩");System.out.print('\t'+"英语成绩");System.out.print('\t'+"Java成绩");System.out.print('\t'+"平均分");System.out.println('\t'+"成绩等级");for(int i=0; i<udg.length;i++){System.out.print(udg[i].Name);System.out.print('\t'+udg[i].Stu_type);System.out.print('\t'+String.valueOf(udg[i].C_score));System.out.print('\t'+String.valueOf(udg[i].English_score));System.out.print('\t'+String.valueOf(udg[i].Java_score));System.out.print('\t'+String.valueOf(udg[i].score));System.out.println('\t'+udg[i].sco_Level);}System.out.println();}}package Package_6;public class Postgraduate extends Student{public Postgraduate(String name, String stu_type, int sco1, int sco2,int sco3) {super(name, stu_type, sco1, sco2, sco3);// TODO Auto-generated constructor stubpg_Level pg_level=new pg_Level();sco_Level=pg_level.getLevel(score);}static void Output(Postgraduate[] pg){System.out.println("**********研究生**********");// System.out.println("————");System.out.print("姓名");System.out.print('\t'+"学生类型");System.out.print('\t'+"C语言成绩");System.out.print('\t'+"英语成绩");System.out.print('\t'+"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();}}package Package_6;public class Test {public static void main(String[] args){Undergraduate[] udg=new Undergraduate[5];udg[0]=new Undergraduate("小明","本科生",25,95,74);udg[1]=new Undergraduate("小红","本科生",60,82,82);udg[2]=new Undergraduate("小白","本科生",64,49,27);udg[3]=new Undergraduate("小黑","本科生",94,77,89);udg[4]=new Undergraduate("小军","本科生",91,84,73);Postgraduate[] pg=new Postgraduate[5];pg[0]=new Postgraduate("小明","本科生",25,95,74);pg[1]=new Postgraduate("小红","本科生",60,82,82);pg[2]=new Postgraduate("小白","本科生",64,49,27);pg[3]=new Postgraduate("小黑","本科生",94,77,89);pg[4]=new Postgraduate("小军","本科生",91,84,73);Undergraduate.Output(udg);Postgraduate.Output(pg);}}第4题的源代码：package PackageOne;public interface InterfaceOne{void OutPut();}package PackageOne;import PackageThree.SubClass;public class test{public static void main(String[] args){SubClass sc=new SubClass();InterfaceOne ifo= sc.getInnerclass();ifo.OutPut();}}package PackageThree;import PackageOne.InterfaceOne;import PackageTwo.SuperClass;public class SubClass extends SuperClass{public InterfaceOne getInnerclass(){InterfaceOne ifo=new InnerClass();return ifo;}}package PackageTwo;import PackageOne.InterfaceOne;public class SuperClass{protected class InnerClass implements InterfaceOne{public String str="这是InnerClass的str!";public InnerClass(){}public void OutPut(){System.out.println("这里是InnerClass的OutPut方法!");}public void OutPut_2(){System.out.println("这里是InnerClass的OutPut_2方法!");}}}六、实验过程中遇到的问题及解决手段：在做第4题时不熟悉接口与一个受保护的内部类之间的实现关系，实例化一个接口类型的内部类对象后无法调用内部类的一个方法（该方法为内部类特有）；经查阅书本后知道明白到了父类型的子对象只能调用父类型与子类共有的方法。