继承与接口实验

合集下载

005-实验五 继承和接口(实验报告内容)

005-实验五 继承和接口(实验报告内容)

实验五继承和接口(实验报告)一、目的1.掌握Java语言继承机制。

二、实验内容定义一个超类,定义一个子类,实例化子类对象,调用超类的属性和方法,体会继承机制。

三、实验环境JDK1.6+dos环境四、实验原理1.继承机制五、实验步骤1、定义一个Person类,有属性姓名,年龄,性别。

Person具有吃饭,睡觉的行为。

定义一个Student类继承Person类,Student具有学习,看书的行为。

定义一个接口,能够输出自己的基本信息。

完成所设计的类的测试。

class Person{private String name;private int age;private String sex;public void setName( String name){ =name;}public String getName( ){return name;}public void setAge( int age){this.age=age;}public int getAge( ){return age ;}public void setSex( String sex){this.sex=sex;}public String getSex( ){return sex;}public void tell01(){System.out.println("会吃饭,能睡觉"); }public void tell02(){System.out.println("姓名:"+this.getName()+"性别:"+this.getSex()+"年龄:"+this.getAge());}}interface A{public void print01();public void print02();}class Student extends Person implements A{private int number;public void setNumber(int number){this.number=number;}public int getNumber( ){return number;}public void tell03(){System.out.println("姓名:"+this.getName()+"\n性别:"+this.getSex()+"\n年龄:"+this.getAge()+"\n学号:"+this.getNumber());}public void tell04(){System.out.println("爱学习,喜欢看书");}public void print01(){System.out.println("巴黎下着小雨!!!");}public void print02(){System.out.println("吉大正在飚雨!!!");}}public class mytest01{public static void main(String args[]){Student stu = new Student();stu.setName("张三");stu.setAge(20);stu.setSex("男");stu.setNumber(2011);stu.tell01();stu.tell03();stu.tell04();stu.print01();stu.print02();}}六、实验小结。

实验6 继承与接口

实验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实验报告——继承与接口

System.out.print('\t'+"平均分");
System.out.println('\t'+"成绩等级");
for(int i=0; i<pg.length;i++) {
System.out.print(pg[i].Name); System.out.print('\t'+pg[i].Stu_type); System.out.print('\t'+String.valueOf(pg[i].C_score)); System.out.print('\t'+String.valueOf(pg[i].English_score)); System.out.print('\t'+String.valueOf(pg[i].Java_score)); System.out.print('\t'+String.valueOf(pg[i].score)); System.out.println('\t'+pg[i].sco_Level); } System.out.println(); } }
String Name=""; String Stu_type=""; int C_score; int English_score; int Java_score; int score; // String sco_Level=""; Sco_Level sco_Level;
public Student(String name,String stu_type,int sco1,int sco2,int sco3) {

java实验报告 类的继承

java实验报告 类的继承

java实验报告类的继承一、实验目的1、深入理解 Java 中类的继承概念和机制。

2、掌握通过继承实现代码复用和功能扩展。

3、学会使用 super 关键字和方法重写。

二、实验环境1、操作系统:Windows 102、开发工具:Eclipse 或 IntelliJ IDEA三、实验内容1、创建一个父类`Animal`包含属性:`name`(字符串类型),`age`(整数类型)包含方法:`eat()`(打印出动物正在吃东西),`sleep()`(打印出动物正在睡觉)2、创建子类`Dog` 继承自`Animal`新增属性:`breed`(字符串类型,表示狗的品种)重写父类的`eat()`方法,打印出狗吃东西的特有方式新增方法:`bark()`(打印出狗在叫)3、创建子类`Cat` 继承自`Animal`新增属性:`color`(字符串类型,表示猫的颜色)重写父类的`sleep()`方法,打印出猫睡觉的特有姿势新增方法:`meow()`(打印出猫在叫)四、实验步骤1、在 Java 项目中创建一个名为`Animal` 的类:```javapublic class Animal {private String name;private int age;public Animal(String name, int age) {thisname = name;thisage = age;}public void eat(){Systemoutprintln(name +" is eating");}public void sleep(){Systemoutprintln(name +" is sleeping");}}```2、创建一个名为`Dog` 的类继承自`Animal`:```javapublic class Dog extends Animal {private String breed;public Dog(String name, int age, String breed) {super(name, age);thisbreed = breed;}@Overridepublic void eat(){Systemoutprintln(supergetName()+" the "+ breed +" dog is eating greedily");}public void bark(){}}```3、创建一个名为`Cat` 的类继承自`Animal`:```javapublic class Cat extends Animal {private String color;public Cat(String name, int age, String color) {super(name, age);thiscolor = color;}@Overridepublic void sleep(){Systemoutprintln(supergetName()+" the "+ color +" cat is sleeping curled up");}public void meow(){}}```4、在`Main` 类中进行测试:```javapublic class Main {public static void main(String args) {Dog dog = new Dog("Buddy", 3, "Labrador");dogeat();dogbark();dogsleep();Cat cat = new Cat("Mimi", 2, "White");cateat();catsleep();catmeow();}}```五、实验结果1、运行`Main` 类后,输出结果如下:`Buddy the Labrador dog is eating greedily``Buddy is barking``Buddy is sleeping``Mimi is eating``Mimi the White cat is sleeping curled up``Mimi is meowing`2、可以看到,子类`Dog` 重写了父类`Animal` 的`eat()`方法,展示了狗特有的吃东西方式;子类`Cat` 重写了父类的`sleep()`方法,展示了猫特有的睡觉姿势。

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

java类的继承实验报告

java类的继承实验报告

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

Java作为一门面向对象的编程语言,也支持类的继承。

本篇实验报告将介绍Java类的继承的基本概念、语法以及实际应用。

一、继承的基本概念继承是指一个类可以派生出另一个类,被派生出的类称为子类,派生出子类的类称为父类。

子类可以继承父类的属性和方法,并且可以在此基础上进行扩展或修改。

继承的关系可以形成类的层次结构,使得代码的复用性和可维护性得到提高。

二、继承的语法在Java中,使用关键字"extends"来实现类的继承关系。

子类通过继承父类来获得父类的属性和方法。

语法格式如下:```javaclass 子类名 extends 父类名 {// 子类的成员变量和方法}```在子类中可以重写父类的方法,以实现自己的逻辑。

使用关键字"super"可以调用父类的构造方法和成员变量。

三、继承的实际应用1. 代码复用继承的一个主要优势是可以实现代码的复用。

子类可以继承父类的属性和方法,避免了重复编写相同的代码。

例如,假设有一个父类"Animal",子类"Dog"和"Cat"可以继承父类的一些通用属性和方法,如"eat()"和"sleep()"。

2. 多态性继承也为多态性的实现提供了基础。

多态性是指一个对象可以根据不同的类型表现出不同的行为。

通过继承,可以将不同的子类对象赋给父类引用,实现对不同子类对象的统一操作。

例如,有一个父类"Shape",子类"Circle"和"Rectangle"可以继承父类的方法"draw()",并在自己的类中实现具体的绘制逻辑。

通过将子类对象赋给父类引用,可以统一调用"draw()"方法,实现对不同形状的绘制。

实验三 继承和多态

实验三 继承和多态

实验三继承和多态一、实验目的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方法,分别用于设置和获取教师的工资。

实验报告

实验报告

实验四类,对象和接口一.实验目的(1)掌握类的声明,对象的创建以及方法的定义和调用。

(2)掌握打包机制。

(3)掌握类的继承。

(4)掌握类接口的使用。

二、实验方案(1)//Father.java;package tom.jiafei;public class Father{int height;protected int money;public int weight;public Father(int m){money=m;}protected int getMoney(){return money;}void setMoney(int newMoney){money=newMoney;}}//Jerry.java:import tom.jiafei.Father;public class Jerry extends Father{public Jerry(){super(20);}public static void main(String args[]){Jerry jerry=new Jerry();jerry.weight=200;jerry.money=800;int m=jerry.getMoney();System.out.println("m="+m);}}(2)interface ShowMessage{void 显示商标(String s);}class TV implements ShowMessage{public void 显示商标(String s){System.out.println(s);}}class PC implements ShowMessage{public void 显示商标(String s){System.out.println(s);}}public class Example4_28{public static void main(String args[]){ShowMessage sm;sm=new TV();sm.显示商标("长城牌电视机");sm=new PC();sm.显示商标("联想奔月5008PC");}}(3)求50以内的素数//Number.javapackage sushu;//将Number.java打包到文件夹sushu中public class Number{public void prn()//创建方法prn(){boolean flag ;for (int i=2;i<50;i++){flag = true ;//将flag初始化for (int j=2 ;j <= i/2 ; j++){ //只需对2到i/2之间取余,因为假如i/2到i有某个数x被i整除,则在2到i/2必定能找到一个数y(y*x=i)被i整除if (i%j == 0 ){flag = false ;break;//假如2到i/2有某个数被i整除,则跳出,执行下一次循环}}if (flag == true ){System.out.print(i+"\t");}//若flag为真,则i为素数,输出i的值}}}//Num.javaimport sushu.Number;//引用定义的包public class Num extends Number{public static void main(String args[]){Number num=new Number();num.prn();}}三、实验结果和数据处理(1)(2)(3)实验五数组与字符串一.实验目的(1)掌握一维数组的概念、定义和使用。

java指导书(新)

java指导书(新)

北方民族大学Beifang Ethnic University《java语言程序设计》课程实验指导书北方民族大学教务处北方民族大学《Java语言程序设计》课程实验指导书编著林淑飞校审任荣北方民族大学教务处二〇一〇年六月前言本书是为指导学生进行java语言程序设计实验而定制的,目的是通过一系列实验练习使学生巩固所学的知识。

本书由绪论和基本实验指导两大部分内容组成,其中绪论部分包括本课程实验的作用与任务、本课程实验的基础知识、本课程实验的项目及要求;基本实验指导部分包括每个实验的目的、原理、主要仪器及耗材、实验内容及步骤、实验注意事项、思考题和参考文献。

目录第一部分绪论 (1)第二部分基本实验指导 (2)实验一程序调试 (2)实验二继承与接口 (4)实验三java的包 (7)实验四输入输出流 (9)实验五图形用户界面设计 (11)第一部份绪论一、本课程实验的作用与任务使学生进一步深刻理解java语言基本概念、语法规则及程序结构,熟练掌握java语言程序设计的基本方法,提高利用java在网络环境下开发、设计应用程序的能力,从而进一步培养学生的创新能力和解决实际问题的能力。

熟悉JDK工具的编程和调试环境;熟练掌握选择和循环结构的程序设计;熟练掌握面向对象的程序设计思想,包括系统类的应用和用户自定义类;充分理解类的三种的特性:封装、继承和多态,特别是通过接口和抽象类理解多态;掌握图形用户界面的设计,特别是事件处理;掌握包的使用;掌握常用的输入输出流类的应用。

最后能根据实验的要求认真完成实验报告。

二、本课程实验的基础知识Java的基本数据类型包括:byte,short,int,long,double,char。

Java的数组属于引用类型的数据,是将相同类型的数据按顺序组成的一种符合数据类型。

Java的运算符有算术运算符、关系运算符、逻辑运算符、位运算符和赋值运算符,特别要注意它们的优先级。

Java的控制语句有if语句、switch语句、for语句、while语句、do-while语句。

实验五 C#类的设计和实现,(2)

实验五 C#类的设计和实现,(2)

实验四类的设计和实现(2)实验学时:2学时实验类型:验证实验要求:必做一、实验目的1.掌握类的继承的实现;2.掌握派生类、抽象类、抽象方法的使用;3.了解接口的实现;4.了解事件的实现二、实验内容实验1类的继承的实现实验要求:参照课本例8.3,创建基类Person和派生类Teacher。

基类Person包含实例字段name和age;虚函数GetInfo()显示个人信息。

派生类Teacher除了包含基类的name和age字段,还包含自己的TeacherID字段,并使用关键字override来重写方法GetInfo ()。

源程序:using System;using System.Collections.Generic;using System.Text;namespace ConsoleApplication12{public class Person{public string name;public uint age;public Person(string name, uint age){ = name;this.age = age;}public virtual void GetInfo(){Console.WriteLine("Name:{0}", name);Console.WriteLine("Age:{0}", age);1}}public class Teacher : Person{public string TeacherID;public Teacher(string name, uint age, string id): base(name, age){this.TeacherID = id;}public override void GetInfo(){base.GetInfo();Console.WriteLine("TeacherID:{0}", TeacherID);}}class Program{static void Main(string[] args){Teacher objteacher = new Teacher("Zhangying", 20, "1245713131");objteacher.GetInfo();Console.ReadKey();}}}运行结果:实验2 抽象类、抽象方法、多态性的实现实验要求:创建抽象基类Shape和派生类Rectangle、Circle。

继承与多态实验报告心得

继承与多态实验报告心得

继承与多态实验报告心得
在进行继承与多态的实验过程中,我深刻理解了这两个面向对象编程的重要概念,并且在实践中体会到了它们的实际应用。

首先,继承是面向对象编程的一个基本特性,它允许创建新的类从已有的类中继承属性和方法。

在实验中,我创建了一个基类,然后通过继承来创建了多个子类。

这样,我可以在基类中定义一些通用的属性和方法,然后在子类中进行扩展或覆盖,实现了代码的重用和灵活性的提高。

通过继承,我可以很方便地创建出一个对象的不同类型的实例,从而满足不同的需求。

其次,多态是继承的一个重要特性,它允许使用基类类型的引用来引用一个子类的对象。

在实验中,我通过多态实现了一个统一的接口,使得可以以一种统一的方式处理不同类型的对象。

这样,我可以将具有相同行为的对象进行统一管理,提高了代码的灵活性和可扩展性。

在实验中,我还学会了使用抽象类和接口来实现多态。

抽象类提供了一种定义通用行为的方式,而接口则定义了一组方法的规范。

通过使用抽象类和接口,我可以定义一些通用的方法和属性,然后在具体的子类中进行实现和具体化。

这种方式可以有效地提高代码的可读性和可维护性。

继承与多态的实验为我提供了一个很好的学习机会,让我更深入地理解了面向对象编程的原理和思想。

通过实际操作,我不仅加深了对这两个概念的理解,还提升了自己的编程能力。

我相信,在以后的学习和工作中,我会继续运用这些知识,开发出更加高效和灵活的程序。

实验15、16:JAVA面向对象编程(继承、接口)

实验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值。

接口的应用实验报告(3篇)

接口的应用实验报告(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”的类,用于测试接口的应用。

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.从上述结果可以看出,子类对象调用了父类方法时,实际上调用的是子类中重写的方法。

java类的继承实验总结

java类的继承实验总结

java类的继承实验总结
在Java中,类的继承是面向对象编程的重要特性之一。

通过继承,子类可以从父类继承属性和方法,从而实现代码复用和层次化设计。

在实验过程中,我深入学习了Java的继承机制,总结了以下几点经验:
1. 子类可以继承父类的非私有属性和方法,可以重写父类的方法。

在重写方法时,要遵循Liskov替换原则,确保子类可以替换掉父类。

2. Java中只支持单继承。

利用接口可以实现多重继承的效果。

3. super关键字可以访问父类的属性和方法,也可以调用父类的构造方法。

4. 父类的构造方法会被自动调用,如果没有显式地调用super(),则会默认调用父类的无参构造方法。

如果父类没有无参构造方法,则需在子类中显式调用super()并传入相应的参数。

5. 子类构造方法中的第一行可以调用super(),也可以调用this()。

但是二者不能同时出现。

6. 父类和子类的引用可以相互转换,但是只能通过向上转型实现。

在向上转型时,子类的特有属性和方法会被隐藏。

通过这次实验,我更深刻地理解了Java的继承机制,并掌握了其在面向对象设计中的重要作用。

在今后的Java开发中,我将充分利用继承的优势,编写出更加优雅和高效的代码。

3 实验三 类的继承及多态

3 实验三 类的继承及多态
}
public void printA2(){
System.out.println("HelloChina!");
}
public void printB(){
System.out.println("Hello "+NAME);
}
}
public class InterfaceExtendsDemo{
public static void main(String args[]){
【源代码】
class Person{
public String name="张三";
}
class Student extends Person{
public String name="张童";
public void print(){
System.out.println("父类中属性: "+);
}
class X implements A,B{
public void printA1(){
System.out.println("Hello World!");
}
public void printA2(){
System.out.println("HelloChina!");
}
public void printB(){
要求:在重写的方法的方法体中需要调用被隐藏的方法返回a和b的最大公约数m,然后将(a*b/m)返回;在应用的程序的主类中分别使用父类和子类创建对象,并分别调用方法f()计算两个正整数的最大公约数和最小公倍数。
4编写一个圆锥类,能够计算圆锥的体积,要求圆锥类的构造函数中有一参数是圆类的一个对象。

实验五

实验五
图5.4
(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(){

继承实验报告实验总结

继承实验报告实验总结

一、实验目的本次实验旨在通过C++语言对类的继承机制进行深入学习和实践,了解不同继承方式下基类成员在派生类中的访问权限,掌握构造函数与析构函数的调用时机与顺序,以及虚基类在多继承中的特殊作用。

二、实验内容1. 类的继承方式(1)公有继承在公有继承中,基类的公有成员和保护成员在派生类中分别作为公有成员和保护成员,派生类的成员函数可以直接访问它们,而无法直接访问基类的私有成员。

在类的外部,派生类的对象可以访问继承下来的基类公有成员。

(2)私有继承在私有继承中,基类的公有成员和保护成员作为派生类的私有成员,派生类的成员函数可以直接访问它们,但无法直接访问基类的私有成员。

在类外部,派生类的对象无法访问基类的所有成员。

(3)保护继承在保护继承中,基类的公有成员和保护成员作为派生类的保护成员,派生类的成员函数可以直接访问它们,但无法直接访问基类的私有成员。

在类外部,派生类的对象无法访问基类的所有成员。

2. 构造函数与析构函数的调用时机与顺序在多继承中,构造函数的调用顺序如下:(1)先调用所有基类的构造函数;(2)再调用派生类中子对象类的构造函数(如果派生类中没有子对象),最后调用派生类的构造函数;(3)析构函数的调用顺序与构造函数相反,先调用派生类的析构函数,再调用子对象类的析构函数,最后调用基类的析构函数。

3. 虚基类的构造函数与普通基类的构造函数在调用时的不同在多继承中,若存在虚基类,则其构造函数只会被调用一次,即使它在多个派生类中被继承。

这是因为虚基类在第一次继承时就已经初始化,后续的继承将直接使用已初始化的虚基类实例。

三、实验结果与分析1. 通过实验,我们验证了不同继承方式下基类成员在派生类中的访问权限,明确了公有继承、私有继承和保护继承的区别。

2. 实验结果显示,在多继承中,构造函数和析构函数的调用顺序符合预期,派生类可以正确地调用基类和子对象类的构造函数和析构函数。

3. 通过实验,我们了解了虚基类在多继承中的作用,避免了重复初始化同一基类的问题。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
System.out.println("中国人的平均体重:67.34公斤");
}
public void chinaGongfu() {
System.out.println("坐如钟,站如松,睡如弓");
}
}
class AmericanPeople extends People {
public void speakHello(){
public void speakHello(){
System.out.println("您好");
}
public void averageHeight(){
System.out.println("北京人的平均身高: 167.0 cm");
}
public void averageWeight(){
System.out.println("北京人的平均体重: 68.5 kg");
{
ComputerWeight[] goodsOne=new ComputerWeight[50],goodsTwo=new ComputerWeight[22];
AmericanPeople americanPeople=new AmericanPeople( );
BeijingPeople beijingPeople=new BeijingPeople( );
chinaPeople.speakHello( );
americanPeople.speakHello( );
System.out.println("average height:"+height);
}
public void averageWeight( ) {
weight=70;
System.out.println("average weight:"+weight);
}
}
class ChinaPeople extends People {
ChinaPeople类是People的子类,新增了public void chinaGongfu()方法。要求ChinaPeople重写父类的public void speakHello()、public void averageHeight()和public void averageWeight()方法。
}
Company company=new Company(employee);
System.out.println("公司年工资总额:"+ company.salariesPay());//调用Company对象的方法输出工资总额
}
}
运行截屏:
实验3
源代码:interface ComputerWeight
AmericanPeople类是People的子类,新增public void americanBoxing()方法。要求AmericanPeople重写父类的public void speakHello()、public void averageHeight()和public void averageWeight()方法。
for(int i=0;i<goods.length;i++)
{
totalWeights+=goods[i].computeWeight();
}
return totalWeights;
}
}
public class Road
{
public static void main(String[] args)
BeijingPeople是ChinaPelple的子类,新增public void beijingOpera()方法。要求ChinaPeople重写父类的public void speakHello()、public void averageHeight()和public void averageWeight()方法。
深圳大学
实验报告
课程名称:Java
实验序号:实验2
实验名称:继承与接口
班级:计算机3姓名:卢志敏
同组人:实验日期:2008年11月16日
教师签字:
一、实验目的
1.继承
子类的继承性
子类对象的创建过程
成员变量的继承与隐藏
方法的继承与重写
2.上转型对象
掌握上转型对象的使用
3.接口回调
掌握接口回调技术
二、实验环境
}
}
class Car
{
ComputerWeight[] goods;
double totalWeights=0;
Car(ComputerWeight[] goods)
{
this.goods=goods;
}
public double getTotalWeights()
{
totalWeights=0;
{
salaries=salaries+employee[i].earnings();
}
return salaries;
}
}
public class HardWork
{
public static void main(String args[])
{
Employee[] employee=new Employee[20];
}
}
class Company
{
Employee[] employee;
double salaries;
Company (Employee[] employee)
{
this.employee=employee;
}
public double salariesPay()
{
salaries=0;
for(int i=0;i<employee.length;i++)
实验2
要求有一个abstract类,类名为Employee。Employee的子类有YearWorker、MonthWorker和WeekWorker。YearWorker对象按年领取薪水,MonthWorker按月领取薪水,WeekWorker按周领取薪水。Employee类有个abstract方法:
for(int i=0;i<employee.length;i++)
{
if(i%3==0)
employee[i]=new WeekWorker();
else if(i%3==1)
employee[i]=new MonthWorker();
else if(i%3==2)
employee[i]=new YearWorker();
}
}
class MonthWorker extends Employee
{
public double earnings( ){
return 12*2300;
}
}
class WeekWorker extends Employee
{
public double earnings( ){
return 48*500;
有一个Car类,该类用ComputeWeight接口类型的数组作为成员,那么该数组的单元就可以存放Television对象的引用、Computer对象的引用或WashMachine对象引用。程序能输出Car对象所能装载的货物的总重量。
按程序模板的要求编写源文件,要特别注意程序的输出结果,并能正确解释输出的结果。
{
public double computeWeight();
}
class Television implements ComputerWeight
{
public double computeWeight()
{
return 10;//实现computeWeight()方法
}
}
class Computer implements ComputerWeight
}
public void beijingOpera() {
System.out.println("京剧术语");
}
}
public class Example {
public static void main(String args[ ]) {
ChinaPeople chinaPeople=new ChinaPeople( );
beijingPeople.speakHello( );
chinaPeople.averageHeight( );
americanPeople.averageHeight( );
beijingPeople.averageHeight( );
chinaPeople.averageWeight( );
americanPeople.averageWeight( );
System.out.println("American Average weight: 80.23 kg");
}
public void americanBoxing() {
System.out.println("直拳钩拳");
}
}
class BeijingPeople extends ChinaPeople {
{
public double computeWeight()
{
return 15;//实现computeWeight()方法
}
}
class WashMachine implements ComputerWeight
相关文档
最新文档