JAVA继承、接口和多态实验
实验6 继承与接口
实验报告姓名学号专业班级课程名称 Java实验实验日期成绩指导教师批改日期实验名称实验 6 继承与接口[实验目的]1、掌握java 继承中父类及其子类的定义方法。
2、掌握子类重写父类同名方法的方法。
3、掌握接口的用法。
(1) 学习如何定义接口 ;(2) 掌握接口的实现方式 ;(3) 使用实现了接口的类 ;(4) 理解接口与抽象类的区别。
[实验要求]1、复习理论教学中所学的内容。
2、认真进行实验预习,查阅参考书,书写源程序,书写实验预习报告。
3、认真总结实验并书写实验报告。
[实验内容]1、类的继承性练习(1) 程序源代码如下。
public class Student{protected String xm; //姓名,具有保护修饰符的成员变量protected int xh;//学号void setdata(String xm,int xh) //设置数据的方法{this.xm=xm;this.xh=xh;}public void print() //输出数据的方法{System.out.println(xm+", "+xh);}}import java.util.*;public class Exe_1 extends Student{public Exe_1(){};public static void main(String[] args) {Scanner input=new Scanner(System.in);Exe_1 text=new Exe_1();System.out.println("请输入姓名和学号:");text.setdata(input.next(), input.nextInt());System.out.println("显示如下:");text.print();}}(2) 编译源并运行程序。
贴图如下(二)创建将被继承的类(1) 程序功能:通过Student类产生子类CollegeStudent,其不仅具有父类的成员变量xm(姓名)、xh(学号),还定义了新成员变量xy(学院)、bj(bj)。
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. 在实验过程中,重点是要区分好实例和类,灵活掌握类的调⽤。
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.多态在Java中的技术基础4.示例5.多态的好处6.总结介绍之前的文章介绍过类的封装性和继承性,现在是时候聊聊面向对象编程的三大特性之一的最后一个类的多态性了。
多态的基础是继承(包括了接口的实现)和方法的覆盖。
什么是多态多态对应的英文单词是polymorphism,百度翻译给出的翻译是:n.多型现象,多态性; 多机组合形式;按字面意思就是多种状态、形态、姿态等等,潜台词就是某个东西具有多种状态、形态、姿态等等。
那是什么东西呢?在面向对象的编程语言里面(当然就包括Java了)就是某个方法或函数。
那方法的多种状态、形态、姿态有是个什么意思呢?这其实是指同一个方法具有多个方法体,就是方法的实现。
而方法的相同与否是由方法签名决定的。
所以,多态其实本质上是指同一个类的同一个方法却具有不同的行为特征。
状态、形态、姿态指的就是行为特征。
多态在Java中的技术基础然而,在Java中,同一个类里面是不可能存在两个签名相同而实现不同的方法的,否则的话会导致无法判断该执行哪个方法,因此在编译时就会报错。
所以,肯定是在两个类中才有可能存在两个签名相同而实现不同的方法,一个实现在这个类,另一个实现在另一个类。
而如果这两个类毫无瓜葛,那么肯定就与多态的本质(同一个类的同一个方法却具有不同的行为特征)自相矛盾了。
所以,这两个类肯定是有某种联系的。
我们再想想,什么概念是能够让两个不同的类却又能称为同一个类的?答案就是类的继承/扩展,就是现实中的“某东西是某类东西”的概念,就是“具体和抽象”的思想。
比如,男人是人,女人也是人,男人类和女人类就借助于人类建立了某种联系,而人类具有的某个行为在男人类和女人类中是有着不同体现的,比如人类的吃饭这个行为,男人类的体现是狼吞虎咽,女人类的体现是细嚼慢咽。
例子不是很恰当,但意思就是这么个意思。
所以说,Java里面多态的技术基础就是方法的覆盖,当然,在Java中覆盖不仅仅发生在类的继承/扩展上,还可能发生在接口的实现上。
实验三 继承和多态
实验三继承和多态一、实验目的1.熟练掌握封装性,多态性的概念。
2.熟练掌握抽象类abstract的概念。
3.熟练掌握接口interface的概念。
4.熟练包package的概念以及编译运行的方法。
二、实验内容1.编写一个Java Application程序,该程序有个点Point类,它包含横坐标x和纵坐标y 两个属性,再给Point定义两个构造方法和一个打印点坐标的方法Show。
定义一个圆Circle 类,它继承Point类(它是一个点,圆心(Center)),除此之外,还有属性半径Radius,再给圆定义2个构造方法、一个打印圆的面积的方法PrintArea和一个打印圆中心、半径的方法Show(其中显示圆心可以用super.Show()的方式)。
编写一测试类,对其进行编译、运行。
结果如何?如去掉语句“super.Show();”,再看看运行结果。
理解程序中重载和多态性的运用。
2.完成以下步骤要求:(1)设计一个表示二维平面上点的类Point,包含有表示坐标位置的protected类型的成员变量x和y,获取和设置x和y值的public方法。
(2)设计一个表示二维平面上圆的类Circle,它继承自类Point,还包含有表示圆半径的protected类型的成员变量r,获取和设置r值的public方法、计算圆面积的public 方法。
(3)设计一个表示圆柱体的类Cylinder,它继承自类Circle,还包含有表示圆柱体高的protected类型的成员变量h、获取和设置h值的public方法、计算圆柱体体积的public 方法。
(4)建立若干个Cylinder对象,输出其轴心位置坐标、半径、高及其体积的值。
3.学校中有老师和学生两类人,而在职研究生既是老师又是学生,对学生的管理和对教师的管理在他们身上都有体现。
(1)设计两个信息管理接口StudentInterface和TeacherInterfaceo其中,StudentInterface接口包括setFee方法和getFee方法,分别用于设置和获取学生的学费;TeacherInterface接口包括setPay方法和getPay方法,分别用于设置和获取教师的工资。
java类的继承实验报告
java类的继承实验报告Java类的继承实验报告引言:在面向对象的编程语言中,继承是一种重要的概念。
Java作为一种面向对象的编程语言,也提供了类的继承机制。
本实验旨在通过编写Java程序,深入理解和掌握Java类的继承。
实验目的:1. 理解继承的概念和原理;2. 掌握Java中类的继承的语法和用法;3. 实践继承的实际应用。
实验过程:1. 创建父类和子类在实验中,我们首先创建一个父类和一个子类。
父类可以是一个基本的类,子类则继承了父类的属性和方法。
这样,子类就可以在不改变父类的基础上,扩展自己的功能。
2. 继承的语法和用法Java中,使用关键字"extends"来实现类的继承。
子类通过继承父类,可以获得父类的属性和方法,并且可以在子类中添加新的属性和方法。
在实验中,我们可以通过创建子类对象,并调用继承自父类的方法来验证继承的正确性。
3. 方法的重写在继承中,子类可以重写父类的方法。
这样,当子类调用该方法时,实际上执行的是子类重写后的方法。
通过方法的重写,我们可以实现多态性的效果。
4. 实际应用在实验中,我们可以选择一个具体的应用场景,例如动物类的继承。
我们可以创建一个父类Animal,包含基本的属性和方法,然后创建子类Dog和Cat,分别继承Animal类,并添加自己的特有属性和方法。
通过这个实例,我们可以更好地理解继承的实际应用。
实验结果:通过实验,我们成功地创建了父类和子类,并验证了继承的正确性。
我们还成功地重写了父类的方法,实现了多态性的效果。
最后,我们还通过实际应用的例子,更好地理解了继承的实际应用。
实验总结:通过本次实验,我们深入理解和掌握了Java类的继承。
继承是面向对象编程中的重要概念,通过继承,我们可以实现代码的重用和扩展。
在实际应用中,继承也可以帮助我们更好地组织代码,提高代码的可读性和可维护性。
然而,继承也有一些限制和注意事项。
首先,Java中只支持单继承,即一个子类只能继承一个父类。
实验4 继承性和多态
实验四继承性和多态一、实验目的:熟悉JA V A中的继承性和多态性。
掌握子类的定义及用法,继承机制中的隐藏与覆盖。
子类的构造方法的用法,对象的上转型对象,抽象类与抽象方法等。
二、实验要求:1.根据下面的要求,编写Java应用程序实现:编写程序模拟中国人、美国人是人、北京人是中国人。
除主类外,程序中还有4个类:People、ChinaPeople、AmericanPeople和BeijingPeople类。
要求如下:●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类是ChinaPeople的子类,新增public void beijingOpera()方法。
要求ChinaPeople重写父类的public void speakHello()、public void averageHeight()和public void averageWeight()方法。
《Java程序设计》上机实验报告 实验三 面向对象程序设计的继承、多态等特性的练习
信息科学与工程学院《Java程序设计》上机实验报告专业班级姓名学号实验时间指导教师成绩主要实验记录及个人小结(包括部分实验源程序、调试结果及实验结果分析等)Student(String name,String sex,int age,String sno,String classno) {super(name,sex,age);this.sno=sno;this.classno=classno;}public String toString(){ return("姓名:"+name+" 性别:"+sex +" 年龄:"+age+ " 学号:"+sno+" 班号:"+classno+" ");}}public class TestStudentPerson {public static void main(String[] args){int i;Student stu[]=new Student[3];stu[1]=new Student("小明","男",20,"200912135138","2班");stu[2]=new Student("小木","女",23,"200912135136","5班");stu [1].updateAge(25);stu [2].updateAge(26);for(i=1;i<3;i++){System.out.println(stu[i]);}}}2)调试结果:主要实验记录及个人小结(包括部分实验源程序、调试结果及实验结果分析等)调试结果:2)将Shape类定义为abstact class Shape{……}public 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); //作为实参,调用对象是3个类对象,上溯造型使其隐藏.doStuff(t);doStuff(l);}}abstract class Shape{abstract void draw();}class Circle extends Shape{void draw(){System.out.println("Draw Circle");}} //定义Shape抽象类的派生类Circleclass Triangle extends Shape{void draw(){System.out.println("Draw Three Triangle");}}//定义Shape抽象类的派生类Triangleclass Line extends Shape{void draw(){System.out.println("Draw Line");}}//定义Shape抽象类的派生类Line主要实验记录及个人小结(包括部分实验源程序、调试结果及实验结果分析等)调试结果:3)将Shape定义为interface Shape{……}public 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); //作为实参,调用对象是3个类对象,上溯造型使其隐藏.doStuff(t);doStuff(l);}}interface Shape{public void draw();} //定义一个Shape接口class Circle implements Shape{public void draw(){System.out.println("Draw Circle");}} //基于Shape接口利用implements实现类Circleclass Triangle implements Shape{public void draw(){System.out.println("Draw Three Triangle");}}class Line implements Shape{public void draw(){System.out.println("Draw Line");}}调试结果:3.思考题:某小型公司,主要有三类人员:经理、兼职技术人员和兼职推销员。
Java继承与多态实验报告.doc
Java继承与多态实验报告.doc
Java的继承与多态实验报告
本报告致力于分析Java继承与多态的概念、原理和作用,以及相关实验过程及其结果。
继承,又称为分类,是Java面向对象程序设计语言中定义类之间关系的重要技术。
它使一个类可以使用另一个基类中定义的方法和属性,在基类中已经定义了一些功能,子
类可以对基类功能进行拓展与定制。
《Java技术手册》得出结论,继承可以有效提高软件的复用性、可维护性和可重用性,使大型的、复杂的程序有条理层次。
多态是Java中一种特殊的程序结构,允许不同类的对象对相同的消息作出不同的响应,由程序的消息而不是对象的类型来决定对象的行为。
它是Java多态性的基础,使程
序能够在不同对象上进行操作,统一实现。
从实验中,可以明显看出Java继承与多态之间的联系:多态必须依赖于继承,当子
类被创建时,它继承了母类的方法以及特性,这样,它才能以逐渐上升的方式处理所有消息,而多态给了子类独特-->性的功能。
同时,多态也方便了代码重用,因为子类会继承
母类的方法和属性。
此外,结果表明,多态的优点使程序可以提高可重用性,它也减少了代码的重复编写,同时允许特定类之外的类可以得到适用。
它促进了软件不断更新,因为多态给开发人员提
供了以对象层次组织代码的方法。
本练习涉及到Java继承与多态概念的整体概述和实现细节,为完全理解多态的概念
打下了坚实的基础。
它提供了一个理解和使用这些概念的有用方式和指导。
JAVA实验报告
JAVA实验报告一、实验目的本次 Java 实验的主要目的是通过实际编程操作,深入理解 Java 语言的基本语法、面向对象编程的概念以及常用类库的使用。
同时,培养自己解决实际问题的能力,提高编程的熟练程度和代码质量。
二、实验环境操作系统:Windows 10开发工具:EclipseJDK 版本:18三、实验内容及步骤(一)基本语法练习1、数据类型与变量定义不同类型的变量,如整数型(int)、浮点数型(float、double)、字符型(char)和字符串型(String),并进行赋值和输出操作。
了解不同数据类型的取值范围和精度,以及在实际编程中的应用场景。
2、控制结构编写使用 ifelse 语句、switch 语句进行条件判断的程序。
运用 for 循环、while 循环和 dowhile 循环实现重复执行的操作。
3、数组与字符串声明和初始化一维数组和二维数组,对数组元素进行访问和操作。
进行字符串的拼接、截取、查找等常见操作。
(二)面向对象编程实践1、类与对象定义一个简单的类,包含属性和方法。
创建该类的对象,并调用对象的方法来操作属性。
2、继承与多态建立父类和子类,实现继承关系。
在子类中重写父类的方法,展示多态性。
3、封装与抽象将类的属性设置为私有,并提供公共的访问方法(getter 和 setter),实现封装。
定义抽象类和抽象方法,体会抽象的概念和作用。
(三)常用类库的使用1、 Java 输入输出(IO)使用 Scanner 类实现从控制台读取用户输入的数据。
运用 File 类和相关的输入输出流类,实现文件的读取和写入操作。
2、集合框架熟悉 ArrayList、LinkedList 等线性集合的使用方法。
了解 HashSet、TreeSet 等集合的特点和应用场景。
3、异常处理在程序中加入可能引发异常的代码段,并使用 trycatch 语句捕获和处理异常。
四、实验结果与分析(一)基本语法练习1、数据类型与变量成功定义了各种数据类型的变量,并正确进行了赋值和输出。
Java实验报告
实验报告课程名称 Java技术专业班级 13-计算机科学与技术-1班学生姓名及学号 98 潘汀指导教师钟华刚实验地点计算中心2015 ~ 2016 学年第一学期实验一类的封装、继承、多态一、实验目的1.复习、理解OOP的特征——封装、继承和多态。
2.学会使用Java编写简单的类。
理解类的属性和方法。
3.掌握关键字private, protected, public的作用。
4.掌握多态的概念。
二、实验内容1.分别编写两个类Point2D,Point3D来表示二维空间和三维空间的点,使之满足下列要求:(1) Point2D有两个整型成员变量x, y (分别为二维空间的X,Y方向坐标),Point2D的构造方法要实现对其成员变量x, y的初始化。
(2) Point2D有一个void型成员方法offset(int a, int b),它可以实现Point2D的平移。
(3) Point3D是Point2D的直接子类,它有有三个整型成员变量x,y,z (分别为三维空间的X,Y,Z方向坐标),Point3D有两个构造方法:Point3D(int x,int y,int z)和Point3D(Point2D p,int z),两者均可实现对Point3D的成员变量x, y,z的初始化。
(4) Point3D有一个void型成员方法offset(int a, int b,int c),该方法可以实现Point3D的平移。
(5)在Point3D中的主函数main()中实例化两个Point2D的对象p2d1,p2d2,打印出它们之间的距离,再实例化两个Point3D的对象p3d1,p3d2,打印出他们之间的距离。
提示:方法2.创建一个数组,随机生成Point2D或者Point3D的对象放于其中。
最后依次调用数组中每个对象的“打印方法”,显示数组中存储的对象是什么。
提示:方法或者类三、实验代码四、思考题1.你对面向对象的理解。
继承与多态实验报告心得
继承与多态实验报告心得
在进行继承与多态的实验过程中,我深刻理解了这两个面向对象编程的重要概念,并且在实践中体会到了它们的实际应用。
首先,继承是面向对象编程的一个基本特性,它允许创建新的类从已有的类中继承属性和方法。
在实验中,我创建了一个基类,然后通过继承来创建了多个子类。
这样,我可以在基类中定义一些通用的属性和方法,然后在子类中进行扩展或覆盖,实现了代码的重用和灵活性的提高。
通过继承,我可以很方便地创建出一个对象的不同类型的实例,从而满足不同的需求。
其次,多态是继承的一个重要特性,它允许使用基类类型的引用来引用一个子类的对象。
在实验中,我通过多态实现了一个统一的接口,使得可以以一种统一的方式处理不同类型的对象。
这样,我可以将具有相同行为的对象进行统一管理,提高了代码的灵活性和可扩展性。
在实验中,我还学会了使用抽象类和接口来实现多态。
抽象类提供了一种定义通用行为的方式,而接口则定义了一组方法的规范。
通过使用抽象类和接口,我可以定义一些通用的方法和属性,然后在具体的子类中进行实现和具体化。
这种方式可以有效地提高代码的可读性和可维护性。
继承与多态的实验为我提供了一个很好的学习机会,让我更深入地理解了面向对象编程的原理和思想。
通过实际操作,我不仅加深了对这两个概念的理解,还提升了自己的编程能力。
我相信,在以后的学习和工作中,我会继续运用这些知识,开发出更加高效和灵活的程序。
实验15、16:JAVA面向对象编程(继承、接口)
实验15:面向对象基础编程(六)继承实验目的:1.理解继承的概念2.掌握继承的实现3.理解继承中的覆盖现象4.理解抽象类的概念,掌握定义抽象类的方法和应用实验数据记录及分析(或程序及运行结果)1.首先预测下列程序的运行结果,然后编译、执行以验证你的预测:class Pet{protected String name;public Pet(String n){name = n;}public String getName(){return name;}public String move(){return "run";}public String speak(){return "";}public String toString(){return "My pet " + name;}}class Dog extends Pet{protected int weight;public Dog(String s){super(s);}}class PetTest{public static void main(String[] args){Pet myPet = new Pet("George");Dog myDog = new Dog("Spot");System.out.println(myPet.toString() + "\n" + "Speak: " +myPet.speak() +"\n" + myPet.move() + " " +myPet.getName() + "\n");System.out.println(myDog.toString() + "\n" + "Speak: " +myDog.speak() +"\n" + myDog.move() + " "+myDog.getName() + "\n");}}1)修改Dog类的构造函数,使之可以初始化Dog类中的weight值。
java 实验5 接口多态 实验报告
实验五接口、多态与内部类实验目标: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为抽象类,其他为普通类。
这里测试的目的是:我们知道当一个普通类实现一个接口时,必须实现该接口的全部方法,但当这个类是抽象类时,我们还需要实现该接口全部方法吗?如果不需要实现?那么是否直接不理这个方法就一,还是要将这个方法在自己类内部再标记一次为抽象方法。
接口的应用实验报告(3篇)
第1篇一、实验目的1. 理解接口的概念和作用。
2. 掌握接口的使用方法,包括接口的定义、实现和继承。
3. 通过实际应用,加深对接口的理解和应用能力。
二、实验环境1. 操作系统:Windows 102. 编程语言:Java3. 开发工具:Eclipse三、实验内容1. 接口的基本概念2. 接口的定义和实现3. 接口的继承和多态4. 接口的应用实例四、实验步骤1. 接口的基本概念(1)打开Eclipse,创建一个名为“InterfaceDemo”的Java项目。
(2)在项目中创建一个名为“Shape”的接口,包含一个抽象方法“draw()”。
```javapublic interface Shape {void draw();}```2. 接口的定义和实现(1)在项目中创建一个名为“Circle”的类,实现“Shape”接口。
```javapublic class Circle implements Shape {@Overridepublic void draw() {System.out.println("Drawing a circle.");}}```(2)在项目中创建一个名为“Rectangle”的类,实现“Shape”接口。
```javapublic class Rectangle implements Shape {@Overridepublic void draw() {System.out.println("Drawing a rectangle.");}}```3. 接口的继承和多态(1)在项目中创建一个名为“Triangle”的类,继承“Circle”类,并实现“Shape”接口。
```javapublic class Triangle extends Circle implements Shape {public void draw() {System.out.println("Drawing a triangle.");}}```(2)创建一个名为“Main”的类,用于测试接口的应用。
(4) 实验四 继承与多态
Java语言使用extends关键字在两个类之间建立这种类似与父子血缘关系的“继承”关系:在定义类时,使用extends来指明它的父类。
值得注意的是,Java中的继承只能是单继承即单根继承。
语法格式:
class SubClass extens SuperClass{//只能有一个父类
……
System.out.pri!~”);
}
public void fB(){
System.out.println(“method fB() from class B!”);
fA();
System.out.println(“x is”+ x);
}
}
public class Test{
2)什么时候需要使用super语句来显式调用父类构造?
(二)多态
多态是面向对象编程的重要技巧,它也是面向对象的重要特征之一。多态的本意是“同一个操作,不同的行为”,也就是使用同一个方法名,运行的实际是不同的方法。在Java语言中,多态主要通过方法的重载(Overloading)和重写(Overriding)实现。
public static void main(String[] args){
B b;
System.out.println(“====类已加载完毕=====”);
b = new B(10);
b.fB();
}
}
问题:
1)请结合运行结果分析Java中创建对象过程。(分析类的不同区域的运行前后次序,提示:类加载时或创建对象时,父类静态成员、实例成员、构造方法和子类静态成员、实例成员、构造方法的执行先后次序)
当程序运行并通过向上转型后的对象来调用方法时,Java会根据实际的对象类型来调用实际类型所对应的方法。这种运行时的多态,我们也成为动态绑定。
继承与多态实验报告
继承与多态实验报告继承与多态实验报告在面向对象编程中,继承和多态是两个重要的概念。
通过继承,我们可以创建新的类,并从现有的类中继承属性和方法。
而多态则允许我们使用父类的引用来指向子类的对象,实现同一操作具有不同的行为。
本实验旨在通过实际的编程实践,加深对继承和多态的理解。
实验一:继承在这个实验中,我们创建了一个动物类(Animal),并从它派生出了两个子类:狗类(Dog)和猫类(Cat)。
动物类具有一些共同的属性和方法,如名字(name)和发出声音(makeSound)。
子类继承了父类的属性和方法,并可以添加自己的特定属性和方法。
在编写代码时,我们首先定义了动物类,并在其中实现了共同的属性和方法。
然后,我们创建了狗类和猫类,并分别在这两个类中添加了自己的特定属性和方法。
通过继承,我们可以在子类中直接使用父类的方法,并且可以根据需要进行重写。
实验二:多态在这个实验中,我们使用多态的概念来实现一个动物园的场景。
我们定义了一个动物园类(Zoo),并在其中创建了一个动物数组。
这个数组可以存储不同类型的动物对象,包括狗、猫等。
通过多态,我们可以使用动物类的引用来指向不同类型的动物对象。
例如,我们可以使用动物类的引用来指向狗对象,并调用狗类特有的方法。
这样,我们可以统一处理不同类型的动物对象,而不需要为每种类型编写特定的处理代码。
实验三:继承与多态的结合应用在这个实验中,我们进一步探索了继承和多态的结合应用。
我们定义了一个图形类(Shape),并从它派生出了三个子类:圆形类(Circle)、矩形类(Rectangle)和三角形类(Triangle)。
每个子类都实现了自己的特定属性和方法。
通过继承和多态,我们可以在图形类中定义一些通用的方法,如计算面积和周长。
然后,我们可以使用图形类的引用来指向不同类型的图形对象,并调用相应的方法。
这样,我们可以轻松地对不同类型的图形进行统一的处理。
结论:通过本次实验,我们进一步理解了继承和多态的概念,并学会了如何在编程中应用它们。
实验五
(2)运行结果如图5.5所示。
图5.5
3.This、super和super()的使用
(1)程序功能:说明this、super和super()的用法。程序首先定义Point(点)类,然后创建点的子类Line(线)。最后通过LX3_4类输出线段的长度。
(2)使用this、super和super()的程序文件LX3_4.java,源代码如下图5.6所示。
多态是一种编程技巧它增加论了程序的可扩展性
2.接口有什么作用?如何实现系统接口。
接口的作用就是把使用接口的人和实现接口的人分开,实现接口的人不必要关心谁去使用,而使用接口的人也不用关心谁实现的接口,由接口将他们联系在一起。接口的用处在于整个程序段中相同类型的类有个统一的规范。
3.如何创建一个自定义接口?如何在一个类中实现这个接口?
图5.6
(3)编译并运行程序,结果如图5.7所示。
图5.7
二、类的多态性练习
1.方法的重载
方法的重载是指对同名方法的不同使用方式。
(1)程序功能:对不同的数进行排序输出。在IntSort类中定义3个同名的方法sort,
(1)编写构造方法RunDemo的重载程序文件LX3_12,源代码如下。
(2)编译并运行程序,结果如图5.4所示。
【思考题】
1.说明类的继承和多态用的一种形式,实现这种形式的方法是从现有的类建立新类,新类继承了现有类的方法和属性,同时新类又可以定义自己的方法和属性。软件复用缩自短了开发时间。继承的魅力在于能够添加基类没有的特点从而对基类进行改进。
子类继承后可以重写,也可以不重写,看需要决定。如果重写的话在实例中调用的是新写的方法,如果不重写的话在实例中调用的是父类的方法。
创建接口:public interface myFirstInterface(){
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
age=a;
}
publicvoidsetGender(String gen){
gender=gen;
}ቤተ መጻሕፍቲ ባይዱ
publicString getGender(){
returngender;
}
publicvoidsetAge(inta){
age=a;
}
publicintgetAge(){
returnage;
③注释掉TestDemo类,在.sdju.util包中新建一个LimitRun测试类。在LimitRun类的main()方法中先创建20个Vehicle对象(随机生成车牌号,车牌号范围为1~1000),并规定只有双号车辆能够通过,输出所有车辆的通过情况。
(3)编写程序实现如下功能:已知Person类包含三个公共域变量(姓名、性别、年龄)和一个构造方法,Student类是Person类的派生类,包含两个新的公共域变量(学号、班号)、两个公共方法(修改年龄、显示基本信息)及一个构造方法。定义一组学生对象,并初始化他们的基本信息,然后依次输出。
publicPerson(String name,charsex,intage) {
= name;
this.sex= sex;
this.age= age;
}
}
classStudentextendsPerson {
publicStringsno;
publicStringclassno;
MaleDriver md =newMaleDriver("male", 32);
Bus vb =newBus("Bus", 1234);
Car vc =newCar("Car", 5678);
String output ="A "+ fd.driver(vc) +" driver a "
+ vc.drivedByDriver(fd) +"\n"+"A "+ md.driver(vb)
(4)接口实验
程序文件TestInterface.java。运行该程序,然后按【思考问题】内容修改和观察程序。
interface rec_Area_Peri
{ int getArea();
int getPerimeter();
}
class rectangle implements rec_Area_Peri
定义一个台球类Billiards,继承Ball类,包含一个私有成员变量——颜色(String color),两个公有成员方法:设定颜色方法setColor()、输出信息方法show(),其中show()方法可以输出该台球的颜色和半径值。
定义一个公有类TestBall,测试前两个类。
(2)定义一个抽象类Driver,它有String gender(性别)和int age(年龄)两个成员属性,还有一个抽象的成员方法drives(Vehicle v),并从它派生出FemaleDriver和MaleDriver两个子类。
}
public class TestInterface
{ public static void main(String args[])
{ rectangle rect=new rectangle(10,20);
System.out.println("矩形面积="+rect.getArea());
System.out.println("矩形周长="+rect.getPerimeter());
+" driver a "+ vb.drivedByDriver(md);
JOptionPane.showMessageDialog(null, output);
System.exit(0);
}
}
运行结果:
a.用简单的输出方式
图3-2运行结果
b.用对话框的方式输出
图3-3运行结果
②a.将Bus类和Car类放置到.sdju.exp032包中,不改动Driver类的修饰符,则编译正确。说明public成员既可以被任何类使用。
}
}
【思考问题】
①在实现类rectangle中注释掉一个方法后进行编译,看发生了什么?为什么?
②在实现类rectangle中将各实现方法前的public修饰符去掉再进行编译,看发生了什么?为什么?
③将接口rec_Area_Peri中定义的两个方法前加上abstract修饰符再编译,看对程序有影响否?为什么?
this.sno= sno;
this.classno= classno;
}
}
publicclassTestStudentPerson {
publicstaticvoidmain(String args[]) {
Student a[] =newStudent[3];
a[0] =newStudent("A",'M', 18,"06","1110");
color= clo;
}
voidshow() {
System.out.println("台球的颜色为"+color+"\n"+"台球的半径为:"+super.getR());
}
}
publicclassTestBall {
publicstaticvoidmain(String[] args) {
Scanner reader =newScanner(System.in);
④不用单独的实现类rectangle,直接在主类classe TestInterface中实现那两个方法,如何修改程序?
⑤将接口rec_Area_Peri中定义的两个方法拆分定义成两个接口,即每个接口只定义一个方法,程序将如何修改?
三、实验结果(关键代码和运行结果)
(1)关键代码:
classBall {
}
publicabstractString driver(Vehicle v);
}
Bus.java的代码:
publicclassBusextendsVehicle{
publicBus(String t,inti) {
super(t, i);
}
publicString drivedByDriver(Driver who){
1先将以上所有类均放置到.sdju.exp031包中,然后以两种方式,分别通过调用drives()和drivedByDriver()成员方法输出如下字符串:
A Female drives a Car
A Male drives a Bus
2通过将Bus和Car类放置到.sdju.exp032包中,检验各个类及其成员的访问权限;
一、实验目的
(1)掌握类的继承机制。
(2)熟悉类中成员变量和方法的访问控制。
(3)熟悉方法或构造方法多态性。
(4)熟悉接口的定义方法。
二、实验内容
(1)定义一个球类Ball,包含一个私有成员变量——半径(double r),两个公有成员方法:设定半径方法(void setR(double x))、得到半径值方法(double getR())。
定义一个抽象类Vehicle,它有String type(车型)和int id(车牌号码)两个成员属性,还有一个抽象的成员方法drivedByDriver(Driver who),并从它派生出Bus和Car两个子类。
定义一个测试类TestDemo,在其main()方法中先创建fd和md两个Driver对象,然后创建vb和vc两个Vehicle对象。
}else{
System.out.println("Bus id="+ id +" The bus can not pass.");
}
}
}
}
图3-4运行结果
(3)关键代码:
Person.java的代码:
classPerson {
publicStringname;
publiccharsex;
publicintage;
publicvoidupdateAge(intage) {
this.age= age;
}
publicString toString() {
System.out.println("Name:"+name+" Sex:"+sex+" Age:"+age
+" Sno:"+sno+" Classno:"+classno+" ");
privatedoubler;
voidsetR(doublex) {
r= x;
}
doublegetR() {
returnr;
}
}
classBilliardsextendsBall {
privateStringcolor;
voidsetColor(doublex, String clo) {
super.setR(x);
{ int width, length;
rectangle(int w, int l)
{ width=w;
length=l;
}
public int getArea()