JAVA 实验报告一:面向对象特性实验
Java实验1_Java面向对象程序设计解析
实验1 Java面向对象程序设计【说明】⑴本文件是实验效果的模板文件,上缴电子资料时请将本说明删除掉。
在具体操作时,可将本文件换名另存,另存时在文件名前加上自己的学号和姓名,例如某个同学另存后文件名为“06261088王武鸣实验1_Java面向对象程序设计”。
⑵在本文件中,源程序格式要求:字体用“Times New Roman”,字号“五号”,行距为“固定值14磅”,段前和段后间距为“0行”,Tab缩进4个字符。
每个源程序要有足够的注释,例如:程序开头均需要有注释,说明程序的版本信息、程序的功能、编制者、编制日期及最后修改日期等;在声明每个方法、每个变量(形参、实参)前均应有注释,等等。
⑶实验中的测试数据应该全面考虑,特别是边界数据或异常数据的测试。
一、实验任务1源程序清单/*在本文件中,源程序格式要求:字体用“Times New Roman”,字号“五号”,行距为“固定值14磅”,段前和段后间距为“0行”,Tab缩进4个字符。
**/二、任务1实验数据及效果图1.测试用第1组数据2.第1组数据运行效果图(见图1)图1 实验任务1第1组测试数据运行效果图3.测试用第2组数据4.第2组数据运行效果图(见图2)图2 实验任务1第2组测试数据运行效果图5.测试用第3组数据6.第3组数据运行效果图(见图3)图3 实验任务1第3组测试数据运行效果图三、实验任务2源程序清单/*在本文件中,源程序格式要求:字体用“Times New Roman”,字号“五号”,行距为“固定值14磅”,段前和段后间距为“0行”,Tab缩进4个字符。
**/四、任务2实验数据及效果图1.测试用第1组数据2.第1组数据运行效果图(见图1)图1 实验任务2第1组测试数据运行效果图3.测试用第2组数据4.第2组数据运行效果图(见图2)图2 实验任务2第2组测试数据运行效果图5.测试用第3组数据6.第3组数据运行效果图(见图3)图3 实验任务2第3组测试数据运行效果图。
JAVA实验报告_Java类与对象
JAVA实验报告_Java类与对象贵州大学实验报告学院:计信学院专业:网络工程班级:101 姓名学号实验组实验时间05.11 指导教师肖源源成绩实验项目名称Java类与对象实验目的1)理解面向过程与面向对象区别2)理解面向对象的三大特征3)掌握类声明的方法4)掌握构造方法5)掌握对象的创建方法与创建机制6)掌握成员变量、类变量和局部变量区别7)掌握成员方法与类方法区别8)掌握函数的重载9)掌握4种访问修饰符的区别实验要求1.安装并设置Java SDK 软件包。
2.按要求编写程序完成实验指导所需实验要求。
3.调试并成功运行。
实验内容1、创建猴子类。
具体要求如下:1)编写一个类Monkey,用来表示猴子类;2)给Monkey类确定添加4个属性:3个实例成员变量(名字、体重、年龄)、1个静态成员变量(爱好:默认值为:吃香蕉);3)添加默认构造方法和有参构造方法(3个参数,分别给名字、体重和年龄赋初始值)4)编写展示猴子能够爬树(climbTree)的方法――提供两个参数传入:分别代码猴子的名字(name)和爬树的高度(height)(方法内只需打印猴子的”名字+会爬树,能爬+高度”)5)测试:在main方法中创建两个猴子对象monkey1(甲、50、3)和monkey2(乙、45、2),monkey1使用默认构造方法创建,monkey2使用有参构造方法创建。
分别打印出monkey1和monkey2的名字、体重、年龄和爱好。
并调用monkey1和monkey2的爬树方法。
2、创建矩形Rectangle类。
具体要求如下:1)创建一个Rectangle类;2)创建属性:两个double成员变量:width和height。
3)创建方法:计算矩形的周长getLength()和面积getArea()。
4)测试:创建Rectangle对象,并给两个成员变量赋值,调用周长和面积的方法,输出周长和面积。
实验数据实验总结整体实验基本达到要求,理解面向过程与面向对象区别,掌握类声明的方法,掌握对象的创建方法,掌握函数的重载等。
面向对象实习报告(共5篇)
面向对象实习报告(共5篇)第1篇:面向对象实习报告实习题目一1.三个自定义类本题有三个自定义的类:点类VecPosition,圆类circle,矩形类Rect,运用类的继承思想从这三个类中抽象出公共基类base。
其中base中有一个纯虚函数virtual void draw()=0; VecPosition类主要实现各个运算符的点的构造,运算符的重载,求两点距离,判断一个点是否在给定其他几个点的范围内,以及与向量有关的几何运算。
Circle类主要实现圆对象的构造,圆的相关参数设置,求取圆的周长函数(doubleCircle::getCircumference())、面积函数(double Circle::getArea()),判断一个点是否在圆内bool Circle::isInside(VecPosition pos),求两个圆交点函数int Circle::getIntersectionPoints(Circle c,VecPosition *p1,VecPosition *p2)返回加点个数。
求两个圆的相交面积double Circle::getIntersectionArea(Circle c)。
矩形由左上点坐标和右下点坐标确定。
包括矩形的构造,参数的设置修改,求矩形的面积,周长,以及判断一个点是否在矩形内。
2.可视化界面建立单文档工程,添加画图菜单,如下图:三个菜单项分别画点,画线,画矩形。
在view.h中添加如下变量:CPoint类的 m_oldpt,m_pt用于记录画图的起点坐标和终点坐标。
Circle m_circle,Rect m_rect,用于构造圆和矩形。
afx_msg voidOnLButtonDown(UINT nFlags, CPoint point)是响应鼠标按下的消息,并将当前坐标传给m_oldPoint。
用switch分支控制画图种类,在view类中加入变量i,添加三个菜单消息响应函数,对i进行赋值;当点击菜单项“点”时,i=0;当点击菜单项“圆” 时,i=1;当点击菜单项“矩形”时,i=2;在view中添加void C实º习一View::OnLButtonUp(UINT nFlags, CPoint point)用来响应鼠标左键弹起消息。
java编程实验报告
java编程实验报告Java编程实验报告引言:Java是一种广泛应用于软件开发领域的高级编程语言,具有跨平台、面向对象、安全性高等特点。
本篇文章将介绍我在Java编程实验中的实践和收获。
实验一:Hello World程序在本实验中,我学习了如何使用Java编写一个简单的Hello World程序。
通过这个实验,我了解了Java的基本语法和程序结构。
在编写过程中,我发现Java的语法规范相对严格,需要注意语句的结束符号和代码的缩进。
通过运行程序,我成功输出了"Hello World"这个简单的字符串,这让我对Java编程的基本流程和语法有了更深入的了解。
实验二:变量与运算符在本实验中,我学习了Java中的变量和运算符的使用。
通过编写程序,我实现了对不同类型的变量进行声明和赋值,并进行基本的运算操作。
在这个过程中,我发现Java的变量需要先声明后使用,而且在进行运算时需要注意数据类型的匹配。
通过这个实验,我对Java中的变量和运算符有了更深入的理解。
实验三:条件语句与循环结构在本实验中,我学习了Java中的条件语句和循环结构的使用。
通过编写程序,我实现了对不同条件进行判断,并根据不同的条件执行相应的操作。
同时,我还学习了循环结构的使用,通过循环语句实现了对一段代码的重复执行。
在这个实验中,我发现条件语句和循环结构是Java编程中非常重要的部分,能够帮助程序实现更复杂的逻辑。
实验四:数组和字符串在本实验中,我学习了Java中数组和字符串的使用。
通过编写程序,我实现了对数组和字符串的声明、赋值和操作。
在这个过程中,我发现Java中的数组和字符串是一种非常方便的数据结构,能够帮助程序处理大量的数据。
通过这个实验,我对Java中数组和字符串的使用有了更深入的了解。
实验五:面向对象编程在本实验中,我学习了Java中的面向对象编程的基本概念和使用。
通过编写程序,我实现了对类的定义、对象的创建和方法的调用。
面向对象设计原则实验报告实验01
面向对象设计原则实验报告1.1实验目的1. 通过实例深入理解和掌握所学的面向对象设计原则。
2.熟练使用面向对象设计原则对系统进行重构。
3.熟练绘制重构后的结构图(类图)。
1.2实验内容1.在某绘图软件中提供了多种大小不同的画笔(Pen),并且可以给画笔指定不同颜色,某设计人员针对画笔的结构设计了如图1-1所示的初始类图。
通过仔细分析,设计人员发现该类图存在非常严重的问题,即如果需要增加一种新的大小或颜色的笔,就需要增加很多子类,例如增加一种绿色的笔,则对应每一种大小的笔都需要增加一支绿色笔,系统中类的个数急剧增加。
试根据依赖倒转原则和合成复用原则对该设计方案进行重构,使得增加新的大小或颜色的笔都较为方便,请绘制重构之后的结构图(类图)。
2.在某公司财务系统的初始设计方案中存在如图1-2所示的Employee类, 该类包含员工编号(ID),姓名(name),年龄(age).性别(gender)、薪水(salary)、每月工作时数( workHoursPerMonth),每月请假天数(leaveDaysPerMonth)等属性。
该公司的员工包括全职和兼职两类,其中每月工作时数用于存储兼职员工每个月工作的小时数,每月请假天数用于存储全职员工每个月请假的天数。
系统中两类员工计算工资的万法也不一样,全职员工按照工作日数计算工资﹐兼职员工按照工.作时数计算上资﹐内此在 Employee 类中提供了两个方法calculateSalaryByDays()和calculateSalaryByHours(),分别用于按照大数和时数计算工资,此外,还提供了方法displaySalary()用于显示工资。
试采用所学面向对象设计原则分析图1-2中Employee类存在的问题并对其进行重构绘制重构之后的类图。
3.在某图形界面中存在如下代码片段,组件类之间有较为复杂的相互引用关系:如果在上述系统中增加一个新的组件类,则必须修改与之交互的其他组件类的源代码,将导致多个类的源代码需要修改。
Java的面向对象特性实验
Java的面向对象特性实验一二、题目实现类Windows操作系统的计算器功能实现功能如图所示,简版和科学计算器均可。
主要功能:1、实现清空文本框的功能;2、完成数字按钮功能;3、完成基本四则运算与连续运算的功能。
4、自定义最大化、最小化、关闭按钮的功能,使界面布局显示良好。
三、题目分析:1.首先先讨论计算器的图形结构因为计算器包括数字框架,运算符号框架,清零符号和删除符号框架以及显示框架。
经过设计,是为原图。
我们将主页面分为两部分。
一为显示页面显示页面JLabel showPanel = new JLabel();二为按钮页面分为1. m1为数字1 2 3 4 5 6 7 8 92.m2为% + - * = /3.m3为删除清空2.事件的操作与运行首先考虑到小数点的输入,其次是* + - /的运行,删除键和清空键的运行3.程序调试四、小组讨论内容:图形的设计规划按钮分为一块还是三块主函数中要不要添加一些方法还有一些数据的测试其实,整个程序都是讨论出来的,所以具体的我就说这几个吧……(例程的结果与分析;小组各组员程序的评估;先独立完成再总体讨论,各自实现过程可进行局部问题的讨论,再比较、分析、评估;最后再完善程序;大作业给出设计类图)五、程序实现:package text;import java.awt.BorderLayout;import java.awt.GridLayout;import java.awt.event.ActionEvent;import java.awt.event.ActionListener;import javax.swing.*;public class Calculator extends JFrame {JPanel mainpanel = new JPanel();//整个页面JPanel btonPanel = new JPanel();//操控按钮分布图JLabel showPanel = new JLabel();//运算输入和输出显示页面boolean start;boolean isExist;double result;String command;public static void main(String[] args) {new Calculator();}public Calculator() {main1();}//定义addButton方法public void addButton(String content,ActionListener listener) {JButton button = new JButton(content);button.addActionListener(listener);btonPanel.add(button);//将按钮加入btonPanel中}public void main1() {this.setSize(400,300);//整个页面长400,宽300this.setVisible(true);//可视this.setLocationRelativeTo(null);//将窗口将置于屏幕的中央this.setDefaultCloseOperation(EXIT_ON_CLOSE);//用户单击窗口的关闭按钮时程序执行的操作this.setTitle("简易计算器");//整个页面的名字start = true;isExist = false;command = "=";result = 0.0;mainpanel.setLayout(new BorderLayout());//设置布局为边框布局,边框布局分东南西北中5个方位来添加控件。
面向对象实验报告
面向对象实验报告面向对象实验报告引言:面向对象编程是一种软件开发方法,它将现实世界中的事物抽象成对象,通过定义对象的属性和行为来描述其特征和功能。
本实验旨在通过实际操作,深入理解面向对象编程的概念和原则。
一、实验背景面向对象编程是计算机科学领域的重要概念之一,它具有封装、继承和多态等特性,可以提高代码的可重用性和可维护性。
在本实验中,我们将通过编写一个简单的学生管理系统来探索面向对象编程的实际应用。
二、实验目的1. 理解面向对象编程的基本概念和原则;2. 掌握类的定义、对象的创建和方法的调用;3. 熟悉封装、继承和多态的使用;4. 实践面向对象编程的思维方式和方法论。
三、实验过程1. 类的定义在学生管理系统中,我们首先需要定义一个学生类,包含学生的基本信息,如学号、姓名、年龄等。
通过封装这些属性和定义相应的方法,我们可以实现对学生对象的创建和操作。
2. 对象的创建在主程序中,我们可以通过实例化学生类来创建学生对象。
通过调用构造函数,为学生对象赋予具体的属性值。
例如,创建一个名为Tom的学生对象,可以使用以下代码:Student tom = new Student("001", "Tom", 18);3. 方法的调用定义了学生类后,我们可以为其添加一些方法,如获取学生信息、修改学生信息等。
通过调用这些方法,可以实现对学生对象的操作和管理。
例如,获取Tom的年龄可以使用以下代码:int age = tom.getAge();4. 继承的应用在学生管理系统中,我们可以将学生类作为基类,派生出一些特定类型的学生类,如研究生、本科生等。
通过继承,子类可以继承基类的属性和方法,并可以添加自己特有的属性和方法。
这样,我们可以更好地组织和管理不同类型的学生对象。
5. 多态的实现通过使用多态,我们可以在不同的上下文中使用同一个方法名,实现不同的功能。
例如,在学生管理系统中,我们可以定义一个统一的显示信息方法,然后在不同的学生类中重写该方法,以实现不同类型学生的信息展示。
面向对象技术实训报告
一、摘要本次面向对象技术实训以Java编程语言为基础,通过实例分析和实践操作,让学生深入了解面向对象编程的基本概念、原则和方法。
实训过程中,学生掌握了面向对象编程的基本语法、类和对象的设计与实现、继承与多态等核心概念,并通过实际项目开发提高了编程能力。
本文将从实训内容、方法与收获三个方面进行总结。
二、实训内容1. 面向对象基本概念(1)面向对象编程(OOP)的基本概念:封装、继承、多态。
(2)Java编程语言中的面向对象编程特性:类、对象、构造方法、访问控制符等。
2. 类和对象的设计与实现(1)设计一个简单的Java程序,实现学生信息管理系统。
(2)设计并实现学生类、教师类、课程类等实体类,以及相关的方法。
3. 继承与多态(1)使用继承实现学生类和教师类的继承关系。
(2)通过多态实现不同类对同一方法的重写和重载。
4. 实际项目开发(1)设计并实现一个图书管理系统,包括图书类、读者类、借阅类等。
(2)实现图书的借阅、归还、查询等功能。
三、实训方法1. 理论学习:通过阅读教材、参考书籍,了解面向对象编程的基本概念和原理。
2. 实践操作:根据实训内容,动手编写Java程序,实现面向对象编程。
3. 交流与讨论:在实训过程中,与其他同学进行交流与讨论,共同解决遇到的问题。
4. 查阅资料:针对遇到的具体问题,查阅相关资料,提高编程能力。
四、实训收获1. 理论知识:掌握了面向对象编程的基本概念、原则和方法,为后续课程和实际项目开发奠定了基础。
2. 编程能力:通过实际项目开发,提高了编程能力,学会了如何将理论知识应用到实际项目中。
3. 团队协作:在实训过程中,与其他同学进行交流与讨论,提高了团队协作能力。
4. 问题解决能力:在遇到问题时,能够主动查阅资料、请教他人,提高了问题解决能力。
五、总结本次面向对象技术实训使我受益匪浅,不仅加深了对面向对象编程的理解,还提高了编程能力。
在今后的学习和工作中,我会继续努力,将所学知识运用到实际项目中,为我国信息技术领域的发展贡献自己的力量。
Java实验报告面向对象
实验报告学年第学期任课老师:m=max[i];}}System.out.println("5个人中java成绩最大值是:"+m);}}实验结果分析与总结1、程序运行结果(请提供所完成的各道题运行结果界面截图):2、在实验过程中遇到的问题与解决方法:实验中并未有太多技术上的问题,除了对软件运用的不够熟练造成最初的一些错误,比如,用Jcreator时未编译便运行,一直出错,检查多次后才发现此处与eclipse的不同(上机时没问题,写实验报告用的Jcreator出错了,所以是软件用的不熟记错的缘故。
)而且要先编译Student类才可编译Main。
3、实验过程中的发现与收获,未解决或需进一步解决的问题:实验中的发现便是java其实较C/C++简单许多,很多东西都不要自己多加考虑,但试验还是太少所以会在一些小的细节方面浪费很多时间。
指导老师评阅意见指导老师:年月日填写内容时,可把表格扩大。
附:实验源程序代码//Mainpackage Test;public class Main {public static void main(String[] args) {Main ma=new Main();Student stu1=new Student();stu1.setAge(18);stu1.setJava(86);stu1.setName("aaa");stu1.setNo("001");stu1.setSex("M");int a=stu1.getJava();System.out.println("第一个学生的信息为:\r\n"+"姓名是:"+stu1.getName()+"\r\n"+"年龄是:"+stu1.getAge()+"\r\n"+"性别是:"+stu1.getSex()+"\r\n"+"学号是:"+stu1.getNo()+"\r\n"+"成绩是:"+stu1.getJava()+"\r\n");Student stu2=new Student();stu2.setAge(18);stu2.setJava(90);stu2.setName("bbb");stu2.setNo("011");stu2.setSex("M");int b=stu2.getJava();System.out.println("第二个学生的信息为:\r\n"+"姓名是:"+stu2.getName()+"\r\n"+"年龄是:"+stu2.getAge()+"\r\n"+"性别是:"+stu2.getSex()+"\r\n"+"学号是:"+stu2.getNo()+"\r\n"+"成绩是:"+stu2.getJava()+"\r\n");System.out.println("两个人的java平均成绩为:"+(stu1.getJava()+stu2.getJava())/2);Student stu3=new Student();stu3.setAge(20);stu3.setJava(76);stu3.setName("ccc");stu3.setNo("067");stu3.setSex("F");int c=stu3.getJava();System.out.println("第三个学生的信息为:\r\n"+"姓名是:"+stu3.getName()+"\r\n"+"年龄是:"+stu3.getAge()+"\r\n"+"性别是:"+stu3.getSex()+"\r\n"+"学号是:"+stu3.getNo()+"\r\n"+"成绩是:"+stu3.getJava()+"\r\n");Student stu4=new Student();stu4.setAge(19);stu4.setJava(100);stu4.setName("ddd");stu4.setNo("09091219");stu4.setSex("M");int d=stu4.getJava();System.out.println("第四个学生的信息为:\r\n"+"姓名是:"+stu4.getName()+"\r\n"+"年龄是:"+stu4.getAge()+"\r\n"+"性别是:"+stu4.getSex()+"\r\n"+"学号是:"+stu4.getNo()+"\r\n"+"成绩是:"+stu4.getJava()+"\r\n");Student stu5=new Student();stu5.setAge(22);stu5.setJava(89);stu5.setName("eee");stu5.setNo("097");stu5.setSex("F");int e=stu2.getJava();System.out.println("第五个学生的信息为:\r\n"+"姓名是:"+stu5.getName()+"\r\n"+"年龄是:"+stu5.getAge()+"\r\n"+"性别是:"+stu5.getSex()+"\r\n"+"学号是:"+stu5.getNo()+"\r\n"+"成绩是:"+stu5.getJava()+"\r\n");int max[]={a,b,c,d,e};int m=max[0];for(int i=0;i<5;i++){if(m<max[i]){m=max[i];}}System.out.println("5个人中java成绩最大值是:"+m);}}//Student类package Test;public class Student {private String sNo;private String sName;private String sSex;private int sJava;private int sAge;//set方法public void setJava(int java){sJava=java;;}public void setAge(int age){sAge=age;}public void setNo(String no){sNo=no;}public void setName(String name){ sName=name;}public void setSex(String sex){sSex=sex;}//get方法public int getJava(){return sJava;}public int getAge(){return sAge;}public String getNo(){return sNo;}public String getName(){return sName;}public String getSex(){return sSex;}}。
java面向对象实验报告
java面向对象实验报告《Java面向对象实验报告》摘要:本实验报告旨在探讨Java面向对象编程的基本概念和实践方法。
通过实验,我们将学习如何创建类、对象、封装、继承和多态等面向对象的特性,并通过实际代码演示这些概念的应用。
本报告将详细介绍实验过程和结果,并总结所得到的经验和教训。
一、实验目的1. 了解面向对象编程的基本概念和原则2. 掌握Java语言中类、对象、封装、继承和多态的使用方法3. 通过实验加深对面向对象编程的理解和掌握二、实验环境1. Java开发环境:Eclipse/IntelliJ IDEA等2. Java SDK版本:1.8及以上三、实验内容1. 创建一个简单的Java类2. 创建对象并调用对象方法3. 实现类的封装和访问控制4. 实现类的继承和方法重写5. 实现类的多态四、实验步骤1. 创建一个名为Person的Java类,包含姓名和年龄两个私有属性,并提供公有的get和set方法进行访问和修改。
2. 创建一个名为Student的子类,继承Person类,并重写父类的get方法。
3. 创建一个名为Teacher的子类,继承Person类,并重写父类的get方法。
4. 创建一个名为Main的主类,实例化Person、Student和Teacher对象,并调用其方法进行测试。
五、实验结果1. 成功创建了Person、Student和Teacher三个类,并实现了类的封装、继承和多态。
2. 通过测试,验证了类的封装和访问控制的有效性。
3. 通过测试,验证了类的继承和方法重写的有效性。
4. 通过测试,验证了类的多态的有效性。
六、实验总结通过本次实验,我深刻理解了面向对象编程的重要性和优势,掌握了Java语言中面向对象编程的基本概念和实践方法。
在今后的学习和工作中,我将继续加强对面向对象编程的理解和应用,不断提高自己的编程水平。
七、实验感想通过本次实验,我对Java面向对象编程有了更深入的了解,也更加熟练地掌握了面向对象编程的基本概念和实践方法。
JAVA 实验报告一:面向对象特性实验
实验报告实验项目一Java面向对象特性实验多态性与动态绑定一、实验目的1.掌握多态性在继承中的运用;2.理解动态绑定的含义;3.学会使用抽象类;4.了解成员变量的隐藏。
二、实验内容假设某班级里既有本科生也有研究生,请编写程序统计出全班学生的成绩等级并显示出来。
.三、实验原理Java上溯造型技术、抽象类、继承性、多态性、动态绑定等技术原理。
四、实验环境主CPU 586以上,内存1G以上,操作系统Windows XP,eclipse 。
五、实验步骤1、创建一个Polymorphism.java 项目图 1 创建Polymorphism.java 项目。
2、创建类 Polymorphism。
图 2 创建类 Polymorphism 3、创建抽象类Student图 3 抽象类Student4.创建继承于Student的Undergraduate类图 4 Undergraduate类5. 创建继承于Student的Postgraduate类图 5 创建Postgraduate类所有类如下:图 6 创建所有类后6.在各类中补充代码,并输入相对应的代码可得。
6.1 抽象类Studentabstract 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="" ; //初始化courseGrade为空串代码1 }public abstract void calculateGrade();public String getName( ){return name;}public String getType( ){return type;//代码2 //返回学生类型}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按课程索引号设置课程成绩}}6.2 创建继承于Student的Undergraduate(本科生)类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]; // 代码4 // 累加各门课程成绩};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 = "不及格";}}6.3 创建继承于Student的Postgraduate(研究生)类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 if (average>=80&&average<90) courseGrade = "良好";else if (average>=70&&average<80) courseGrade = "一般";else if (average>=60&&average<70) courseGrade = "及格";else courseGrade = "不及格";}}6.4 创建类 Polymorphismpublic 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("梁欣欣"); // 代码5 // 创建姓名为梁欣欣的Postgraduate对象students[4]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( ));}}}六、实验结果运行可得如下实验结果:图 7 实验运行结果七、实验分析7.1在 Polymorphism 类中有一个循环语句用来计算每个学生的成绩等级for(int i=0;i<5;i + +){student[i].calculateGrade();}这里的 calculateGrade() 方法,如果对象是研究生,即按照研究生的标准来计算。
Java面向对象实验报告
实验一:JAVA输入与输出的应用一、实验目的(1)理解流类的概念和意义(2)掌握标准的输入输出及标准错误(3)文件操作,对流类进行读取,掌握其构造器方法二、实验设备个人计算机windows XP,JDK1.5编译开发环境、Eclipse文本编辑器。
三、实验步骤、方法与要求实验一;编写一个程序,分别统计并输出文本文件中元音字母a e i o u 的个数实验二;编程实现以下功能,在屏幕上显示输入姓名,然后将用户输入的姓名保存到文本文件中,重复进行,直到用户输入空字符串为止。
四、实验结果示例1:实验一2:实验二五、程序清单列出完成上述实验步骤所要求编写的程序源代码实验一:package chapter10;import java.io.File;import java.io.FileInputStream;import java.io.FileNotFoundException;import java.io.IOException;public class Test {public static void main(String[] args) throws IOException { int ch;File file1=new File("F:\\蔺永虎作业\\TestFile.txt");try {@SuppressWarnings("resource")FileInputStream fin=new FileInputStream(file1);System.out.println("文件中的信息为:");ch=fin.read();while(ch!=-1){System.out.print((char)ch);ch=fin.read();}FileInputStream fin1=new FileInputStream(file1);int s,aa=0 ;s=fin1.read();while(s!=-1){char c= (char) s;if(c=='a'){aa++;}s=fin1.read();}System.out.println(" TestFile.txt中a的个数为:"+aa);fin1.close();} catch (FileNotFoundException e) {e.printStackTrace();} catch (IOException e) {e.printStackTrace();}}}实验二;package chapter10;import java.io.*;public class ImputName{public static void main(String args[]) throws IOException{String s;InputStreamReader isr=new InputStreamReader(System.in);BufferedReader br=new BufferedReader(isr);FileWriter fw=new FileWriter("F:\\蔺永虎作业.\\InputName.txt"); BufferedWriter bw=new BufferedWriter(fw);System.out.println("请输入姓名:(以空行结束)");while(true){System.out.println("输入姓名: ");System.out.flush();s = br.readLine();if(s.length()==0)break;bw.write(s);bw.newLine();}br.close();bw.close();System.out.println("输入的姓名存入到F:\\蔺永虎作业.\\InputName.txt");}}六、实验总结这次的实验对以自己的流方式向文件中写入的这种类型的题,有了进一步的了解,而且对于这种异常处理的方法,也有了更深一步的印象,DataOutputStream可以把各种丰富类型的数据写入磁盘,在实际操作中用的这种方法,也可以解决很多不同类对象。
面向对象实验报告Java
max1=i;
max2=j;
max3=k;
if (max1<max2){
s=max1;max1=max2;max2=s;
}
if (max1<max3){
s=max1;max1=max3;max3=s;
}
if (max2<max3){
s=max2;max2=max3;max3=s;
}
}
void sort(int t1,int t2[]){ //父类中的方法用来实现升序
//用选择法按升序排列
for(i=0;i<t1-1;i++){
k=i;
for(j=i+1;j<t1;j++)
if(t2[j]<t2[k]) k=j;
if (k!=i){
swap=t2[i];
t2[i]=t2[k];
}
}
public class Class1{
public static void main (String args[]){
Sort2or3 m1 = new Sort2or3();
m1.sort(100,200);
System.out.println("两个数从大到小为:"+m1.max1+","+m1.max2);
t2[k]=swap;
}
}
}
}
class sub_sort_Demo extends sort_Demo{
void sort(int t1,int t2[]){ //子类中的方法实现降序
//用选择法实现降序排列
for(i=0;i<t1-1;i++){
java面向对象编程实验报告
java面向对象编程实验报告篇一:java面向对象编程实验报告信息工程学院Java程序设计实验/实习报告学院:信息工程学院班级:信息112 姓名:吴连梅学号:XX013305 成绩:A实验二面向对象编程1.实验目的(1)掌握类与对象基本知识;(2)Java中的继承机制及包(package)、接口(interface)等的设计方法;(3)掌握static、this、super等关键字的使用;(4)掌握Java中两种比较器的用法。
2.实验内容实验题 1 定义一个类Book,包含两个属性:一个是private的String类型的属性title、一个是private的float类型的属性listPrice,封装这两个属性的四个方法setTitle()和getTitle()、setListPrice( )和geListPrice ()。
基本要求:(1)设计类Book及类BookManagement,在类BookManagement中输出Book类的对象的两个private属性;(2)重写父类的toString()方法,实现Book类实例的两个属性的输出。
实验过程:新建工程后,在工程下面建立一个包Book,在包下再建立一个Book类,类中包含两个属性,一个是private的String类型的属性title、一个是private的float类型的属性listPrice,之后是封装这两个属性的四个方法,用快捷键Alt+Shift+S选择gennerate Getters and Setters,再实验报告的内容与格式按任课教师的要求书写。
然后就是重写父类的toString()方法,用快捷键Alt+Shift+S选择gennerate toString,快捷重写。
这段程序写完是这样的:接下来便是BookManagement类,在包book下新建一个类BookManagement,写完的程序是这样的:BookManagement类中创建了书的对象,在主方法中调用output函数,赋值,输出。
java《Java程序设计》实验报告1:Java面向对象程序设计
开课实验室:现代信息交流中心403开课时间:2019年**月**日实验报告:2019年11月2日一、实验目的:熟悉和掌握Java中的面向对象编程,包括类、属性、方法、构造方法。
二、实验内容:1. 定义一个矩形类Rectangle:(1)属性:长length、宽width(2)方法:getArea()求面积、getPerimeter()求周长,showAll()分别在控制台输出长、宽、面积、周长(3)构造方法Rectangle(width, length),分别给两个属性赋值编写测试类,创建Rectangle对象,并输出相关信息。
2. 设计一个类Student:(1)属性包括姓名、学号和成绩(2)方法,按照成绩从高到低的顺序输出姓名、学号和成绩信息。
编写测试类运行上面的方法。
3. 编写复数类Complex,使用该类验证两个复数2+2i 和3+3i 相加产生一个新的复数5+5i 。
复数类Complex 满足如下要求:(1)属性:RealPart : int型,代表复数的实数部分;ImaginPart : int型,代表复数的虚数部分(2)方法:Complex( ) : 构造方法,将复数的实部和虚部都置0Complex( int r , int i ) : 构造方法,形参r 为实部的初值,i为虚部的初值。
Complex complexAdd(Complex a) : 将当前复数对象与形参复数对象相加,所得的结果仍是一个复数值,返回给此方法的调用者。
String toString( ) : 把当前复数对象的实部、虚部组合成a+bi 的字符串形式,其中a 和b分别为实部和虚部的数据。
编写测试类对其进行测试。
三、源代码清单:1.源代码清单package text1;public class Rectangle {float length,width;Rectangle(float width, float length) {this.width = width;this.length = length;}double getArea(){return length*width;}double getPerimeter(){return 2*(length+width);}void showAll(){System.out.println("长:"+length);System.out.println("宽:"+width);System.out.println("面积:"+getArea());System.out.println("周长:"+getPerimeter());}public static void main(String args[]) {Rectangle a = new Rectangle(2, 5);a.showAll();}}2.源代码清单package text;public class student {String name;int id;private float score;student(String name,int id,int score){=name;this.id=id;this.score=score;}void show() {System.out.println("id:"+id+",name="+name+",score="+score);}public static void sort(student[] stus) {student stu;for(int i = 0;i < stus.length-1;i++) {for(int j = 0;j < stus.length - i - 1;j++) {if(stus[j].score < stus[j+1].score) {stu = stus[j];stus[j] = stus[j+1];stus[j+1] = stu;}}}}public static void main(String[] args) {student[] stus = new student[3];stus[0] = new student("董山炮", 1, 59);stus[1] = new student("丁朵朵", 2, 96);stus[2] = new student("大狗", 3, 77);student.sort(stus);for(student stu : stus) {stu.show();}}}3. 源代码清单package text;public class complex {int RealPart;int ImaginPart;complex(){this.RealPart = 0;this.ImaginPart = 0;}complex(int r,int i){RealPart = r;ImaginPart = i;}int getRealPart(){return this.RealPart;}public int getImaginPart(){return this.ImaginPart;}complex complexAdd(complex a){int RealPart = this.RealPart + a.getRealPart();int ImaginPart = this.ImaginPart + a.getImaginPart();return new complex(RealPart, ImaginPart);}public String toString(){return this.RealPart + "+" + this.ImaginPart + "i";}public static void main(String[] args){complex a = new complex(2,2);complex b = new complex(3,3);complex sum = plexAdd(b);System.out.println(a + "+" + b + "=" +sum ); }}四、运行结果:(给出运行结果贴图)。
java实验报告——对象和类
成绩:面向对象原理与Java实践课程实验报告实验1:对象和类姓名 ____班级 ____学号 ____实验地点 ____实验时间 ____指导教师 ____面向对象原理与Java实践课程实验报告实验1:对象和类一、实验目的:●掌握类的定义及应用方法●掌握对象的创建方法,了解实例变量、实例方法和静态字段的特性●体会Java在类和对象的设计中体现的面向对象的思想二、实验要求:●具备Java基础知识(教材第1、2章内容)●掌握Java中对象和类的基本概念和应用方法(教材第3章内容)●设计类时注意保证类的封装性●编写程序完成以下实验内容并上交实验报告(包括电子文档与纸质文档)三、实验内容:设计并实现一个“广石化院电信学院学生通信录”系统。
系统采用字符界面,在出现的主界面中按提示输入相应字符以选择“增加”、“删除”、“修改”、“查找”等功能进行操作(其中“查找”功能除能够查找某个学生的信息之外,还能够显示所有学生的信息)。
记录的存储可采用数组或链表的方式。
四、设计思路:为了实现该系统,首先要需要两个类;一个类为主界面服务,用于接收用户输入信息以及做出相关反应;一个类为学生信息服务,定义学生通讯录信息的各个字段,以及操作字段的各个方法,考虑到部分字段的属性问题,所以将操作方法都写在学生类中,不再另外放置在其他类中。
学生信息将会采用学生类的对象数组来储存。
五、程序源代码:下面是ZhuJieMian 主界面类package pkg_TXL;import java.util.Scanner;public class ZhuJieMian{/**** 该类为通讯录系统的主界面提供主要功能显示,以及负责主菜单与子菜单的正常跳转*/public static void main(String[] args){// TODO Auto-generated method stub//XueShengXinXi[] Stu=ChuShiHua(); //初始化系统数据XueShengXinXi[] Stu=new XueShengXinXi[100];Stu[0]=new XueShengXinXi("专业", "班级", "姓名", "性别", "电话", "家庭住址");Stu[1]=new XueShengXinXi("自动化", "自动化10-1", "张三", "男", "63256", "fnhjfdhsdbh");Stu[2]=new XueShengXinXi("自动化", "自动化10-2", "李四", "女", "653256", "nfhggdfddhsdbh");Stu[3]=new XueShengXinXi("电子", "电子10-1", "王五", "男", "6156", "fnhvjbh");Stu[4]=new XueShengXinXi("电子", "电子10-2", "小红", "女", "63956", "asdfnhjbh");Stu[5]=new XueShengXinXi("网络", "网络10-1", "小明", "男", "656", "nfgdgfnhjbh");Stu[6]=new XueShengXinXi("网络", "网络10-2", "小芳", "女", "62215", "nfgdmmmdfhbdsh");Stu[7]=new XueShengXinXi("计算机", "计算机10-1", "黄龙", "男", "65584", "bbbdddfnhjbh");Stu[8]=new XueShengXinXi("计算机", "计算机10-2", "陈玲", "女", "666114", "mjgfddddfnhjbh");Stu[9]=new XueShengXinXi("测控", "测控10-1", "赵小斌", "男", "644814", "fthnrehbkjhjbh");Stu[10]=new XueShengXinXi("测控", "测控10-2", "钱颖", "女", "63641", "dbfsvnnhjbh");Stu[11]=new XueShengXinXi("电信", "电信10-1", "孙武", "男", "6321514", "mmhmgvvdfnhjbh");Stu[12]=new XueShengXinXi("电信", "电信10-2", "李雨", "女", "6314", "43ghffvvdfnhjbh");for(int x=13;x<Stu.length;x++){Stu[x]=new XueShengXinXi();}System.out.println("欢迎使用广石化电信学院通讯录系统!");ZhuJieMian: for(int exit=0;exit==0;)//exit为退出主菜单的指示变量,0为不退出,非0为退出{System.out.println();System.out.println("************************************");System.out.println("****************主菜单****************");System.out.print(" 1。
java实验报告
java实验报告一、实验目的本次实验的目的是深入了解Java的基本语法和面向对象编程的思想。
通过实践,掌握Java的常用工具和类库,并能熟练使用Java进行编程和调试。
二、实验内容1.环境搭建在本次实验中,我们使用Eclipse作为Java的开发工具,需要安装JDK环境和相关插件。
安装完毕后,我们需要进行相关配置,如添加JDK环境变量,设置Eclipse编译选项等。
2.基本语法和数据类型Java的基本语法和数据类型是Java编程的基础,需要掌握Java的变量、运算符、流程控制语句等基本知识。
在实验中,我们将会练习Java的语法和数据类型的使用,如输出文本、计算数值、定义变量等。
3.面向对象编程思想Java是一门面向对象的编程语言,面向对象思想是Java编程的核心。
在本次实验中,我们将学习Java的类、对象、继承、多态等面向对象的知识,并通过实践来理解和熟悉Java面向对象编程的思想。
4.常用类库和工具Java有丰富的类库和工具,如集合类、IO类、网络编程类等。
在本次实验中,我们将会了解并运用Java的常用类库和工具来实现一些简单的功能,如读写文件、网络通信等。
三、实验步骤1.环境搭建与配置安装JDK环境和Eclipse开发工具,并将JDK环境添加到系统环境变量中。
然后进入Eclipse,设置编译选项和相关插件,如Java自动补全、eclipse编译和调试工具等。
2.基本语法和数据类型基于Java的基本语法和数据类型,我们可以编写一些简单的程序,如输出HelloWorld、计算数字和变量赋值等。
这些程序可以通过Eclipse自带的编译器进行调试和运行。
3.面向对象编程思想通过学习Java的面向对象编程思想,我们可以定义一个类和对应的对象,使用继承和多态来实现复杂的业务逻辑,并使用接口和内部类等技术来封装数据和实现较复杂的功能。
4.常用类库和工具在实践中,我们会用到常用的类库和工具,如java.io包和包。
面向对象方法实验报告
一、实验目的1. 理解面向对象方法的基本概念和原理;2. 掌握面向对象程序设计的基本技能;3. 通过实际编程,提高面向对象编程能力。
二、实验环境1. 操作系统:Windows 102. 编程语言:Java3. 开发工具:Eclipse三、实验内容1. 面向对象方法的基本概念2. 类和对象的创建与使用3. 继承和多态的应用4. 抽象类和接口的使用5. 面向对象程序设计实例四、实验步骤1. 面向对象方法的基本概念面向对象方法是一种编程范式,它将问题域中的对象抽象成类,并通过对象之间的关系来描述问题。
面向对象方法具有以下特点:(1)封装:将数据和操作数据的方法封装在一起,形成一个独立的实体。
(2)继承:允许一个类继承另一个类的属性和方法,实现代码复用。
(3)多态:允许不同类型的对象对同一消息做出不同的响应。
2. 类和对象的创建与使用(1)定义类:使用class关键字定义一个类,包括属性和方法。
(2)创建对象:使用new关键字创建一个类的实例。
(3)访问对象属性和方法:使用点号(.)操作符访问对象的属性和方法。
示例代码:public class Person {private String name;private int age;public Person(String name, int age) { = name;this.age = age;}public String getName() {return name;}public int getAge() {return age;}}Person person = new Person("张三", 20);System.out.println("姓名:" + person.getName());System.out.println("年龄:" + person.getAge());3. 继承和多态的应用(1)继承:使用extends关键字实现类的继承。
面向对象编程 JAVA编程综合实验报告
成绩:JA V A编程B综合实验报告实验名称:面向对象编程实验时间:2012年5月31日星期四JAVA编程B综合实验报告一、实验名称面向对象编程二、实验目的1、理解Java语言是如何体现面向对象编程基本思想,2、了解类的封装方法,以及如何创建类和对象,3、了解成员变量和成员方法的特性。
4、掌握OOP方式进行程序设计的方法,5、了解类的继承性和多态性的作用。
三、实验环境配置Windows XP、JDK 1.6与Eclipse 3.5四、实验记录1)创建Applet 应用小程序2)创建对象并使用对象3)使用修饰符五、代码分析一、创建Applet 应用小程序1、创建一个Applet应用程序文件。
(1)程序功能:建立一个Applet小程序,使其可以进行简单的加法运算。
该程序要包含类、接口、属性、方法、事件等面向对象的基本元素。
(2)程序源代码如下。
import java.awt.*;import java.awt.event.*;import java.applet.Applet;public class Applet1 extends Applet implements ActionListener {Label label1 = new Label("+");Label label2 = new Label("=");TextField field1 = new TextField(6);TextField field2 = new TextField(6);TextField field3 = new TextField(6);Button button1 = new Button("相加");public void init() { // 初始化add(field1);add(label1);add(field2);add(label2);add(field3);add(button1);button1.addActionListener(this);}public void actionPerformed(ActionEvent e) { // 处理按钮事件int x = Integer.parseInt(field1.getText())+ Integer.parseInt(field2.getText());field3.setText(Integer.toString(x)); // 数值转换为字符串}}2、编写一个浏览Applet应用程序的页面文件Applet1.HTML,源代码如。
实验一Java面向对象基础实验报告参考模板
实验一Java面向对象基础、数组实验报告一、实验目的1. 理解面向对象编程基本思想2. 了解类的封装方法,以及如何创建类和对象3. 掌握面向对象程序设计的方法,了解类的继承性和多态性的作用4. 掌握Java 中的数组定义、引用二、实验要求编写程序时要注意体现面向对象思想,体会不同访问控制符的作用。
1. 编写一个Vehicle类和它的二个子类Bus类和Boat类。
(要求:程序要有构造方法重载;要能体现类的多态性)2. 定义一个由若干个整数组成的数组,要求输出该数组的平均值以及所有的奇数之和。
3. 随机生成30个0-9之间的数字,分别统计0-9这10个数字分别出现了多少次。
三、实验内容及结果1. 编写一个Vehicle类和它的二个子类Bus类和Boat类。
public class Vehicle {private String color;public Vehicle() {this("black");}public Vehicle(String color) {this.color = color;}public String toString() {return "this is a " + this.color + " vehicle";}}class Bus extends Vehicle {private int passagerNumber;public Bus() {this(50, "black");}public Bus(int number) {this(number, "black");}public Bus(int number, String color) {super(color);this.passagerNumber = number;}public String toString() {return super.toString().replace("vehicle", "bus")+ " , max passager number: " + this.passagerNumber;}}class Boat extends Vehicle {private String owner;public Boat() {super("black");this.owner = "nobody";}public Boat(String owner) {super("black");this.owner = owner;}public Boat(String owner, String color) {super(color);this.owner = owner;}public String toString() {return super.toString().replace("vehicle", "boat")+ " own by "+ this.owner;}}2. 定义一个由若干个整数组成的数组,要求输出该数组的平均值以及所有的奇数之和。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
实验报告实验项目一Java面向对象特性实验多态性与动态绑定一、实验目的1.掌握多态性在继承中的运用;2.理解动态绑定的含义;3.学会使用抽象类;4.了解成员变量的隐藏。
二、实验内容假设某班级里既有本科生也有研究生,请编写程序统计出全班学生的成绩等级并显示出来。
.三、实验原理Java上溯造型技术、抽象类、继承性、多态性、动态绑定等技术原理。
四、实验环境主CPU 586以上,内存1G以上,操作系统Windows XP,eclipse 。
五、实验步骤1、创建一个Polymorphism.java 项目图 1 创建Polymorphism.java 项目。
2、创建类 Polymorphism。
图 2 创建类 Polymorphism 3、创建抽象类Student图 3 抽象类Student4.创建继承于Student的Undergraduate类图 4 Undergraduate类5. 创建继承于Student的Postgraduate类图 5 创建Postgraduate类所有类如下:图 6 创建所有类后6.在各类中补充代码,并输入相对应的代码可得。
6.1 抽象类Studentabstract 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="" ; //初始化courseGrade为空串代码1 }public abstract void calculateGrade();public String getName( ){return name;}public String getType( ){return type;//代码2 //返回学生类型}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按课程索引号设置课程成绩}}6.2 创建继承于Student的Undergraduate(本科生)类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]; // 代码4 // 累加各门课程成绩};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 = "不及格";}}6.3 创建继承于Student的Postgraduate(研究生)类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 if (average>=80&&average<90) courseGrade = "良好";else if (average>=70&&average<80) courseGrade = "一般";else if (average>=60&&average<70) courseGrade = "及格";else courseGrade = "不及格";}}6.4 创建类 Polymorphismpublic 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("梁欣欣"); // 代码5 // 创建姓名为梁欣欣的Postgraduate对象students[4]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( ));}}}六、实验结果运行可得如下实验结果:图 7 实验运行结果七、实验分析7.1在 Polymorphism 类中有一个循环语句用来计算每个学生的成绩等级for(int i=0;i<5;i + +){student[i].calculateGrade();}这里的 calculateGrade() 方法,如果对象是研究生,即按照研究生的标准来计算。
如果对象是本科生,即按本科生的标准来计算,这也正体现了方法的多态性。
7.2在程序 Polymorphism 类中,下面语句体现了子类的对象可以赋值给父类的引用变量:students[0] = new Undergraduate("陈建平");students[1] = new Undergraduate("鲁向东");students[2] = new Postgraduate("匡晓华");students[3] = new Undergraduate("周丽娜");students[4]=new Postgraduate("梁欣欣");7.3现在请在程序 Polymorphism 类的 main() 方法中添加如下的语句Student st=new Student (" 李明 ");此时编译会报错。
这是不允许的,因为Student类是一个抽象类,不可以直接用于创建类,里面什么也没有实现。
八、实验结论一、本实验设计 3 个类 , 分别是学生类 Student, 本科生类 Undergaduate, 研究生类Postgraduate, 其中 Student 类是一个抽象类 , 它包含一些基本的学生信息如姓名、所学课程、课程成绩等 , 而 Undergraduate 类和 Postgraduate 都是Student 类的子类 , 它们之间的主要差别是计算课程成绩等级的方法有所不同 , 研究生的标准要比本科生的标准高一些。
二、我通过本实验,了解并掌握了多态性在继承中的运用,理解了动态绑定的含义,并学会了使用抽象类,了解成员变量的隐藏。
多态性也分静态多态性和动态多态性两种。
静态多态性是指定义在一个类或一个函数中的同名函数,它们根据参数表(类型以及个数)区别语义,并通过静态联编实现动态多态性是指定义在一个类层次的不同类中的重载函数,它们一般具有相同的函数,因此要根据指针指向的对象所在类来区别语义,它通过动态联编实现。
动态多态是指发出同样的消息被不同类型的对象接收时,有可能导致完全不同的行为。