下载文档原格式
第1篇一、实验目的本次实验旨在通过实践加深对编译技术中词法分析阶段的理解，掌握词法分析的基本原理和方法，能够实现一个简单的词法分析器，并对源代码进行初步的符号化处理。
二、实验环境1. 操作系统：Windows 102. 编程语言：Java3. 开发工具：Eclipse IDE4. 实验素材：实验提供的C语言源代码三、实验原理词法分析是编译过程中的第一个阶段，其主要任务是将源代码中的字符序列转换成一系列的词法单元（Token）。
词法单元是构成源程序的基本单位，如标识符、关键字、运算符等。
词法分析的基本原理如下：1. 字符流：从源代码中逐个读取字符，形成字符流。
2. 状态转换：根据字符流中的字符，在有限状态自动机（FSM）中转换状态。
3. 词法单元生成：当状态转换完成后，生成对应的词法单元。
4. 错误处理：在分析过程中，如果遇到无法识别的字符或状态，进行错误处理。
四、实验步骤1. 设计词法分析器：根据C语言的语法规则，设计有限状态自动机，定义状态转换图。
2. 实现状态转换函数：根据状态转换图，实现状态转换函数，用于将字符流转换为词法单元。
3. 实现词法单元生成函数：根据状态转换结果，生成对应的词法单元。
4. 测试词法分析器：使用实验提供的C语言源代码，测试词法分析器的正确性。
五、实验结果与分析1. 词法分析器设计：根据C语言的语法规则，设计了一个包含26个状态的状态转换图。
状态转换图包括以下状态：- 初始状态：用于开始分析。
- 标识符状态：用于分析标识符。
- 关键字状态：用于分析关键字。
- 运算符状态：用于分析运算符。
- 数字状态：用于分析数字。
- 字符串状态：用于分析字符串。
- 错误状态：用于处理非法字符。
2. 状态转换函数实现：根据状态转换图，实现了状态转换函数。
该函数用于将字符流转换为词法单元。
3. 词法单元生成函数实现：根据状态转换结果，实现了词法单元生成函数。
该函数用于生成对应的词法单元。
java实训报告（精选5篇）java实训报告1作为就业培训，项目的好坏对培训质量的影响十分大，常常是决定性的作用。
这篇__是关于在学习java软件开发时练习项目的总结，简单总结为以下几点：1、项目一定要全新的项目，不能是以前做过的2、项目一定要企业真实项目，不能是精简以后的，不能脱离实际应用系统3、在开发时要和企业的开发保持一致4、在做项目的时候不应该有参考代码长话短说就是以上几点，如果你想要更多的了解，可以继续往后看。
一：项目的地位因为参加就业培训的学员很多都是有一定的计算机基础，大部分都具备一定的编程基础，尤其是在校或者是刚毕业的学生，多少都有一些基础。
他们欠缺的主要是两点：（1）不能全面系统的、深入的掌握某种技术，也就是会的挺多，但都是皮毛，不能满足就业的需要。
（2）没有任何实际的开发经验，完全是想象中学习，考试还行，一到实际开发和应用就歇菜了。
解决的方法就是通过项目练习，对所学知识进行深化，然后通过项目来获取实际开发的经验，从而弥补这些不足，尽快达到企业的实际要求。
二：如何选择项目项目既然那么重要，肯定不能随随便便找项目，那么究竟如何来选择呢？根据java的研究和实践经验总结，选择项目的时候要注意以下方面：1：项目不能太大，也不能太小这个要根据项目练习的阶段，练习的时间，练习的目标来判断。
不能太大，太大了做不完，也不能太小，太小了没有意义，达不到练习的目的。
2：项目不能脱离实际应用系统项目应该是实际的系统，或者是实际系统的简化和抽象，不能够是没有实战意义的教学性或者是纯练习性的项目。
因为培训的时间有限，必须让学员尽快地融入到实际项目的开发当中去。
任何人接受和掌握一个东西都需要时间去适应，需要重复几次才能够真正掌握，所以每个项目都必须跟实际应用挂钩。
3：项目应能覆盖所学的主要知识点学以致用，学完的知识点需要到应用中使用，才能够真正理解和掌握，再说了，软件开发是一个动手能力要求很高的行业，什么算会了，那就是能够做出来，写出代码来，把问题解决了，你就算会了。
Java实验三实验报告1一、实验目的本次 Java 实验的主要目的是深入理解和掌握 Java 中的面向对象编程概念，通过实际的编程实践，提高对类、对象、继承、多态等特性的运用能力，同时培养良好的编程习惯和代码规范。
二、实验环境1、操作系统：Windows 102、开发工具：Eclipse IDE for Java Developers三、实验内容1、设计一个名为｀Shape` 的抽象类，其中包含一个抽象方法｀calculateArea(）｀用于计算图形的面积。
2、分别创建｀Circle`（圆形）、｀Rectangle`（矩形）和｀Triangle`（三角形）类继承自｀Shape` 类，并实现各自的｀calculateArea(）｀方法来计算具体图形的面积。
3、创建一个测试类｀TestShapes`，在其中创建不同图形的对象，并调用其计算面积的方法，输出结果。
四、实验步骤1、创建｀Shape` 抽象类｀｀｀javaabstract class Shape ｛abstract double calculateArea(）；｝｀｀｀2、创建｀Circle` 类继承自｀Shape` 类｀｀｀javaclass Circle extends Shape ｛private double radius;public Circle(double radius) ｛thisradius ＝ radius;｝＠Overridedouble calculateArea(）｛return MathPI radius radius;｝｝｀｀｀3、创建｀Rectangle` 类继承自｀Shape` 类｀｀｀javaclass Rectangle extends Shape ｛private double length;private double width;public Rectangle(double length, double width) ｛thislength ＝ length;thiswidth ＝ width;｝＠Overridedouble calculateArea(）｛return length width;｝｝｀｀｀4、创建｀Triangle` 类继承自｀Shape` 类｀｀｀javaclass Triangle extends Shape ｛private double base;private double height;public Triangle(double base, double height) ｛thisbase ＝ base;thisheight ＝ height;｝＠Overridedouble calculateArea(）｛return 05 base height;｝｝｀｀｀5、创建测试类｀TestShapes`｀｀｀javapublic class TestShapes ｛public static void main(String args) ｛Circle circle ＝ new Circle(50)；Rectangle rectangle ＝ new Rectangle(40, 60)；Triangle triangle ＝ new Triangle(30, 80)；Systemoutprintln(＂圆形的面积：＂＋ circlecalculateArea(））；Systemoutprintln(＂矩形的面积：＂＋ rectanglecalculateArea(））；Systemoutprintln(＂三角形的面积：＂＋trianglecalculateArea(））；｝｝｀｀｀五、实验结果运行测试类｀TestShapes` 后，输出结果如下：｀｀｀圆形的面积：78539816矩形的面积：240三角形的面积：120｀｀｀六、实验中遇到的问题及解决方法1、在编写抽象类和子类的代码时，一开始对于抽象方法的定义和实现理解不够清晰，导致代码出现错误。
java编程实验报告Java编程实验报告引言：Java是一种广泛应用于软件开发领域的高级编程语言，具有跨平台、面向对象、安全性高等特点。
本篇文章将介绍我在Java编程实验中的实践和收获。
实验一：Hello World程序在本实验中，我学习了如何使用Java编写一个简单的Hello World程序。
通过这个实验，我了解了Java的基本语法和程序结构。
在编写过程中，我发现Java的语法规范相对严格，需要注意语句的结束符号和代码的缩进。
通过运行程序，我成功输出了"Hello World"这个简单的字符串，这让我对Java编程的基本流程和语法有了更深入的了解。
实验二：变量与运算符在本实验中，我学习了Java中的变量和运算符的使用。
通过编写程序，我实现了对不同类型的变量进行声明和赋值，并进行基本的运算操作。
在这个过程中，我发现Java的变量需要先声明后使用，而且在进行运算时需要注意数据类型的匹配。
通过这个实验，我对Java中的变量和运算符有了更深入的理解。
实验三：条件语句与循环结构在本实验中，我学习了Java中的条件语句和循环结构的使用。
通过编写程序，我实现了对不同条件进行判断，并根据不同的条件执行相应的操作。
同时，我还学习了循环结构的使用，通过循环语句实现了对一段代码的重复执行。
在这个实验中，我发现条件语句和循环结构是Java编程中非常重要的部分，能够帮助程序实现更复杂的逻辑。
实验四：数组和字符串在本实验中，我学习了Java中数组和字符串的使用。
通过编写程序，我实现了对数组和字符串的声明、赋值和操作。
在这个过程中，我发现Java中的数组和字符串是一种非常方便的数据结构，能够帮助程序处理大量的数据。
通过这个实验，我对Java中数组和字符串的使用有了更深入的了解。
实验五：面向对象编程在本实验中，我学习了Java中的面向对象编程的基本概念和使用。
通过编写程序，我实现了对类的定义、对象的创建和方法的调用。
计算机与信息学院实验报告系软件系专业软件工程年级08级成绩姓名学号实验室T312 机号48实验时间2010年11月1日下午3、4节教师签字实验（三）类和对象一、实验目的和要求1.掌握类的构造函数的重载2.深入理解类和对象3.学习NetBeans中UML项目的创建类并生成相应代码的方法二、实验内容和原理设计一个复数类，能够完成复数之间的基本运算，重写方法toString()，使其能输出此复数（形式为：实部 + 虚部i）。
要求设计的复数类必须有三个构造函数，分别为无参数、1个参数和2个参数的构造函数，完成的基本运算包括两个复数的加、减、乘、除法和共轭复数。
三、实验环境1.硬件环境：2.软件环境：JDK1.5四、算法描述及实验步骤1.算法描述（可以用类图、流程图、伪代码或源程序描述）2.实验步骤●创建一个UML项目，并设计类Complex如下图●创建一个Java应用项目●把UML项目中的Complex自动生成代码到Java应用项目中●实现Complex类中的方法●进行编译●进行测试，使用的测试用例：输入：预期输出：…五、调试过程1.编译过程记录算法实现中发现的语法错误及改正以下代码不能实现预期的结果：应该改成如下代码：2.调试过程记录算法实现中发现的逻辑错误及改正，对每个测试用例，记录实际输出，并与预期输出进行比较，如果不同，分析产生错误的原因并改正。
输入：预期输出：实际输出：分析与预期结果一致。
六、实验结果用与测试用例不同的输入数据运行算法，写出得到的结果，并分析结果是否正确。
第一组输入：第二组输入：第一组输出结果：第二组输出结果：结果分析：两组的输出结果都正确。
七、总结不应该一开始就考虑怎么编写代码，而是应该想好其框架。
注意语法上的错误，而逻辑上的错误在改正上有很大的难度，在这方面要多加交流。
附录：import javax.swing.*;public class Complex {private double realPart;private double imaginaryPart;public Complex(){realPart = Double.parseDouble(JOptionPane.showInputDialog("Please enter the realpart:"));imaginaryPart = Double.parseDouble(JOptionPane.showInputDialog("Please enter the imaginarypart:"));}public Complex(double realPart){this.realPart = realPart;this.imaginaryPart = 0;}public Complex(double realPart,double imaginaryPart){this.realPart = realPart;this.imaginaryPart = imaginaryPart;}public double getRealPart(){return this.realPart;}public void setRealPart(double val){realPart = val;}public double getimaginaryPart(){return this.imaginaryPart;}public void setimaginaryPart(double val){imaginaryPart = val;}public Complex plus(Complex complex){Complex c = new Complex(realPart + complex.realPart,imaginaryPart + complex.imaginaryPart);return c;}public Complex minus(Complex complex){Complex c = new Complex(realPart - complex.realPart,imaginaryPart - complex.imaginaryPart);return c;}public Complex times(Complex complex){Complex c = new Complex(realPart * complex.realPart - imaginaryPart * complex.imaginaryPart,realPart * complex.imaginaryPart + imaginaryPart * complex.realPart);return c;}public Complex divideBy(Complex complex){double t = complex.realPart * complex.realPart + complex.imaginaryPart * complex.imaginaryPart;Complex c = new Complex((realPart * complex.realPart + imaginaryPart * complex.imaginaryPart)/t,(imaginaryPart * complex.realPart - realPart * complex.imaginaryPart) / t);return c;}public Complex conjugate(){Complex c = new Complex(realPart,-imaginaryPart);return c;}public String toString(){String str = "";if(realPart != 0 && imaginaryPart > 0)return str+realPart+"+"+imaginaryPart+"i"+"\n";if(realPart != 0 && imaginaryPart < 0)return str+realPart+imaginaryPart+"i"+"\n";if(realPart == 0 && imaginaryPart != 0){return str+imaginaryPart+"i"+"\n";}if(realPart == 0 && imaginaryPart == 0){System.out.println("重新输入：");}return str+realPart+"\n";}public static void main(String[] args){Complex c1 = new Complex();Complex c2 = new Complex();String output = "两个复数：\n"+c1+"\n"+c2+"\n"+"两个复数相加：\n"+c1.plus(c2)+"两个复数相减：\n"+c1.minus(c2)+"两个复数相乘：\n"+c1.times(c2)+"两个复数相除：\n"+c1.divideBy(c2)+"c1的共厄复数：\n"+c1.conjugate()+"c2的共厄复数：\n"+c2.conjugate(); JOptionPane.showMessageDialog(null,output);}}。
java语言程序设计实验报告篇一：Java实验八报告《Java语言程序设计》实验报告学生姓名：郭倩班级：信息112学号：201152275208实验地点：经管实验中心证券实验室指导教师：赵利平实验日期：实验环境：Windows 2000+JDK1.61. 实验目的（1）理解子类派生的概念（2）学习创建子类对象（3）掌握方法覆盖的使用2.实验内容（1）设计三个类：完成实验教材P52页程序清单4-2；（2）通过编制一个程序来加深对嵌套类、内部类和局部类的理解：完成实验教材P56页程序清单4-3；2. 实验过程报告撰写具体要求：上述实验内容要求写出源代码及运行结果。
实验内容（1）：//Polymorphism.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=null;}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;}}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+=courses[i];};average=total/CourseNo;if(average>=80&&average<100) coursegrade="优秀" else="" average="">=70&&average<80) coursegrade="良好" else="" average="">=60&&average<70) coursegrade="一般" else="" average="">=50&&average<60) courseGrade="及格";else courseGrade="不及格";}}class Postgraduate extends Student{public Postgraduate(String name){super(name);type="研究生";}public void calculateGrade(){int 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="" average="">=80&&average<90) coursegrade="良好"else="" average="">=70&&average<80) coursegrade="一般" else="" average="">=60&&average<70) courseGrade="及格";else courseGrade="不及格";}}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) 都有(2) Student[] students=new Student[5];(3) Student是抽象的,不能用new操作符创建抽象类的实例。
java流程控制实验总结英文回答：Java Flow Control Experiment Summary.Objective:The objective of this experiment was to explore the different flow control statements available in the Java programming language. Flow control statements allow programmers to control the execution flow of their programs, enabling them to make decisions and perform differentactions based on specific conditions.Materials:Java Development Kit (JDK)。
Java Integrated Development Environment (IDE)。
Methods:The following flow control statements were investigated:if-else: Conditional statement that executes a blockof code only if a given condition is true.switch-case: Conditional statement that executes a different block of code based on the value of a given variable.while: Loop statement that executes a block of code repeatedly as long as a given condition is true.do-while: Loop statement that executes a block of code at least once, even if the condition is false.for: Loop statement that executes a block of code a specified number of times.break: Statement that exits a loop or switch statement prematurely.continue: Statement that skips the remaining code in a loop iteration and proceeds to the next iteration.Results:Each flow control statement was implemented in a Java program and tested to verify its functionality. The results confirmed that Java provides a comprehensive set of flow control statements that enable programmers to effectively control the execution flow of their programs.Conclusion:This experiment provided valuable insights into the different flow control statements available in the Java programming language. By understanding and utilizing these statements, programmers can achieve greater control over the behavior of their programs and develop more efficient and reliable applications.中文回答：Java 流程控制实验总结。
淮海工学院计算机工程学院实验报告书课程名：《Java语言实验与课程设计指导》题目：实验3——深入面向对象编程班级：学号：姓名：实验题目：1.定义一个学生类，定义一个大学生类和小学生类，这两个类是学生类的子类；定义一个选课接口，由大学生类实现该接口，定义一个年龄异常处理，当小学生年龄小于7岁时，弹出异常。
2.定义一个银行卡类，定义一个信用卡类和普通银行卡类，这两个类是银行卡类的子类；定义一个透支的接口，信用卡可以透支，普通银行卡不可以透支。
定义一个取款异常和透支异常，当普通银行卡取款超过银行卡余额时，弹出“取款异常”；当信用卡透支超过2万元时弹出“透支异常”。
实验代码：题1源代码：import java.awt.*;class student{String number,name,sex,bj;int age;student(String xuehao,String xingming,String xingbie,int nianling,String banji){number=xuehao;name=xingming;sex=xingbie;age=nianling;bj=banji;}}interface xuanke{abstract void select(String s);}interface illegal{abstract void illegal(int s);}class primary extends student implements illegal{String xx;primary(String xuehao,String xingming,String xingbie,int nianling,String banji,String xiaoxue){super(xuehao,xingming,xingbie,nianling,banji);}public void illegal(int s){age=s;if(age<7)System.out.println("\n出错~学生"+name+" 的年龄过小！");}}class college extends student implements xuanke{String dx,xk;college(String xuehao,String xingming,String xingbie,int nianling,String banji,String daxue){super(xuehao,xingming,xingbie,nianling,banji);dx=daxue;}public void select(String s){xk=s;}}public class test_1{public static void main(String args[]){primary p1=new primary("1","张三","男",13,"五(1)班","ZZZ小学");System.out.println(p1.number+" "++" "+p1.sex+" "+p1.age+" "+p1.bj+" "+p1.xx);p1.illegal(p1.age);primary p2=new primary("\n2","小红","女",6,"一(1)班","YYY小学");System.out.println(p2.number+" "++" "+p2.sex+" "+p2.age+" "+p2.bj+" "+p2.xx);p2.illegal(p2.age);college c1=new college("3","小茗","女",20,"软件112","XXX大学");c1.select("现代密码学");System.out.print("\n"+c1.number+" "++" "+c1.sex+" "+c1.age+" "+c1.bj+" "+c1.dx+" "+c1.xk+"\n");}}实验结果：题2源代码：import java.util.*;class bankcard{String kh,name;double yue;bankcard(String kahao,String yezhu,double shengyu) {kh=kahao;name=yezhu;yue=shengyu;}}interface touzhi{abstract void tz(double s);abstract void tzye(double s);abstract void illegal();}interface qkillegal{abstract void illegal();}class common extends bankcard implements qkillegalcommon(String kahao,String yezhu,double shengyu){super(kahao,yezhu,shengyu);}public void warning(){System.out.println("普通银行卡不可透支！");}public void illegal(){System.out.println("取款超额！");}}class xinyongka extends bankcard implements touzhi{double tzye;xinyongka(String kahao,String yezhu,double shengyu){super(kahao,yezhu,shengyu);}public void tz(double s){tzye=s;}public void tzye(double s){double t=20000+yue-s;if(s>yue)System.out.println(t);}public void illegal(){System.out.println("透支超额！");}}public class test_3{public static void main(String args[]){common c1=new common("62226200240001916658","张三",1200.00);System.out.println("卡号:"+c1.kh+"业主:"++"余额:"+c1.yue);System.out.println("请输入取款金额:");Scanner s1=new Scanner(System.in);double b=s1.nextDouble();if(b<c1.yue){double c=c1.yue-b;System.out.println("银行卡余额为:"+c);}elsec1.illegal();System.out.println("\n\n");xinyongka x1=new xinyongka("62236200243008615559","李四",500.00);System.out.println("卡号:"+x1.kh+"业主:"++"余额:"+x1.yue);System.out.println("信用卡可透支！透支金额为20000元！");System.out.println("请输入要取款金额:");Scanner s2=new Scanner(System.in);double a=s2.nextDouble();if(a<=x1.yue){double d=x1.yue-a;System.out.println("银行卡余额为:"+d);}else if(a>x1.yue&&a<=(20000+x1.yue)){System.out.println("透支余额剩余:");x1.tzye(a);}elsex1.illegal();}}实验结果：普通银行卡类：输入普通银行卡取款金额若输入金额小于余额则若大于余额则信用卡类：输入取款金额，若输入金额小于余额则若输入金额大于余额小于透支金额与余额之和，则若大于透支金额与余额之和，则。
java实验心得体会在实验中，我深刻体会到了Java的面向对象特性。
在面向对象的编程思想中，一切皆为对象。
在Java中，类是一切的基础，通过定义类，我们可以创建对象，并在对象之间进行交互。
通过实验，我掌握了Java中类的定义、创建对象、成员变量和方法的使用等基础知识。
在实验中，我发现通过良好的面向对象设计，可以使程序结构清晰，易于维护和扩展。
同时，Java提供了丰富的面向对象特性，如封装、继承、多态等，可以帮助我们更好地组织和管理代码。
另外，实验也让我深刻理解了Java的跨平台特性。
Java编译后的字节码可以在任何支持Java虚拟机（JVM）的平台上运行，这使得Java具有较强的可移植性。
在实验中，我在不同的操作系统上运行了同一个Java程序，都可以得到相同的结果。
这让我深刻认识到了Java的跨平台特性，这也是Java被广泛应用的重要原因之一。
此外，实验也让我理解了Java的异常处理机制。
在Java中，异常是一个表示错误的对象，它可以在程序执行过程中被抛出，并通过try-catch-finally语句进行处理。
通过实验，我学会了如何正确地使用try-catch-finally语句，以及如何自定义异常类，实现程序的健壮性和可靠性。
在实验中，我还学会了如何使用Java的集合框架。
Java提供了丰富的集合类和工具类，如ArrayList、HashMap、LinkedList等，这些类可以帮助我们更方便地管理和操作数据。
通过实验，我深入了解了集合框架的各种使用方法和特性，加深了我对Java集合框架的理解和掌握。
此外，在实验中，我也学会了如何使用Java的多线程特性。
在当今的计算机系统中，多线程编程已经成为了越来越重要的技能。
Java提供了丰富的多线程支持，通过实验，我学会了如何创建线程、启动线程、同步线程等基础知识，加深了我对多线程编程的理解。
在实验中，我还学习了如何使用网络编程。
在当今互联网时代，网络编程已经成为了一个必备的技能。
实验三面向对象程序设计的继承、多态等特性的练习编写程序实现如下功能：已知Person类包含三个公共域变量（姓名、性别、年龄）和一个构造方法，Student类是Person类的派生类，包含两个新的公共域变量(学号、班号)、两个公共方法（修改年龄、显示基本信息）及一个构造方法。
定义一组学生对象，并初始化他们的基本信息，然后依次输出。
步骤（1）：定义类Person，并添加以下公共域变量public String name; public char sex; public int age;添加构造方法Person(String name,char sex,int age){……}步骤（2）：基于类Person派生类Student,并添加如下公共域变量和方法public String classno; public String sno;public void updateAge(int age){……}void toString(){……}Student(String name,char sex,int age,String sno,String name){ super(name,sex,age);…….}步骤（3）：定义一个包含main方法的Application程序类TestStudentPerson，初始化一个学生类对象数组,并利用循环语句显示所有学生基本信息。
源程序如下：class Person{ public String name;public char sex;public int age;Person(String name,char sex,int age){=name;this.sex=sex;this.age=age;}}class Student extends Person{ public String classno;public String sno;public void updateAge(int age){this.age=age;}void tostring(){System.out.println(name+'\t'+sex+'\t'+age+'\t'+classno+'\t'+sno);}Student(String name,char sex,int age,String classno,String sno){super(name,sex,age);this.classno=classno;this.sno=sno;}public class TestStudentPerson{public static void main(String arg[]){int i;Student s[]=new Student[5];s[0]=new Student("邓林",'男',20,"1002","201012135050");s[1]=new Student("陶毕",'男',21,"1001","201012135048");s[2]=new Student("方芳",'女',20,"1003","201012135047");s[3]=new Student("王清",'女',21,"1004","201012135056");s[4]=new Student("单凡",'女',22,"1001","201012135050");for(i=0;i<=4;i++)s[i].tostring();}}输入课本例5-4的源程序，观察其运行结果，然后将Shape类分别定义为一个抽象类和接口，然后将源程序进行修改，让其实现相同功能。
步骤（1）：在编辑调试工具中输入课本例5-4TestVirtualInvoke.java程序，编译运行，观察程序的运行结果，并思考为什么产生这样的结果。
源程序如下：class TestVirtualInvoke{static void doStuff(Shape s){s.draw();}public static void main(String args[]){Circle c=new Circle();Triangle t=new Triangle();Line l=new Line();doStuff(c);doStuff(t);doStuff(l);}}class Shape{void draw(){System.out.println("Shape Drawing");}}class Circle extends Shape{void draw(){System.out.println("Draw Circle");}class Triangle extends Shape{void draw(){System.out.println("Draw Three Line");}}class Line extends Shape{void draw(){System.out.println("Draw Line");}}运行结果如下图：因为Java在使用上溯造型的情况下，子类对象可以当做父类对象，对于重载或继承的方法，Java运行时系统根据调用该方法的实例的类型来决定选择哪个方法调用，在doStuff （）的代码里，调用draw（）时，根据Shape句柄当时所引用对象的实际类型，会相应地采取正确的操作。
在这里因为当Java编译器为doStuff（）编译代码时，它并不知道自己要操作的准确类型是什么。
但在运行时，却会根据实际的类型调用正确的方法。
这就是通过虚方法调用（动态绑定）来实现的面向对象程序设计的“多态形性”。
步骤（2）：将Shape类定义为abstact class Shape{……},然后重新定义Shape抽象类的派生类Circle、Triangle、Line，最后编译运行，观察程序的运行结果是否和上面的结果相同。
源代码如下：class TestVirtualInvoke{static void doStuff(Shape s){s.draw();}public static void main(String args[]){Shape c=new Circle();Shape t=new Triangle();Shape l=new Line();doStuff(c);doStuff(t);doStuff(l);}}abstract class Shape{abstract void draw();}class Circle extends Shape{void draw(){System.out.println("Draw Circle");}}class Triangle extends Shape{void draw(){System.out.println("Draw Three Line");}}class Line extends Shape{void draw(){System.out.println("Draw Line");}}运行结果如下图：由运行结果可知：与上面的结果一致。
步骤（3）：将Shape定义为interface Shape{……},然后基于Shape接口实现类Circle、Triangle、Line，最后编译运行，观察程序的运行结果是否和上面的结果相同。
源代码如下：class TestVirtualInvoke{static void doStuff(Shape s){s.draw();}public static void main(String args[]){Circle c=new Circle();Triangle t=new Triangle();Line l=new Line();doStuff(c);doStuff(t);doStuff(l);}}interface Shape{public void draw();}class Circle implements Shape{public void draw(){System.out.println("Draw Circle");}}class Triangle implements Shape{public void draw(){System.out.println("Draw Three Line");}}class Line implements Shape{public void draw(){System.out.println("Draw Line");}}运行结果如下图：由运行结果可知：与上面的结果一致。
3.思考题某小型公司，主要有三类人员：经理、兼职技术人员和兼职推销员。
这三类人员共同拥有的相关属性：姓名、编号；相关方法：获取当月薪水的getPay()方法、显示个人信息的toString()方法。
人员编号基数为1000，每创建一个人员实例对象，其编号属性的值顺序加1。
月薪计算方法：经理拿固定月薪8000元；兼职技术人员按每小时100元领取月薪；兼职推销人员的月薪按当月的销售额的4%提成。
要求：根据题意，自己确定需要定义的类及各类的属性、构造方法和其他方法，并编写Java Applcation程序实现功能：存储若干个职工信息，然后分行显示所有职工的姓名、编号、月工资等相关信息，另外计算所有职工的月薪总和并显示出来。
源程序如下：abstract class Employee{ String name; long no;static long id=1000;abstract double getPay();Employee(String name){ =name;id=id+1;}};class Manager extends Employee{ double pay=8000;double getPay(){return 8000;}Manager(String name){super(name);no=id; }public String toString(){return "姓名:"+name+" 编号:"+no+" 月薪:8000";} };class Sale extends Employee{ long saleNum; double getPay(){return saleNum*0.4;}Sale(String name,long saleNum){super(name); no=id; this.saleNum=saleNum;}public String toString(){return "姓名:"+name+" 编号:"+no+" 月薪:"+getPay();}}class Tech extends Employee{ long salaryHours; double getPay(){return salaryHours*100; }Tech(String name,long salaryHours){super(name);no=id;this.salaryHours=salaryHours;}public String toString(){return "姓名:"+name+" 编号:"+no+" 月薪:"+getPay();}};import java.io.BufferedReader;import java.io.IOException;import java.io.InputStreamReader;import java.util.Enumeration;import java.util.Vector;public class EmployApp{public static void main(String args[]){Vector v=new Vector();Employee em;double numPay=0;String s="";System.out.print("Please input the SalesGet:");try{BufferedReader in=new BufferedReader(new InputStreamReader(System.in)); s=in.readLine();}catch(IOException e){}int i=Integer.parseInt(s);String m="";System.out.print("Please input the Working Hours:");try{BufferedReader in=new BufferedReader(new InputStreamReader(System.in));m=in.readLine();}catch(IOException e){}int j=Integer.parseInt(m);v.addElement(new Sale("李玲(sale)",i));v.addElement(new Tech("陈冲(tech)",j));v.addElement(new Manager("Lisa(manager)"));v.addElement(new Manager("Jones(manager)"));Enumeration e=v.elements();while(e.hasMoreElements()){ em=(Employee)e.nextElement();numPay=numPay+em.getPay();System.out.println(em);}System.out.println("总工资:"+numPay);}};4.实验小结：通过本次试验基本掌握了类的继承机制，学会如何创建类并使用其继承机制，基本熟悉了类中的成员变量和方法的访问控制，并且学会如何正确使用这些访问控制符，熟悉了方法或构造方法多态性，学会了如何使用虚方法调用（动态绑定）来实现多态性，熟悉了接口的定义方法，并且基本掌握了接口的使用以及实现，进一步丰富了Java的程序设计学习。
