实验4 继承、多态的理解和运用

合集下载

php实验报告总结与体会

php实验报告总结与体会

php实验报告总结与体会php实验报告总结与体会1. 引言在经过一学期的学习和实践,我有幸进行了一系列的php实验,通过编写代码和实践项目,掌握了php语言的基本语法和特性。

在这篇文章中,我将对我进行的实验进行总结和回顾,分享我对php的个人观点和理解。

2. 实验一:入门实验实验一是我对php语言的第一次接触和学习实践。

通过编写简单的“Hello World”程序,我了解了php的基本语法和语义。

我发现php是一种简单易学的语言,语法规则清晰,代码结构简洁。

通过实验一,我对php的基本语法有了初步的了解,为后续的学习奠定了基础。

3. 实验二:变量与数据类型实验二主要围绕php的变量和数据类型展开。

我学习了php的基本数据类型,包括整数、浮点数、字符串、布尔值等,并掌握了变量的定义和使用。

通过实践运用,我发现php的变量赋值和使用非常灵活,可以方便地进行运算和操作。

php的数据类型转换也是一个重要的概念,我学到了如何将一个数据类型转换为另一个数据类型,为写出高质量的php代码提供了便利。

4. 实验三:条件语句与循环控制实验三是我对php条件语句和循环控制的实践。

通过掌握if语句、switch语句和for循环、while循环等,我学习了如何根据条件执行不同的代码块和如何针对一定条件进行循环操作。

这些控制流程的语法和用法都非常简单明了,使我能够通过编写php代码实现各种复杂的逻辑操作。

5. 实验四:函数的定义与使用实验四是对php函数的实践。

通过学习函数的定义和使用,我了解了php函数的作用和用法。

我发现函数是一个非常重要的概念,可以帮助我们将一段代码块进行封装和复用。

通过函数,我们可以提高代码的可读性和可维护性,同时也可以减少代码的重复性。

在实验四中,我还学习了php函数的参数传递和返回值的使用,更加深入地理解了函数的灵活性和便利性。

6. 实验五:数组与文件操作实验五是对php数组和文件操作的实践。

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. 在实验过程中,重点是要区分好实例和类,灵活掌握类的调⽤。

python面向对象编程实验总结

python面向对象编程实验总结

python面向对象编程实验总结摘要:1.实验目的2.实验内容3.实验过程4.实验收获5.实验反思正文:python面向对象编程实验总结一、实验目的本次实验旨在加深对Python面向对象编程的理解和应用,通过实践掌握类、对象、继承、多态等概念,提高编程能力和解决实际问题的能力。

二、实验内容本次实验主要涉及以下内容:1.定义类和对象:学会如何创建类,实例化对象,并使用属性和方法对对象进行操作。

2.继承和多态:理解继承关系,实现多态,以便在一个父类中定义多个子类。

3.封装和初始化:掌握如何使用封装性来隐藏对象内部的实现细节,以及如何使用初始化方法对对象进行初始化。

4.异常处理:学习如何在面向对象的程序中处理异常,提高程序的健壮性。

三、实验过程1.编写第一个类:定义一个名为“Person”的类,包含姓名、年龄等属性,以及初始化方法和说话方法。

2.创建对象:实例化一个Person对象,并使用对象的方法和属性。

3.添加继承关系:定义一个名为“Student”的类,继承自Person类,添加学生特有的属性(如:班级、成绩等),并重写说话方法。

4.创建学生对象:实例化一个Student对象,并使用对象的方法和属性。

5.异常处理:在Student类中添加一个方法,当调用该方法时,如果成绩低于及格线,则抛出异常并显示警告信息。

6.测试实验:编写测试代码,验证各个类的功能是否正常运行。

四、实验收获通过本次实验,我对Python面向对象编程有了更深入的了解,掌握了类、对象、继承、多态等概念,提高了编程能力。

同时,我也学会了如何在面向对象的程序中处理异常,使程序更加健壮。

五、实验反思在本次实验中,我发现在编写代码的过程中,要注意类的封装性,避免在其他地方直接修改类的属性。

此外,在编写异常处理时,要确保异常信息清晰明了,便于程序调试。

最后,我要不断提高自己的编程能力,将所学知识应用到实际项目中。

总之,本次实验对我的编程技能提升有很大帮助,让我更加熟练地运用Python面向对象编程。

面向对象实验报告

面向对象实验报告

面向对象实验报告面向对象实验报告引言:面向对象编程是一种软件开发方法,它将现实世界中的事物抽象成对象,通过定义对象的属性和行为来描述其特征和功能。

本实验旨在通过实际操作,深入理解面向对象编程的概念和原则。

一、实验背景面向对象编程是计算机科学领域的重要概念之一,它具有封装、继承和多态等特性,可以提高代码的可重用性和可维护性。

在本实验中,我们将通过编写一个简单的学生管理系统来探索面向对象编程的实际应用。

二、实验目的1. 理解面向对象编程的基本概念和原则;2. 掌握类的定义、对象的创建和方法的调用;3. 熟悉封装、继承和多态的使用;4. 实践面向对象编程的思维方式和方法论。

三、实验过程1. 类的定义在学生管理系统中,我们首先需要定义一个学生类,包含学生的基本信息,如学号、姓名、年龄等。

通过封装这些属性和定义相应的方法,我们可以实现对学生对象的创建和操作。

2. 对象的创建在主程序中,我们可以通过实例化学生类来创建学生对象。

通过调用构造函数,为学生对象赋予具体的属性值。

例如,创建一个名为Tom的学生对象,可以使用以下代码:Student tom = new Student("001", "Tom", 18);3. 方法的调用定义了学生类后,我们可以为其添加一些方法,如获取学生信息、修改学生信息等。

通过调用这些方法,可以实现对学生对象的操作和管理。

例如,获取Tom的年龄可以使用以下代码:int age = tom.getAge();4. 继承的应用在学生管理系统中,我们可以将学生类作为基类,派生出一些特定类型的学生类,如研究生、本科生等。

通过继承,子类可以继承基类的属性和方法,并可以添加自己特有的属性和方法。

这样,我们可以更好地组织和管理不同类型的学生对象。

5. 多态的实现通过使用多态,我们可以在不同的上下文中使用同一个方法名,实现不同的功能。

例如,在学生管理系统中,我们可以定义一个统一的显示信息方法,然后在不同的学生类中重写该方法,以实现不同类型学生的信息展示。

C#程序设计实验指导资料

C#程序设计实验指导资料

C#程序设计实验指导课程名称:C#程序设计 _____________ 专业班级:鱼阪科扶學院学生实验报告册(理工学生学号: _________________________ 学生姓名:所属院部:信息技术学院__________ 指导教师:20 12 —— 20 13学年第1学期金陵科技学院教务处制实验报告书写要求实验报告原则上要求学生手写,要求书写工整。

若因课程特点需打印的,标题采用四号黑体,正文采用小四号宋体,单倍行距。

纸张一律采用A4的纸张。

实验报告书写说明实验报告中实验目的和要求、实验仪器和设备、实验内容与过程、实验结果与分析这四项内容为必需项。

教师可根据学科特点和实验具体要求增加项目。

填写注意事项(1)细致观察,及时、准确、如实记录。

(2)准确说明,层次清晰。

(3)尽量采用专用术语来说明事物。

(4)外文、符号、公式要准确,应使用统一规定的名词和符号。

(5)应独立完成实验报告的书写,严禁抄袭、复印,一经发现,以零分论处。

实验报告批改说明实验报告的批改要及时、认真、仔细,一律用红色笔批改。

实验报告的批改成绩采用五级记分制或百分制,按《金陵科技学院课堂教学实施细则》中作业批阅成绩评定要求执行。

实验报告装订要求实验批改完毕后,任课老师将每门课程的每个实验项目的实验报告以自然班为单位、按学号升序排列,装订成册,并附上一份该门课程的实验大纲。

实验项目名称:C#编程基础_______________ 实验学时:6 学时同组学生姓名:无_______________ 实验地点:实验日期:_________________________ 实验成绩:批改教师:_________________________ 批改时间:实验1 C#编程基础一、实验目的(1)熟悉Visual 集成开发环境(IDE),熟悉C#源程序语言的编辑、编译和运行过程;(2)学会创建简单的控制台应用程序和win dows窗体应用程序;(3)能够使用C#选择、循环等流程控制语句编写并调试程序;(4)掌握使用数组来求解一些现实问题的步骤和方法。

java类的继承实验报告

java类的继承实验报告

java类的继承实验报告Java类的继承实验报告引言:在面向对象的编程语言中,继承是一种重要的概念。

Java作为一种面向对象的编程语言,也提供了类的继承机制。

本实验旨在通过编写Java程序,深入理解和掌握Java类的继承。

实验目的:1. 理解继承的概念和原理;2. 掌握Java中类的继承的语法和用法;3. 实践继承的实际应用。

实验过程:1. 创建父类和子类在实验中,我们首先创建一个父类和一个子类。

父类可以是一个基本的类,子类则继承了父类的属性和方法。

这样,子类就可以在不改变父类的基础上,扩展自己的功能。

2. 继承的语法和用法Java中,使用关键字"extends"来实现类的继承。

子类通过继承父类,可以获得父类的属性和方法,并且可以在子类中添加新的属性和方法。

在实验中,我们可以通过创建子类对象,并调用继承自父类的方法来验证继承的正确性。

3. 方法的重写在继承中,子类可以重写父类的方法。

这样,当子类调用该方法时,实际上执行的是子类重写后的方法。

通过方法的重写,我们可以实现多态性的效果。

4. 实际应用在实验中,我们可以选择一个具体的应用场景,例如动物类的继承。

我们可以创建一个父类Animal,包含基本的属性和方法,然后创建子类Dog和Cat,分别继承Animal类,并添加自己的特有属性和方法。

通过这个实例,我们可以更好地理解继承的实际应用。

实验结果:通过实验,我们成功地创建了父类和子类,并验证了继承的正确性。

我们还成功地重写了父类的方法,实现了多态性的效果。

最后,我们还通过实际应用的例子,更好地理解了继承的实际应用。

实验总结:通过本次实验,我们深入理解和掌握了Java类的继承。

继承是面向对象编程中的重要概念,通过继承,我们可以实现代码的重用和扩展。

在实际应用中,继承也可以帮助我们更好地组织代码,提高代码的可读性和可维护性。

然而,继承也有一些限制和注意事项。

首先,Java中只支持单继承,即一个子类只能继承一个父类。

《Java程序设计》课程教学大纲

《Java程序设计》课程教学大纲

《Java程序设计》课程教学大纲课程编号:08120031课程名称:Java程序设计/JAVA Programming总学时/学分:48/3(其中理论32学时,实验16学时)适用专业:计算机科学与技术一、课程目标通过本课程学习,学生应达到如下目标:目标1. 识别Java语言特点、基本语法、语言机制。

目标2. 将面向对象方法知识运用在程序设计案例中,能使用JAVA常用类、枚举、lambda 表达式、容器、泛型进行实例编程验证。

目标3. 利用JavaSE中的异常处理、输入输出等技术来表达处理程序应用问题。

目标4. 将图形用户界面和数据库编程技术运用中综合应用程序设计中。

目标5. 搭建Java开发环境,能设计实现各种Java技术的应用程序,且能测试运行。

二、课程目标对毕业要求的支撑三、教学过程安排四、实验或上机内容五、课程目标达成方法六、考核标准本门课程考核包括6个部分,分别为考试、作业、实验、讨论和测验。

具体要求及评分方法如下:1、期末考试试卷知识点要求2、作业3、实验4、讨论设置讨论课一次,要求学生按照讨论题目分组查阅资料,归纳总结,撰写报告。

5、测验随堂测验,老师给出题目,学生回答。

具体有任课老师给出评分标准。

七、教材及主要参考资料[1] 黑马程序员. Java基础入门(第2版)[M]. 清华大学出版社, 2018.[2] 郑人杰、马素霞、殷人昆. 软件工程概论(第2版)[M]. 机械工业出版社,2016.[3] Gay S.Horstmann. Java核心技术(第10版)[M]. 机械工业出版社,2016.[4] Y.Daniel Liang(美). Java语言程序设计(第10版)[M]. 机械工业出版社.2015.[5] 李刚. 疯狂Java讲义(第4版)[M]. 电子工业出版社,2018.[6] 封亚飞. 揭秘Java虚拟机[M]. 电子工业出版社,2017.[7] Bruce Eckel(美). Java编程思想(第4版)[M]. 机械工业出版社,2007.。

类与对象的实验总结

类与对象的实验总结

类与对象的实验总结类与对象是面向对象编程中的重要概念,通过对类与对象的实验,我深入了解了它们的基本概念、特性和使用方法。

首先是对类的实验。

一个类是对象的抽象模板,它描述了对象的共同属性和行为。

在实验中,我创建了一个名为“Person”的类来描述人的属性和行为。

在类中,我定义了属性包括姓名(name)、年龄(age)和性别(gender),并通过构造函数来初始化这些属性。

我还定义了方法来获取和设置属性的值,以及一个方法来展示人的信息。

通过实例化该类,我创建了不同的人对象,每个对象具有不同的属性值。

这样,一个类可以创建多个对象,每个对象都有相同的属性和方法,但属性值可以不同。

这使得代码的复用性大大提高,并且能够方便地对对象进行操作和管理。

接下来是对对象的实验。

一个对象是类的一个实例,它具有类定义的属性和行为。

在实验中,我通过实例化“Person”类来创建了不同的人对象。

通过调用对象的方法,我可以获取和设置对象的属性值,以及展示对象的信息。

对象可以根据需求动态地改变自己的属性值,从而实现了对数据的灵活处理。

同时,对象之间可以相互调用对方的方法,实现了不同对象之间的交互与合作。

通过使用对象,我可以更加方便地管理和操作数据,使代码更加模块化和可维护。

在实验中,我还学习了类的继承和多态的概念,并实际操作了它们。

继承是一种机制,允许一个类从另一个类继承属性和方法。

通过创建一个子类,我可以继承父类的属性和方法,并可以在子类中添加新的属性和方法,或者重写父类的方法。

这种继承的关系使得代码更加灵活和可扩展,可以根据不同的需求创建不同的子类。

多态是一种机制,允许一个对象使用多种形态。

通过创建一个父类的对象,我可以将其赋值给父类和子类的变量,通过调用不同的变量实现对不同的方法的调用。

多态提高了代码的灵活性和可扩展性,使得代码更加易于拓展和维护。

在实验过程中,我遇到了一些问题,并通过实践得到了解决。

首先是对类的理解问题,刚开始接触类的概念时,我对类和对象之间的关系有些模糊,以及如何正确使用类和对象。

Java实验指导4继承与多态

Java实验指导4继承与多态

《Java程序设计》实验指导实验四继承与多态一、实验目的:1.掌握类的继承方法。

2.掌握变量的继承和覆盖。

3.掌握方法的继承、重载和覆盖。

4.了解接口的实现方法。

二、实验原理新类可从现有的类中产生,并保留现有类的成员变量和方法,并可根据需要对它们加以修改。

新类还可添加新的变量和方法。

这种现象就称为类的继承。

当建立一个新类时,不必写出全部成员变量和成员方法。

只要简单地声明这个类是从一个已定义的类继承下来的,就可以引用被继承类的全部成员。

被继承的类称为父类或超类(superclass),这个新类称为子类。

Java 提供了一个庞大的类库让开发人员继承和使用。

设计这些类是出于公用的目的,因此,很少有某个类恰恰满足你的需要。

你必须设计自己的能处理实际问题的类,如果你设计的这个类仅仅实现了继承,则和父类毫无两样。

所以,通常要对子类进行扩展,即添加新的属性和方法。

这使得子类要比父类大,但更具特殊性,代表着一组更具体的对象。

继承的意义就在于此。

语法格式:类访问限定符子类名extends 父类名{……}三、实验内容及要求:1. 定义一个接口(ShapeArea),其中包含返回面积的方法(getArea)。

定义一个矩形类(Rectangle),派生出一个正方形类(Square),再定义一个圆类(Circle),三者都要求实现接口ShapeArea,自行扩充成员变量和方法。

在主方法中建一数组,数组中放入一些上述类型的对象,并计算它们的面积之和。

2. 运行下面的程序,理解成员变量的继承与隐藏,方法的覆盖与重载。

class A{int sum,num1,num2;public A(){num1=10;num2=20;sum=0;}void sum1(){sum=num1+num2;System.out.println("sum="+num1+"+"+num2+"="+sum);}void sum2(int n){num1=n;sum=num1+num2;System.out.println("sum="+num1+"+"+num2+"="+sum);}}class B extends A{int num2;public B(){num2=200;}void sum2(){sum=num1+num2;System.out.println("sum="+num1+"+"+num2+"="+sum);}void sum2(int n){num1=n;sum=num1+num2;System.out.println("sum="+num1+"+"+num2+"="+sum);}void sum3(int n){super.sum2(n);System.out.println("sum="+num1+"+"+num2+"="+sum);}}public class test{public static void main (String arg[]){B m=new B();m.sum1();m.sum2();m.sum2(50);m.sum3(50);}}。

python类与继承实验总结

python类与继承实验总结

python类与继承实验总结在Python中,类与继承是一种面向对象编程的基本概念。

类是一种抽象数据类型,用于描述具有共同属性和行为的对象。

而继承是一种机制,允许子类继承父类的属性和方法,以及可以在子类中添加新的属性和方法。

通过实验,我深入了解了类与继承的实际应用。

以下是我对实验的总结:1. 类的定义:在Python中,可以使用class关键字定义一个类。

类由属性和方法组成,属性是类的变量,而方法是类的函数。

类的属性和方法可以通过点号(.)来访问。

2. 实例化对象:通过类创建的对象称为实例。

在Python中,可以使用类名后跟一对括号来创建对象。

通过对象可以访问类的属性和方法。

3. 继承的语法:在Python中,可以使用class关键字后跟父类的名称来定义子类。

子类继承父类的属性和方法,并且可以对父类的方法进行重写。

4. 多重继承:在Python中,一个类可以同时继承多个父类。

这种继承方式称为多重继承。

可以使用逗号将多个父类的名称列在class语句中。

通过以上实验,我更加深入了解了Python中类与继承的概念和应用:1. 类与对象的关系:类是对象的模板,而对象是类的实例。

通过类可以创建多个对象,每个对象都具有一组相同的属性和方法。

2. 封装性:类将数据与操作数据的方法封装在一起,避免了数据的直接访问和修改。

通过在类中定义私有属性和方法,可以实现数据的封装性。

3. 继承的优势:继承可以实现代码的重用和扩展。

子类可以继承父类的属性和方法,从而减少重复的代码。

通过重写父类的方法,子类可以修改父类的行为。

4. 多态性:多态性是面向对象编程中的重要概念。

通过多态性,可以使用父类的引用来引用子类的对象。

这可以实现代码的灵活性和扩展性。

总的来说,通过实验我对Python类与继承有了更深入的理解。

类与继承是面向对象编程的基础,掌握了类与继承的相关知识,可以更好地设计和编写代码,并且可以提高代码的可复用性和可扩展性。

C++实验报告模板 -太原理工大学-软件学院

C++实验报告模板 -太原理工大学-软件学院
cin>>a>>b;
area=a*b;
cout<<"面积为"<<area<<endl;
}
else if(x==3)
{
double a;
cout<<"边长:";
cin>>a;
area=a*a;
cout<<"面积为"<<area<<endl;
}
else{
cout<<"输入有误,请重新输入!"<<endl;
七、讨论、心得
通过本次实验,我明确了构造函数和析构函数的应用,也对函数重载有了更深刻的理解,掌握了类的私有成员、公有成员和保护成员的区别,对编写程序的整体思维方法是也有了更清晰的理解。
实验三继承与派生
一、实验目的和要求
(1)掌握类的继承和派生过程;
(2)掌握派生类的定义与使用;
(3)掌握派生类的构造函数与析构函数的应用及调用顺序;
int GetBottom() const { return itsBottom; }
int GetRight() const { return itsRight; }
void SetTop(int top) { itsTop = top; }
void SetLeft (int left) { itsLeft = left; }
};
Circle::Circle(double x0,double y0,double r):Shape(x0,y0)
int itsRight;
};
Rectangle::Rectangle(int top, int left, int bottom, int right)

java多态实验报告

java多态实验报告

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中的多态概念和使用方法。

JAVA实验四1

JAVA实验四1
4.2.1 继承的概念
通过类的继承, 祖先类的所有成员均将成为子类拥有的“财富”。 但是能否通过子类对 象直接访问这些成员则取决于访问权限设置。Object 类是所有类的祖先。
4.2.2 构造方法与继承关系
构造方法不存在继承关系,子类中是如何给父类继承的属性赋初值呢? 子类通过调用父类的构造方法给父类的属性赋值, 在子类的构造方法的第 1 行可以通过 super 去调用父类的构造方法,如果没有 super 调用,则默认调用父类的无参构造方法。所 以,在父类中编写构造方法通常均要提供无参构造方法。
实验 4 继承与多态 4.1 实验目的
(1) 理解类的继承,掌握变量隐藏、方法覆盖的概念。 (2)理解引用类型的变量的赋值转换原则。 (3)理解多态概念,掌握方法的匹配调用原则; (4)理解抽象类与接口的使用; (5)理解 this 和 super 的含义及使用。 (6)理解访问控制符的使用
4.2 知识要点
提高题
a=new
methodMatch ();
1) 分别下面程序中 x 的访问权限进行修改,测试访问许可。修改包括:private, protected,public 以及无访问控制符 4 种情形。 程序1:同一类情形(文件accessTest.java) package test class accessTest{
4.2.6 抽象类
定义形式: abstract class 类名称 { 成员变量; 方法(){……} //定义一般方法
abstract 方法();//定义抽象方法 } 在抽象类中可以包含一般方法和抽象方法。 抽象类表示的是一个抽象概念,不能被实例化为对象。 继承抽象类的具体类必须将抽象类中抽象方法覆盖实现。
(2) 使用抽象类的引用变量可引用子类的对象; (3) 通过父类引用子类对象,通过该引用访问对象方法时实际用的是子类的方法。可 将所有对象存入到父类定义的数组中。 样例2:定义接口 Shape, 其中包括一个方法 size () ,设计“直线”、 “圆”、 “会议”、 “圆柱体”等类实现 Shape 接口。分别创建一个“直线”、“圆”、“会议”、“圆柱体” 存入一个数组中,将数组中各类图形的大小输出。 注:圆柱体可考虑由底边圆和高度两个部分组成。 【参考程序】 interface Shape { double size(); } class Line implements Shape { private double x1,y1,x2,y2; public Line(double x1, double y1, double x2, double y2) { this.x1 = x1; this.y1 = y1; this.x2 = x2; this.y2 = y2; } public double size() {

创建类课程实验报告

创建类课程实验报告

一、实验目的1. 理解面向对象编程的基本概念,包括类、对象、继承、多态等。

2. 掌握使用面向对象编程语言(如Java、C++等)创建类的步骤。

3. 学会使用类和对象进行程序设计,实现特定功能。

二、实验环境1. 操作系统:Windows 102. 编程语言:Java3. 开发工具:Eclipse三、实验内容本次实验主要涉及以下内容:1. 定义一个简单的类2. 创建类的实例(对象)3. 使用类的成员变量和方法4. 继承与多态四、实验步骤1. 定义一个简单的类```javapublic class Person {private String name;private int age;public Person(String name, int age) { = name;this.age = age;}public void introduce() {System.out.println("My name is " + name + ", and I am " + age + " years old.");}}```2. 创建类的实例(对象)```javapublic class Main {public static void main(String[] args) {Person person1 = new Person("Alice", 20);Person person2 = new Person("Bob", 25);}}```3. 使用类的成员变量和方法```javapublic class Main {public static void main(String[] args) {Person person1 = new Person("Alice", 20);person1.introduce(); // 输出:My name is Alice, and I am 20 years old.Person person2 = new Person("Bob", 25);person2.introduce(); // 输出:My name is Bob, and I am 25 years old.}}```4. 继承与多态```javapublic class Employee extends Person {private String job;public Employee(String name, int age, String job) {super(name, age);this.job = job;}public void introduce() {System.out.println("My name is " + getName() + ", and I am " + getAge() + " years old. I work as a " + job + ".");}}public class Main {public static void main(String[] args) {Employee employee1 = new Employee("Alice", 20, "Engineer");employee1.introduce(); // 输出:My name is Alice, and I am 20 years old. I work as an Engineer.Employee employee2 = new Employee("Bob", 25, "Manager");employee2.introduce(); // 输出:My name is Bob, and I am 25 years old. I work as a Manager.}}```五、实验结果与分析1. 通过定义一个简单的类,我们可以将数据和行为封装在一起,提高代码的可维护性和可读性。

python继承定义多态的实验体会

python继承定义多态的实验体会

Python继承定义多态的实验体会1. 引言在面向对象编程中,继承和多态是两个重要的概念。

继承指的是一个类可以继承另一个类的属性和方法,从而实现代码的重用和扩展。

而多态则指的是同一种行为或方法可以用不同的方式实现。

在Python中,继承和多态是通过类和对象的特性来实现的。

本文将通过一个实验来探讨Python继承定义多态的概念和应用。

2. 实验背景在实验之前,我们首先需要了解一些与实验相关的背景知识。

以下是一些基本的概念:•类(Class):类是对象的蓝图或模板,用于定义对象的属性和方法。

•对象(Object):对象是类的一个实例,具有类定义的属性和方法。

•继承(Inheritance):继承是一种机制,允许一个类继承另一个类的属性和方法。

•多态(Polymorphism):多态是指同一种行为或方法可以用不同的方式实现。

3. 实验方法为了说明Python继承定义多态的概念,我们可以通过一个实验来展示其应用。

下面是实验的步骤:1.首先,创建一个父类(ParentClass)和一个子类(ChildClass)。

2.父类中定义一个方法(parent_method),并在子类中重写该方法。

3.创建一个父类对象和一个子类对象。

4.调用对象的方法,并观察多态的效果。

4. 实验代码以下是实验所需的Python代码:class ParentClass:def parent_method(self):print("This is the parent method.")class ChildClass(ParentClass):def parent_method(self):print("This is the overridden method in child class.")parent_obj = ParentClass()child_obj = ChildClass()parent_obj.parent_method()child_obj.parent_method()5. 实验结果运行上述代码,我们可以得到以下结果:This is the parent method.This is the overridden method in child class.从上述结果可以看出,子类对象调用了父类方法时,实际上调用的是子类中重写的方法。

(4) 实验四 继承与多态

(4) 实验四 继承与多态
(1)类的继承
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会根据实际的对象类型来调用实际类型所对应的方法。这种运行时的多态,我们也成为动态绑定。

继承与多态性

继承与多态性

[标准实验报告]南昌航空大学实验报告2011 年11 月12 日课程名称:面向对象程序设计B 实验名称:继承与多态性班级:10202327 姓名:吕潇同组人:指导教师评定:签名:一、实验目的根据现有类建立新类;学习构造基类和虚函数的用法。

二、实验内容(本次实验要完成的内容)应用VC++6.0的编辑环境构造一个类Jhtx及其派生类,该类主要实现关于几何图形的基本操作。

对于基类“几何图形”,有求面积、求体积的函数(纯虚函数),其派生类圆和矩形主要有初始化(构造函数),求面积,求周长操作,类圆的派生类圆球和圆柱有求表面积、体积操作。

试在主函数中分别定义圆、圆球、圆柱以及矩形的对象,并调用其成员函数实现其相应操作。

三、概要设计(实现的功能,函数原型及说明等)对于基类“几何图形”,有求面积、求体积的函数(纯虚函数),其派生类圆和矩形主要有初始化(构造函数),求面积,求周长操作,类圆的派生类圆球和圆柱有求表面积、体积操作。

试在主函数中分别定义圆、圆球、圆柱以及矩形的对象,并调用其成员函数实现其相应操作。

Geometry(double c) 基类构造函数初始化{r=c;}virtual void GetArea()=0; 求面积的纯虚函数原型virtual void GetPeriMeter()=0; 求周长的纯虚函数原型virtual void GetColume()=0; 求体积的纯虚函数原型四、详细设计(程序中核心代码,并要有相应注释——函数功能、参数说明、重要语句的注解)class Geometry{ 抽象基类public:Geometry(double c){r=c;}//~Geometry();virtual void GetArea()=0; 分别用于求面积周长virtual void GetPeriMeter()=0; 体积的纯虚函数原型virtual void GetColume()=0;protected:double r;};--------------------------------------------------------------class Rectangle:public Geometry{public: 矩形派生类virtual void GetColume(){} 纯虚函数的重定义Rectangle(double a,double b,double c):Geometry(c){x=a;y=b; } 构造函数初始化//~Rectangle();void GetArea() 求面积的纯虚函数{ 在派生类中的重定义cout<<"The Rectangle's Area is";cout<<x*y<<endl;}void GetPeriMeter(){ 纯虚函数重定义cout<<"The Rectangle's PeriMeter is";cout<<2*(x+y)<<endl;}protected:double x;double y;};-------------------------------------------------------------------class Circle:public Geometry{ 派生类圆的类public:virtual void GetColume(){}Circle(double c):Geometry(c) 构造函数{}//~Circle();virtual void GetArea() 求面积的纯虚函数的重定义{cout<<"The Circle's Area is";cout<<3.14*r*r<<endl;}virtual void GetPeriMeter() 求周长的纯虚函数的重定义{cout<<"The Circle's PeriMeter is";cout<<2*3.14*r<<endl;}};------------------------------------------------------------class Ball:public Circle{ 圆的派生类球的类public:Ball(double c):Circle(c){ }virtual void GetArea() 求面积的纯虚函数的重定义{cout<<"The Ball's Surface Area is";cout<<6*3.14*r*r<<endl;}virtual void GetColume() 求体积的纯虚函数的重定义{cout<<"The Ball's V olume is";cout<<(4/3)*3.14*r*r*r<<endl;}//~Ball();};-------------------------------------------------------------------class Column:public Circle{ 园的派生类圆柱的类public:Column(double h,double c):Circle(c){H=h;}virtual void GetArea() 求面积的纯虚函数的重定义{cout<<"The Column's Surface Area is";cout<<(2*3.14*r*r)+(2*3.14*r*H)<<endl;}virtual void GetColume() 求体积的纯虚函数的重定义{cout<<"The Column's V olume is";cout<<3.14*r*r*H<<endl;}//~Column();protected:double H;};五、程序调试(包括调试过程中遇到的问题及解决方法、程序测试数据及结果)class Ball:public Circle{Public:Ball(double c):Circle(c){ }virtual void GetArea(){cout<<"The Ball's Surface Area is";cout<<6*3.14*r*r<<endl;}virtual void GetColume(){cout<<"The Ball's Volume is";cout<<(4/3)*3.14*r*r*r<<endl;}//~Ball();};在派生类球的类中将 public 写成Public导致错误不能编译成功六、实验总结(对实验过程中出现的问题进行总结、指出程序中还需进一步完善的地方、在本次实验中学到的内容及自身不足等)对本次试验进行总结:1.应对实验整体架构进行了解。

Java程序设计实验指导书(答案)

Java程序设计实验指导书(答案)

第Ⅰ部分:实验指导实验1:Java开发环境J2SE一、实验目的(1)学习从网络上下载并安装J2SE开发工具。

(2)学习编写简单的Java Application程序.(3)了解Java源代码、字节码文件,掌握Java程序的编辑、编译和运行过程。

二、实验任务从网络上下载或从CD-ROM直接安装J2SE开发工具,编写简单的Java Application程序,编译并运行这个程序。

三、实验内容1.安装J2SE开发工具Sun公司为所有的java程序员提供了一套免费的java开发和运行环境,取名为Java 2 SDK,可以从上进行下载。

安装的时候可以选择安装到任意的硬盘驱动器上,例如安装到C:\j2sdk1.4.1_03目录下。

教师通过大屏幕演示J2SE的安装过程,以及在Windows98/2000/2003下环境变量的设置方法。

2.安装J2SE源代码编辑工具Edit Plus教师通过大屏幕演示Edit Plus的安装过程,以及在Windows98/2000/2003操作系统环境下编辑Java 原程序的常用命令的用法。

3.编写并编译、运行一个Java Application程序。

创建一个名为HelloWorldApp的java Application程序,在屏幕上简单的显示一句话"老师,你好!"。

public class HelloWorldApp{public static void main(String[] args){System.out.println("老师,你好!");}}4.编译并运行下面的Java Application程序,写出运行结果。

1:public class MyClass {2:private int day;3:private int month;4:private int year;5:public MyClass() {6:day = 1;7:month = 1;8:year = 1900;9:}10:public MyClass(int d,int m,int y) {11:day = d;12:month = m;13:year = y;14:}15:public void display(){16:System.out.println(day + "-" + month + "-" + year);17:}18:public static void main(String args[ ]) {19:MyClass m1 = new MyClass();20:MyClass m2 = new MyClass(25,12,2001);21:m1.display();22:m2.display();23:}24:}运行结果:1-1-190025-12-2001实验2:Java基本数据类型一、实验目的(1)掌握javadoc文档化工具的使用方法。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

实验4 继承、多态的理解和运用一. 实验目的1. 通过阅读本课件的知识点和例题,理解面向对象的两个重要概念——继承和多态。

2. 在深入理解继承和多态意义和编程方法的基础上,模仿例题中的思路和编程模式,尝试运用继承和多态解决本课件给出两个问题,以训练面向对象方法的综合运用能力。

二. 知识点和例题1. 继承⑴ 继承的概念继承 (inheritance) 是面向对象程序设计中的一个重要的方法。

从字面意义上说,继承就是获得父辈的遗产,在这个基础之上发展自己的事业,而不必从头做起。

在类的设计中,我们会发现许多类都存在着某些共性,一方面,我们要将这些共性抽象出来,做成一些称为基类(父类、超类)的类,另一方面,我们可以利用面向对象的继承机制,在基类之上设计出一些称为子类(派生类)的类来拓展基类的功能。

现实生活中,继承的例子很多。

自然科学中,狼、狗、狐等存在着某些共性,生物学家把它们抽象为“犬类”来描述它们的共性,再在该大类基础上进一步细分,并分别描述它们的特性。

犬类便是基类(在其之上还有哺乳类等更高层次的基类),狼、狗、狐便是子类;社会科学中,“学生”是一个基类,他们具有学号、姓名、成绩等共性,小学生、中学生、大学生、研究生等则是子类,它们各自有各自的特性。

就像自然界和人类社会的分类都是相对的一样,程序中的类也是相对的,一个基类可能是另一个基类的子类,一个子类的下面可能还有子类,从而构成一个树状的层次结构,称为“类族”,如下图所示:⑵ 继承的实现程序中的继承体现在类与类之间的关系上。

要将一个类定义为另一个类的子类,只需在类名之后加上关键字extends ,再加上其父类名即可:访问权限 class 类名 extends 父类名 { 属性和方法定义 }例如,圆是一般几何图形的一个特例,如果描述一般几何图形的类为Shape ,则class Circle extends Shape { 属性和方法定义 }哺乳类灵长类 犬科类 猫科类猿类 猴类 狼类 狗类 虎类 豹类猫类 狐类 人类一个子类继承了其父类的所有成员,包括所有属性和方法(构造方法除外),除此之外,子类还可以有自己的成员,例如:class Shape {int x, y; // 图形位置(图形的共同属性)Shape(int x, int y) { // 构造方法this.x = x;this.y = y;}int getX() { return x; } // 出口方法int getY() { return y; } // 出口方法}class Circle extends Shape {int r; // 圆的半径(圆的特殊属性)Circle(int x, int y, int r) { // 构造方法super(x, y);this.r = r;}int getRadius() { return radius; } // 出口方法}既然子类继承了父类的所有成员,这就意味着子类对象中也包含着父类的属性和方法,子类方法据此是否就可以随意访问父类成员呢?否!子类对父类成员的访问仍受到访问权限的限制,一个类的private成员同样不允许子类的方法访问,就像儿子不能随意动用父辈的私有财产一样(尽管他已继承了这部分财产)。

关键字protected作为介于private 和public 之间的一种访问权限,则允许子类的方法访问父类的成员。

要设计出一个好的面向对象程序,就要从基类的设计开始,它应当在对所涉及对象充分抽象的基础上设计出来,设计的主线是属性,方法作为服务于属性的角色出现,就像动物的行为是为了延续其生命一样。

然后,通过增加新的属性和方法,在基类之上逐层设计出子类。

父类体现出一类对象的共性,子类则体现出一类对象的特性。

注意:类应以作为服务对象的属性来命名,而不应以方法所完成的功能来命名。

⑶super关键字与前面所述this关键字代表本类对象相似,super关键字代表父类对象,它有两种用法,一是像this一样当子类成员或局部变量与父类成员重名时,作为前缀来标识父类成员,例如super.x,二是代替父类名调用父类构造函数,为父类对象的属性赋初值,例如super(x, y)。

因此在前面例子中,子类Circle的构造函数对父类属性x和y的赋值既可以用super(x, y),又可以用super.x = x; super.y = y;(注意父类x, y属性的访问权限为protected)。

⑷final关键字从理论上讲,一个类族继承的层次可以是无限的。

但在某些情况下,当我们不想让一个类再有子类时,可以用final关键字来为这个类“绝育”,例如:final class Circle extends Shape {int r; // 圆的半径Circle(int x, int y, int r) { super(x, y); this.r = r; }int getRadius() { return radius; }}使得Circle类不能再被继承。

⑸继承实例class Shape {protected int x, y, width, height; // 所有形状的共同属性Shape(int x, int y, int width, int height) {this.x = x;this.y = y;this.width = width;this.height = height;}int getX() { return x; }int getY() { return y; }int getWidth() { return width; }int getHeight() { return height; }}class Rectangle extends Shape {Rectangle(int x, int y, int width, int height) { super(x, y, width, height); // 对父类构造方法的调用}double getArea() { // 计算矩形面积return width * height;}String shapeName() {return"矩形";}}class Oval extends Shape {Oval(int x, int y, int width, int height) {super(x, y, width, height); // 对父类构造方法的调用}double getArea() { // 计算圆形面积return Math.PI * width * height / 4.0;}String shapeName() {return"椭圆";}}class RoundRect extends Shape {int arcWidth, arcHeight; // 子类增加的特殊属性RoundRect(int x, int y, int width, int height, int arcWidth, int arcHeight) { super(x, y, width, height); // 初始化父类成员this.arcWidth = arcWidth; // 初始化本类成员this.arcHeight = arcHeight; // 初始化本类成员}int getArcWidth() { return arcWidth; }int getArcHeight() { return arcHeight; }double getArea() { // 计算圆角矩形面积return width * height - (arcWidth * arcHeight * 4 - arcWidth * arcHeight * Math.PI);}String shapeName() {return"圆角矩形";}}public class UseShape {public static void main(String[] args) {Rectangle rect = new Rectangle(0, 0, 6, 8);System.out.println(rect.shapeName() + "面积= " + rect.getArea());Oval oval = new Oval(0, 0, 6, 8);System.out.println(oval.shapeName() + "面积= " + oval.getArea());RoundRect roundrect = new RoundRect(0, 0, 6, 8, 1, 2);System.out.println(roundrect.shapeName() + "面积= " + roundrect.getArea());}}2. 多态⑴继承的局限性从对上一节例题的观察我们会发现,虽然基类Shape 概括了几何形状的共性,但作为一个独立的类来说,它是不完整的。

例如,它无法计算形状的面积(一个抽象的形状显然无面积可言),因此它的功能必须在子类中得到拓展。

我们希望在定义基类时也给出实现类族功能的基本方法的说明,并且允许子类对基类同原型方法的功能进行重定义。

这一切都可以通过面向对象的另一重要机制——多态(polymorphism)来实现。

⑵父类方法的覆盖我们可以在基类中定义一些与子类同原型的方法来描述未来类族的功能,无论这些方法是否有实际意义。

父、子类同原型方法在通过不同类的对象被调用时会给出不同的实现。

例如Shape类中有如下定义:double getArea() { return 0; }当UseShape类的方法main分别通过Shape和Rectangle的对象对方法 getArea 产生调用时,将分别返回0和48。

此时我们称父类的方法被子类的方法“覆盖”(override)。

⑶abstract关键字如果基类中的某些方法确无法实现,或实现也无实际意义,我们可以用关键字abstract 将其定义为抽象方法,从而避免了在基类中给出实现代码的必要性,例如将getArea定义为:abstract double getArea();包含抽象方法的类必须定义为抽象类:abstract class Shape {…abstract double getArea();…}⑷父类与子类的关系由于抽象类中的抽象方法未曾给出实现代码,因此抽象类的对象是无法创建的。

然而,面向对象程序设计语言允许声明一个父类对象名来引用其子类对象,例如:Shape s = new Rectangle(0, 0, 6, 8);我们称父类与子类存在着“is a”关系,即子类的对象也是父类的对象(An object of Rectangle is an object of Shape),因此可以为父类的对象赋值。

相关文档
最新文档