java 实验5 接口多态 实验报告

实验五继承和接口（实验报告）一、目的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();}}六、实验小结。

多态性实验报告一、实验目的本次实验的主要目的是深入研究和理解多态性这一重要的概念，并通过实际操作和观察来验证多态性在不同情境下的表现和作用。

二、实验原理多态性是面向对象编程中的一个关键特性，它允许不同的对象对相同的消息或操作做出不同的响应。

这种特性基于类的继承和方法的重写机制。

当一个父类的引用指向子类对象时，通过该引用调用方法时，实际执行的是子类中重写的方法，从而实现了多态性。

三、实验材料与环境1、编程语言：选择了 Java 作为实验的编程语言。

2、开发工具：使用了 IntelliJ IDEA 作为集成开发环境。

3、实验设备：一台配置良好的计算机，操作系统为 Windows 10。

四、实验步骤1、创建父类｀Shape`｀｀｀javaclass Shape ｛public void draw(）｛Systemoutprintln(＂Drawing a shape"）；｝｝｀｀｀2、创建子类｀Circle` 和｀Square` 继承自｀Shape`｀｀｀javaclass Circle extends Shape ｛＠Overridepublic void draw(）｛Systemoutprintln(＂Drawing a circle"）；｝｝class Square extends Shape ｛＠Overridepublic void draw(）｛Systemoutprintln(＂Drawing a square"）；｝｝｀｀｀3、在主函数中进行测试｀｀｀javapublic class PolymorphismTest ｛public static void main(String args) ｛Shape shape1 ＝ new Circle(）；Shape shape2 ＝ new Square(）；shape1draw(）；shape2draw(）；｝｝｀｀｀五、实验结果运行上述代码，输出结果为：｀｀｀Drawing a circleDrawing a square｀｀｀这表明，通过父类的引用调用｀draw` 方法时，实际执行的是子类中重写的方法，实现了多态性。

实验报告课程名称： Java程序设计成绩评定：实验项目名称：接口、泛型、枚举、内部类与异常指导教师：学生姓名：学号：专业班级：实验项目类型：基础实验地点：实验时间：一、实验目的与要求：1、理解接口的定义与实现；2、知道泛型、枚举型与内部类的基本应用；3、掌握常用异常的抛出与捕获及处理.二、实验环境：（硬件环境、软件环境）1.硬件环境：奔ⅣPC。

2.软件环境：Windows XP 操作系统，JDK6.0。

三、实验内容：（原理、操作步骤、程序代码等）任务：1、按照要求完成下述接口及实现类的程序1)定义名称为PCI（）的接口，包括启动的方法start和关闭的方法stop；2)定义名称为NetworkCard 的类表示网卡，实现PCI接口，并且其在实现start方法时输出“sending data……”，在实现stop方法时输出“network stop.”3)定义名称为SoundCard 的类表示声卡，实现PCI接口；并且其在实现start方法时输出“dudu……”，在实现stop方法时输出“sound stop.”4)定义名称为MainBoard 的类表示主板，包含方法public void usePCICard(PCIp)，在方法体内通过p来启动和关闭组件；5)定义一个包含main方法的Test类，在main方法内创建一个MainBoard 对象用mb来引用，创建一个NetworkCard对象用nc来引用，创建一个SoundCard对象用sc来引用，分别通过mb来使用usePCICard(PCI p)启动声卡和网卡。

2、泛型类程序的调试调试教材P165的程序8-2，写出程序运行结果，理解泛型类的工作机理及应用。

3、调试运行内部类程序：在类内部再定义另外一个类，这个另外定义的类就叫内部类。

调试教材P171-172程序8-3，写出程序运行结果，理解内部类的定义方法与应用。

4、异常抛出与捕获编程与调试先调试教材P182、183中的程序9-2和9-3，写出调试结果。

java接口实验心得在进行Java接口实验过程中，我深刻体会到接口的重要性和灵活性。

接口是一种规范，它定义了类应该具备的方法，并且可以被多个类实现，使得代码更加模块化和可扩展。

首先，通过实验我明白了接口的作用。

接口可以看作是一种契约，定义了类应该遵守的规则。

它提供了一种机制，使得不同的类可以实现相同的接口，并且具有相同的方法。

这样可以实现多态性，提高代码的可复用性和可扩展性。

其次，实验过程中我学会了如何定义接口。

在Java中，接口使用`interface`关键字来定义，接口中只包含方法的声明，没有方法的实现。

接口中的方法默认是`public`和`abstract`的，不需要显式地声明。

接口也可以包含常量和静态方法。

另外，我还了解到接口的实现方式。

一个类可以通过`implements`关键字来实现一个或多个接口，并且需要实现接口中声明的所有方法。

通过实现接口，类可以获得接口中定义的方法，并根据自己的需求进行具体的实现。

这种方式使得类与接口之间实现了解耦，使得代码更加灵活。

在实验过程中，我还学会了接口的多态性。

通过将接口作为方法的参数或返回值类型，可以实现对不同实现类的统一操作。

这样可以提高代码的灵活性和可扩展性，使得程序更易于维护和扩展。

此外，我还了解到接口的继承和多继承。

一个接口可以继承另一个接口，通过继承可以扩展接口的功能。

这种方式使得接口之间可以建立继承关系，实现更加灵活的接口设计。

总结起来，通过这次Java接口的实验，我深刻认识到接口的作用和优势。

接口可以定义规范，实现多态性，提高代码的可复用性和可扩展性。

同时，接口的实现方式和多态性使得代码更加灵活。

接口的继承和多继承可以扩展接口的功能。

掌握接口的使用，对于编写高质量的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. 在实验过程中，重点是要区分好实例和类，灵活掌握类的调⽤。

实验5：Java抽象类与接口实验时间：实验地点：一、实验目的及要求（1）掌握抽象类的概念及使用。

（2）掌握接口的概念和实现方式。

（3）理解抽象类和接口的区别。

二、实验设备环境及要求三、实验任务（1）输入给定的Java Application程序，写出运行结果。

（2）按照要求编写Java Application程序。

四、实验内容与步骤1．分析下列程序的输出结果。

interface Myface{int getnext();void setstart(int x);}class Add3 implements Myface{int sta,val;Add3(){sta=0;val=0;}public int getnext(){val+=3;return val;}public void setstart(int i){sta=i;val=i;}}public class Face{public static void main(String args[]){Add3 a=new Add3();for(int i=0;i<5;i++)System.out.println(a.getnext());System.out.println();a.setstart(10);for(int i=0;i<5;i++)System.out.println(a.getnext());}}2．按照要求编写Java Application程序。

假定要为某个公司编写雇员工资支付程序。

这个公司有各种类型的雇员（Employee），不同类型的雇员按不同的方式支付工资：经理（Manager）：每月获得一份固定的工资；销售人员（Salesman）：在基本工资的基础上每月还有销售提成；一般工人（Worker）：则按他每月工作的天数计算工资。

试用类的继承及相关机制描述这些功能需求，并编写一个Java Application程序，演示这些类的用法。

一、实验目的1. 理解多态的概念和原理。

2. 掌握多态编程的基本方法。

3. 通过实验加深对多态编程的理解和应用。

二、实验环境1. 操作系统：Windows 102. 编程语言：Java3. 开发工具：Eclipse三、实验内容1. 多态的基本概念2. 多态的实现方法3. 多态的应用实例四、实验步骤1. 多态的基本概念多态是指同一操作作用于不同的对象，可以有不同的解释，产生不同的执行结果。

在Java中，多态主要通过继承和重写方法来实现。

2. 多态的实现方法（1）继承在Java中，通过继承可以实现多态。

子类继承父类的方法和属性，可以重写父类的方法，使得子类的方法具有多态性。

（2）重写方法重写方法是指在子类中重写父类的方法，使得子类的方法具有多态性。

重写方法必须满足以下条件：- 方法名、返回类型、参数列表与父类方法相同；- 子类和父类之间必须存在继承关系。

（3）方法重载方法重载是指在同一个类中，存在多个同名方法，但参数列表不同。

方法重载可以实现多态，因为根据传入的参数列表，可以调用不同的方法。

3. 多态的应用实例下面通过一个简单的例子来展示多态的应用。

（1）创建一个动物类```javapublic class Animal {public void makeSound() {System.out.println("Animal makes a sound");}}```（2）创建两个子类，分别代表狗和猫```javapublic class Dog extends Animal {@Overridepublic void makeSound() {System.out.println("Dog barks");}}public class Cat extends Animal {@Overridepublic void makeSound() {System.out.println("Cat meows");}}```（3）创建一个方法，接受一个Animal类型的参数，并调用其makeSound方法```javapublic class Test {public static void main(String[] args) {Animal dog = new Dog();Animal cat = new Cat();makeSound(dog);makeSound(cat);}public static void makeSound(Animal animal) {animal.makeSound();}}```输出结果：```Dog barksCat meows```通过上面的例子，我们可以看到，尽管我们传递的是Animal类型的参数，但在调用makeSound方法时，会根据实际对象的类型调用相应的方法，实现了多态。

第1篇一、实验目的1. 理解接口的概念和作用。

2. 掌握接口的基本用法，包括接口的定义、实现和实现类。

3. 通过实际操作，加深对接口的理解和应用。

二、实验环境1. 操作系统：Windows 102. 开发工具：IntelliJ IDEA3. 编程语言：Java三、实验内容1. 接口的基本概念2. 接口的定义与实现3. 接口的多态性4. 接口的应用示例四、实验步骤1. 接口的基本概念（1）打开IntelliJ IDEA，创建一个新的Java项目。

（2）在项目下创建一个包，命名为“com.example”，用于存放实验代码。

（3）在包下创建一个接口，命名为“IAnimal”，用于定义动物的基本行为。

```package com.example;public interface IAnimal {void eat();void sleep();}```2. 接口的定义与实现（1）在“com.example”包下创建一个类，命名为“Dog”，实现“IAnimal”接口。

```package com.example;public class Dog implements IAnimal {@Overridepublic void eat() {System.out.println("狗吃肉");}@Overridepublic void sleep() {System.out.println("狗睡觉");}}```（2）在“com.example”包下创建另一个类，命名为“Cat”，实现“IAnimal”接口。

```package com.example;public class Cat implements IAnimal {@Overridepublic void eat() {System.out.println("猫吃鱼");}@Overridepublic void sleep() {System.out.println("猫睡觉");}}```3. 接口的多态性（1）在主类“Main”中创建一个方法，用于测试接口的多态性。

java接口实验报告实验报告：Java接口实验一、实验目的通过本次实验，我们希望达到以下目的：1. 深入理解Java接口的概念、特点和用途。

2. 掌握如何定义、实现和使用接口。

3. 理解接口在多态性中的作用。

4. 掌握如何使用接口来设计可扩展的代码。

二、实验内容1. 定义一个接口，并实现该接口。

2. 使用接口实现多态性。

3. 通过接口设计可扩展的代码。

三、实验步骤及结果步骤1：定义一个接口首先，我们定义一个名为"Shape"的接口，该接口包含一个计算面积的方法。

```javapublic interface Shape {double getArea();}```步骤2：实现接口接下来，我们创建两个类（Circle和Rectangle），分别实现Shape接口。

每个类都提供了一个计算面积的方法。

Circle类：```javapublic class Circle implements Shape {private double radius;private static final double PI = ;public Circle(double radius) {= radius;}Overridepublic double getArea() {return PI radius radius;}}```Rectangle类：```javapublic class Rectangle implements Shape {private double width;private double height;public Rectangle(double width, double height) {= width;= height;}Overridepublic double getArea() {return width height;}}```步骤3：使用接口实现多态性现在，我们创建一个名为"ShapeDisplay"的类，该类接受一个Shape对象，并使用该对象的getArea方法来计算面积。

java接口实验报告-回复Java接口实验报告[Java接口]的使用及实验结果写一篇1500-2000字文章，一步一步回答一、引言Java是一种面向对象的编程语言，它提供了丰富的特性来支持面向对象的编程。

其中一个最重要的特性之一就是接口。

接口在Java中扮演着连接不同类之间的桥梁，它定义了一组方法的签名，规定了其他类必须遵循的接口。

在本次实验中，我们将探索Java接口的使用，并通过编写简单的实验来进一步理解其工作原理。

二、理论基础2.1 接口的定义在Java中，接口是一种抽象的定义，它定义了一组可以被其他类实现的方法。

接口可以看作是一种约定，它规定了实现它的类必须提供的方法。

接口中的方法只有签名，没有实现，是完全抽象的。

接口使用`interface`关键字来定义。

2.2 接口的实现一个类可以同时实现多个接口，通过`implements`关键字来实现接口。

一个类实现了一个接口，就必须提供该接口中定义的所有方法。

接口的实现通过关键字`implements`来实现。

2.3 接口的优势接口在Java中扮演着重要的角色，它具有以下几个优势：1. 定义了一组可以被其他类实现的方法，提供了一种规范。

2. 实现多态性，不同的类可以实现同一个接口，实现类的实例可以通过接口的引用来访问。

3. 提高了代码的灵活性和可维护性，实现类可以随时更改。

4. 提供了一种解耦合的方式，降低了类之间的依赖性。

三、实验过程3.1 实验目标本次实验的目标是通过创建一个简单的接口和实现类，理解接口的概念和使用方法。

3.2 实验准备首先，我们需要创建一个Java项目来进行实验。

打开[Java IDE]，创建一个新的Java项目，并命名为"InterfaceExperiment"。

3.3 实验步骤步骤1：创建接口在项目中，创建一个新的Java类，并命名为"Animal"。

在类中定义一个抽象方法，例如`void sound()`。

JAVA第五次实验报告实验五：数组的引用类型与多态性实验目的：1.掌握数组的引用类型和多态性的概念和使用。

2. 熟悉Java中数组的创建、初始化和遍历。

3.理解多态性的概念和实现方式。

4. 掌握Java中类和对象的定义和使用。

实验过程：1. 创建了一个名为"Person"的类，拥有一个私有成员变量"name"和一个公有的构造方法和一个公有的成员方法printName(。

2. 创建了一个名为"Student"的类，作为Person类的子类，拥有一个私有成员变量"grade"和一个公有的构造方法和一个公有的覆盖了父类方法的成员方法printName(。

3. 创建了一个名为"Teacher"的类，作为Person类的子类，拥有一个私有成员变量"subject"和一个公有的构造方法和一个公有的覆盖了父类方法的成员方法printName(。

4. 在主函数中，创建了一个长度为5的Person类型的数组，并分别实例化了两个Student对象和两个Teacher对象，并将这四个对象赋值给数组的前四个元素。

5. 遍历数组，调用每个对象的printName(方法，分别输出每个对象的名称。

实验结果：运行程序后，实验结果如下：Student - 1Student - 2Teacher - 1Teacher - 2实验分析：通过以上实验，我们可以看到数组可以存储同一父类引用类型的不同子类对象，这种特性称为多态性。

在遍历数组时，可以调用每个对象的方法，实现多态的效果。

在本实验中，通过将两个Student对象和两个Teacher对象赋值给Person类型的数组，我们实现了多态性。

在遍历数组时，调用每个对象的printName(方法，程序会根据对象的具体类型执行对应的方法。

实验总结：通过本次实验，我学会了如何使用数组的引用类型和多态性。

java多态实验报告Java多态实验报告引言：Java是一种面向对象的编程语言，多态是其核心特性之一。

本实验旨在通过编写代码并运行实验，深入理解Java中的多态概念和使用方法。

实验目的：1. 理解多态的概念和原理；2. 掌握多态的使用方法和技巧；3. 通过实验加深对多态的理解和应用。

实验步骤：1. 创建一个抽象类Animal，并定义一个抽象方法makeSound()；2. 创建两个继承自Animal的子类：Dog和Cat，并分别实现makeSound()方法；3. 在主函数中创建一个Animal类型的数组，包含两个元素，分别为Dog和Cat 的实例；4. 遍历数组，调用每个元素的makeSound()方法；5. 运行程序，观察输出结果。

实验结果：通过运行实验代码，我们可以看到Dog和Cat的实例都调用了makeSound()方法，但输出的结果却不同。

这就是多态的体现。

多态性允许我们在父类Animal的引用下，调用子类Dog和Cat的方法，实现了代码的灵活性和扩展性。

实验分析：1. 多态的概念：多态是指同一种类型的对象，在不同的情况下表现出不同的行为。

在本实验中，Dog和Cat都是Animal的子类，它们都继承了makeSound()方法，但实现方式不同，因此在调用时会表现出不同的行为。

2. 多态的原理：多态的实现依赖于继承和方法重写。

通过将子类对象赋值给父类引用，实现了对子类对象的调用。

在运行时，会根据实际对象的类型来确定调用哪个方法。

3. 多态的优势：多态使代码更加灵活和可扩展。

当需要新增一种动物时，只需创建一个新的子类并实现makeSound()方法，不需要修改原有的代码，即可实现新增功能。

4. 多态的应用场景：多态常用于面向对象的设计和开发中，尤其是在需要处理多种类型对象的情况下。

通过使用多态，可以简化代码结构，提高代码的可读性和可维护性。

实验总结：通过本次实验，我深入理解了Java中的多态概念和使用方法。

实验五接口、多态与内部类实验目标：1、理解接口、塑型、多态的概念并能熟练应用；2、熟练掌握接口的定义和使用；3、深刻理解构造方法的调用顺序，理解编写时需要注意的问题；4、了解并学会使用内部类实验任务：1、继承时的多态：目测给出下面代码的执行输出结果，并简单解释每一行输出的原因。

答：首先，该程序的主函数是Vehicle v=new Vehicle();即先声明并实例化一个汽车对象，而v.test();则是调用汽车的测试方法；而test方法里，Vehicle vc=new Car();是将上面的汽车指向了一个具体的小汽车对象；Bus vb=new Bus();将公共汽车指向了一个具体的公共汽车对象；drive();调用汽车的驾驶方法；vc.drive();调用小汽车的驾驶方法；vb.drive();调用公共汽车的驾驶方法；而vc.brake();vb.brake();则是直接调用汽车的刹车方法。

因而运行结果如下：A new bus.Vehicle is drivenCar is drivenBus is drivenVehicle is brakedVehicle is braked2.针对下面的简单的类图，从面向对象的角度，将Instrument定义成接口，应怎样实现。

编写能完成如图功能的程序，并再编写一个简单的应用程序进行多态性测试。

（参考例子5-9；实验4该题是要求用抽象类来实现，在此要求用接口实现，还要进行多态性测试）说明：Instrument表示乐器、Wind表示管乐器、Percussion敲击乐器、Stringed表示弦乐器、Woodwind表示木管乐器、Brass表示铜管乐器。

要求：（1）Instrument为接口，Wind为抽象类，其他为普通类。

这里测试的目的是：我们知道当一个普通类实现一个接口时，必须实现该接口的全部方法，但当这个类是抽象类时，我们还需要实现该接口全部方法吗？如果不需要实现？那么是否直接不理这个方法就一，还是要将这个方法在自己类内部再标记一次为抽象方法。

实验五继承与多态理解继承与多态的概念，掌握三种访问控制的区别，掌握抽象类、接口与包的应用。

二、实验内容：1. 参考教材P112，示例程序C5_17，掌握抽象类的应用。

2. 参考教材P116，示例程序C5_19，掌握接口的使用方法。

3. 参考教材P121，示例程序C5_20，掌握包的使用方法。

三、实验要求：1.完成示例程序的验证。

2.写出实验报告。

四、实验步骤与结果：（由学生按照实验内容完成）1. 示例程序c5_17import java.awt.*;import java.applet. *;abstract class Shapes //定义一个抽象类Shapes{public int x,y; //x、y为画图的坐标public int width,height;public Shapes(int x,int y,int width,int height){ this.x=x;this.y=y;this.width=width;this.height=height;}abstract double getArea( ); //求图形面积的抽象方法abstract double getPerimeter( ); //求图形周长的抽象方法}class Square extends Shapes //由抽象类Shapes派生的子类——矩形类{public double getArea( ){return(width*height);}public double getPerimeter( ){return(2*width+2*height);}public Square(int x,int y,int width,int height){ super(x,y,width,height); }}class Triangle extends Shapes //由抽象类Shapes派生的子类——三角形类{public double c; //斜边public double getArea( ){return(0.5*width*height);}public double getPerimeter( ){return(width+height+c);}public Triangle(int x,int y,int base,int height){super(x,y,base,height);c=Math.sqrt(width*width+height*height);}}class Circle extends Shapes //由抽象类Shapes派生的子类——圆类{public double r; //半径public double getArea( ){return(r*r*Math.PI);}public double getPerimeter( ){return(2*Math.PI*r);}public Circle(int x,int y,int width,int height){super(x,y,width,height);r=(double)width/2.0;}}public class c5_18 extends Applet{/****/private static final long serialVersionUID = -L;Square Box=new Square(5,15,25,25);Triangle tri=new Triangle(5,50,8,4);Circle Oval=new Circle(5,90,25,25);public void paint(Graphics g){//画正方形g.drawRect(Box.x,Box.y,Box.width,Box.height);g.drawString("Box Area:"+Box.getArea( ),50,35);g.drawString("Box Perimeter:"+Box.getPerimeter( ),50,55);g.drawString("tri Area:"+tri.getArea( ),50,75);g.drawString("tri Perimeter:"+tri.getPerimeter( ),50,95);g.drawOval(Oval.x,Oval.y,Oval.width,Oval.height); //画圆g.drawString("oval Area:"+Oval.getArea( ),50,115);}}2. 示例程序C5_19import java.awt.*;import java.applet.*;interface Shapes{ abstract double getArea( );abstract double getPerimeter( );}class Coordinates{int x,y;public Coordinates(int x,int y){this.x=x;this.y=y;}}//Square Coordinates Shapesclass Square extends Coordinates implements Shapes{public int width,height;public double getArea( ){return(width*height);}public double getPerimeter( ){return(2*width+2*height);} public Square(int x,int y,int width,int height){super(x,y);this.width=width;this.height=height;}}class Triangle extends Coordinates implements Shapes{public int width,height;public double c;public double getArea( ){return(0.5*width*height);}public double getPerimeter( ){return(width+height+c);}public Triangle(int x,int y,int base,int height){super(x,y);width=base;this.height=height;c=Math.sqrt(width*width+height*height);}}class Circle extends Coordinates implements Shapes{public int width,height;public double r;public double getArea( ){return(r*r*Math.PI);}public double getPerimeter( ){return(2*Math.PI*r);}public Circle(int x,int y,int width,int height){super(x,y);this.width=width;this.height=height;r=(double)width/2.0;}}public class c5_20 extends Applet{/****/private static final long serialVersionUID = L;Square Box=new Square(5,15,25,25);Triangle tri=new Triangle(5,50,8,4);Circle Oval=new Circle(5,90,25,25);public void paint(Graphics g){g.drawRect(Box.x,Box.y,Box.width,Box.height);g.drawString("Box Area:"+Box.getArea( ),50,35);g.drawString("Box Perimeter:"+Box.getPerimeter( ),50,55);g.drawString("tri Area:"+tri.getArea( ),50,75);g.drawString("tri Perimeter:"+tri.getPerimeter( ),50,95);g.drawOval(Oval.x,Oval.y,Oval.width,Oval.height);g.drawString("oval Area:"+Oval.getArea( ),50,115);}}五.总结。

实验（四）接口与多态一、实验目的和要求1.掌握面向对象的继承关系2.理解面向对象的多态3.掌握方法的重写4.掌握接口的实现二、实验内容和原理设计一个抽象类Shape，包括2个抽象方法，分别是计算形状的周长和面积。

设计具体类Rectangle和Circle，分别表示矩形和圆，它们都是Shapes的子类。

使Rectangle和Circle都实现Comparable接口（根据面积比较大小），编写一个通用的排序程序和一个通用的二分查找程序（自己写代码实现），能对这二种类型的数组进行排序并查找指定的对象。

三、实验环境1.硬件环境：2.软件环境：JDK1.5四、算法描述及实验步骤1.算法描述（可以用类图、流程图、伪代码或源程序描述）通用排序算法：通用二分法查找算法：2.实验步骤●创建一个UML项目，并设计类shape、Rectangle、Circle接口Comparable的关系（算法描述的图）●创建一个Java应用项目●把UML项目自动生成代码到Java应用项目中●实现各类中的方法●进行编译●进行测试，使用的测试用例：输入：预期输出：测试用例：输入：圆形对象数组：半径3.0、2.0、5.0、4.0、6.0矩形对象数组：长5.0 宽4.0 长4.0 宽3.0长7.0 宽2.0 长9.0 宽6.0 用于查找的圆形对象：半径5.0用于查找的矩形对象：长10.0 宽3.0预期输出：按面积小大排序好的数组：圆形：面积12.57、28.27、50.27、78.54、113.10 矩形：面积12.00、14.00、20.00、54.00按面积查找的结果：圆位于第3位，矩形不在数组中。

五、调试过程1.编译过程1）一开始以为Comparable接口中的CompareTo方法是要圆形与矩形面积相比较，因此一开始的写法是：（Circle类中的方法）getArea() >((Rectangle) obj).getArea()；但是排序算法提示错误，原因是Circle对象无法强制转化为Rectangle对象，因此将ComparabeTo算法改为：（Circle类中的方法）getArea() > ((Circle) obj).getArea()2）排序算法一开始传入的对象是Shape父类并具有返回值，返回类型为Shape对象数组，但是这样不符合通用编程思想，因此将传入的参数改为Comparable接口对象，不具有返回类型。

java实验报告Java实验报告。

一、实验目的。

本实验旨在通过对Java编程语言的学习和实践，加深对Java语言特性和编程技巧的理解，提高编程能力和解决问题的能力。

二、实验内容。

1. 学习Java语言的基本语法和数据类型；2. 掌握Java语言的流程控制和函数调用；3. 熟悉Java语言的面向对象编程特性；4. 实践Java语言的异常处理和文件操作；5. 编写一个简单的Java程序，实现特定的功能。

三、实验过程。

在实验过程中，首先我通过阅读相关的教材和资料，系统地学习了Java语言的基本语法、数据类型、流程控制和函数调用。

然后，我深入理解了Java语言的面向对象编程特性，包括类、对象、继承、多态等概念，并通过实例加深了对这些概念的理解和掌握。

接着，我学习了Java语言的异常处理和文件操作，了解了如何在Java程序中处理异常和进行文件的读写操作。

最后，我根据所学知识，编写了一个简单的Java程序，实现了一个特定的功能，通过实际的编程实践，巩固了所学知识，提高了编程能力。

四、实验结果。

经过一段时间的学习和实践，我成功地完成了实验要求，掌握了Java语言的基本语法和编程技巧，能够熟练地编写简单的Java程序，并且对Java语言的面向对象编程特性、异常处理和文件操作有了较为深入的理解和掌握。

五、实验总结。

通过本次实验，我深刻地认识到了学习和实践的重要性。

只有通过不断地学习和实践，才能够真正地掌握知识和技能。

在今后的学习和工作中，我将继续努力，不断地学习和实践，提高自己的编程能力和解决问题的能力，为将来的发展打下坚实的基础。

六、致谢。

在此，我要感谢老师和同学们在学习和实践中给予我的帮助和支持，没有你们的帮助和支持，我无法顺利地完成本次实验。

同时，我也要感谢自己的努力和坚持，是你们让我不断地成长和进步。

以上就是本次实验的全部内容，谢谢阅读！。

实验报告【实验名称】第四章接口和多态【实验目的】1.学习Java中抽象类的概念2.学习接口的概念3.学习面向抽象的编程以及面向接口的编程【实验原理】1.Java程序设计基本原理2.面向对象程序设计基本原理【实验内容】一、结合本次课程，简答：1、什么是上转型对象？调用子类方法原则？将子类赋给父类时，称父类为子类的上转型对象。

方法原则：只能调用子类继承和重写的方法，不能调用子类中新的方法。

2、父类创建的对象和其子类的上转型对象异同？相同点：都可以对父类里的方法进行调用。

不同点：上转型对象调用的父类方法只能是子类重写之后的，而父类创建的对象调用的是自身定义的。

3、为什么引入抽象类和抽象方法？抽象类只关心操作，不关心操作具体实现细节，可以使程序员把精力集中在程序的设计上，而不必拘泥于细节的实现。

也就是说设计者只需设计好方法，而具体方法实现由子类的设计者实现。

减轻了程序员的负担。

4、接口和抽象类的异同？相同点：二者都是需要背继承和实现后才有实际意义，并且二者都有抽象类型。

不同点：抽象类属于类，接口是一种新的数据类型；抽象类的属性可以是常量和变量，而接口中只能是常量；抽象类中可以有抽象方法和普通方法，而接口中只能是抽象方法；抽象类将其抽象方法的实现交给其子类，而接口将其抽象方法的实现交给实现该接口的类。

5、接口和类的异同？相同点：接口和类都是数据类型；属性中都有常量，方法中都有抽象类方法。

不同点：类的属性是变量和常量，方法需要实现，而接口的属性只能是常量，方法只需声明；类中可以有抽象方法和普通方法，而接口中只能是抽象方法；类的属性可以是常量和变量，而接口中只能是常量；类中可以有抽象方法和普通方法，而接口中只能是抽象方法。

二、程序设计实验一：按要求完成程序1. 设计一个抽象类People，具有抽象方法say()；2. 设计子类ChinaPeople，AmericaPeople，实现抽象方法say()；两个类的say（）方法，分别输出语句：我是中国人；我是美国人3. 设计一个Speak类，提供speaking(People p)方法，注意：其参数是抽象的People类型，Speaking方法中，要求以上转型对象参数p，调用say 方法的内容；4. 设计一个测试类Test，添加main函数，分别创建中国人和美国人，测试speak类的使用；5.再增加一个子类AfricaPeople，实现抽象方法say()；添加到测试类中。

java接口的实现与运用实验总结Java接口的实现与运用实验总结一、引言在Java编程中，接口（Interface）被广泛应用于面向对象编程中，它定义了一组方法的规范，而不实现这些方法的具体逻辑。

通过接口的实现，不仅可以提高代码的重用性和灵活性，还可以实现多态编程。

本篇文章将对Java接口的实现与运用进行实验总结，并回答以下问题：1. 实验过程中你遇到了哪些问题？2. 你是如何解决这些问题的？3. 通过实验你获得了哪些经验和教训？二、实验过程1. 实验背景在编程过程中，经常需要定义一些规范，而不实现具体的逻辑，以便多个类来实现这些规范。

这时候，就可以使用接口来定义这些规范。

本次实验旨在加深对接口实现的理解，并掌握接口的运用。

2. 实验环境和工具实验使用Java编程语言，所需工具为Eclipse IDE。

为了更好地理解和实践接口的实现和运用，我们需要有一定的Java语言和面向对象编程的基础。

3. 实验步骤(1) 创建接口首先，我们需要创建一个接口，例如命名为Flyable，用于定义飞行的规范。

在接口中，可以定义多个抽象方法，例如fly()和land()。

(2) 实现接口接下来，我们需要创建一个类，例如Bird，通过实现接口Flyable来实现飞行的具体逻辑。

在实现类中，需要实现接口中定义的所有抽象方法。

(3) 使用接口最后，我们可以通过创建对象，调用接口中定义的方法来实现具体的功能，例如创建Bird对象，调用fly()和land()方法。

三、问题与解决1. 问题在实验过程中，我遇到了以下问题：- 如何正确定义和使用接口？- 如何实现接口中定义的方法？- 接口与抽象类的区别和联系是什么？2. 解决方案为了解决上述问题，我采取了以下解决方案：- 了解接口的基本概念和语法规则，以及如何定义和使用接口。

- 在实现接口时，需要通过关键字implements来实现接口，并实现接口中定义的所有抽象方法。

- 接口是一种完全抽象的类，它只提供了一组方法的规范，而没有具体的实现。

实验 java接口技术和多态一、实验目的：掌握接口技术和多态二、实验内容：1．创建以下类图所示的各类三、实验要求：1. 实现接口的继承；2. 实现各个类的接口方法；3. 多态的使用。

四、实验步骤：1．定义接口Payment，Payment包含两个常数：EmployerPayment（职员工资）和ManagerPayment（管理员工资），Employer类和Manager类分别实现getMonthlyPayment方法，显示月工资，在main方法中显示Employer和Manager对象的工资。

2．定义接口ShowAble，ShowAble包含showMe()方法和指示图片目录的常量filePath，Employer类和Circle类分别实现ShowAble接口，请在Circle，Employer和Manager类中实现showMe()方法（注1），利用多态机制在main方法中调用showMe方法显示Circle，Employer 和Manager对象的图像。

五、自做作实验1．定义一个描述人的基本类，该类包括人的性别和出生日期两个数据成员，以及设置和获取这些属性值的方法成员；再定义一个大学生类，使大学生类具有人的所有属性外，还具有姓名、学号，大学入学成绩，籍贯属性以及设置和获取这些属性值的方法成员；编写完整的程序，完成一个具有班级学生统计信息功能的小程序。

Ｍａｉｎ程序１：package test;import business.demo.person.*;public class Test1 {public static void main(String[] args) {Employer man1=new Employer();Employer man2=new Manager();System.out.println(man1.getMonthlyPayment());System.out.println(man2.getMonthlyPayment());}}Ｍａｉｎ程序２：package test;import business.demo.person.*;import business.demo.shape.*;import business.demo.show.*;public class Test2 {public static void main(String[] args) { ShowAble[] showObject=new ShowAble[4];showObject[0]=new Employer();showObject[1]=new Manager();showObject[2]=new Circle();for(int i=0;i<3;i++) {showObject[i].showMe();}}}import java.awt.Image;import java.io.File;import java.io.IOException;import javax.imageio.ImageIO;import javax.swing.ImageIcon;import javax.swing.JFrame;import javax.swing.JLabel;public class ShowPicture extends JFrame { //显示图片public void show(String bmpFile) {this.setSize(10, 10);Image image = null;try {image = ImageIO.read(new File(bmpFile));} catch (IOException ex) {}JLabel label = new JLabel(newImageIcon(image));label.setSize(2, 2);add(label);setDefaultCloseOperation(EXIT_ON_CLOSE);pack();this.setVisible(true);}}package business.demo.person;public class Employer implements Payment{ public float getMonthlyPayment(){return EmployerPayment;}}package business.demo.person;public class Manager extends Employer{public float getMonthlyPayment(){return ManagerPayment;}}package business.demo.person;public interface Payment {float EmployerPayment=2000;float ManagerPayment=4000;}package test;import business.demo.person.Employer;import business.demo.person.Manager;public class test1 {public static void main(String[] args){Employer man1=new Employer();Employer man2=new Manager();System.out.println(man1.getMonthlyPayment());System.out.println(man2.getMonthlyPayment());}}。

实验9：接口、多态性一、实验目的与要求1、多态性的概念、技术基础2、构造方法的调用顺序3、总结接口的应用二、内容概要1、多态性概念是指不同类型的对象可以响应相同的消息。

从相同的基类派生出来的多个类型可被当作同一种类型对待，可对这些不同的类型进行同样的处理，由于多态性，这些不同派生类对象响应同一方法时的行为是有所差别的。

例如●Cat行为是吃鱼，Dog行为是吃骨头●所有的Object类的对象都响应toString()方法2、多态性的技术基础●向上塑型技术：一个父类的引用变量可以指向不同的子类对象●动态绑定技术：运行时根据父类引用变量所指对象的实际类型执行相应的子类方法，从而实现多态性3、多态性的好处应用程序不必为每一个派生类（子类）编写功能调用，只要对基类（特别是抽象基类）或接口处理即可，“以不变应万变”，大大提高程序的可复用性。

例如：下面代码Waiter类中的callPersonEat方法参数是Person 类型，所以利用向上塑性技术可以给其传参数China和USA类型。

而该方法体p.eat(); ，利用动态邦定技术运行时候根据p引用的具体对象调用创建对象时所属类的eat方法interface Person{public void eat();}class China implements Person{public void eat(){System.out.println("chinese use chopsticks");}}class USA implements Person{public void eat(){System.out.println("usa use forks");}}class Waiter{static void callPersonEat(Person p){p.eat(); //实例方法调用，动态绑定}public static void main(String a[]){Person p1=new China();//向上塑性Person p2=new USA();//向上塑性Waiter.callPersonEat(p1);Waiter.callPersonEat(p2);/*Person p[]=new Person[2];p[0]=new China();p[1]=new USA();for(int i=0;i<2;i++)Waiter.callPersonEat(p[i]);*/}}例如，Ball类。