实验5 子类与继承
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();}}六、实验小结。
实验报告_实验5 类与类关系与抽象类(学生学号_姓名)
实验报告_实验5类与类关系与抽象类(学生学号_姓名)一、实验目的1.理解继承的概念,掌握子类的创建方法;2.熟悉成员变量的隐藏和方法覆盖;3.掌握使用super访问被隐藏、覆盖的基类变量与方法;4.理解继承的层次结构,熟悉构造方法的执行顺序;5.理解访问修饰符的作用,熟悉访问修饰符对子类继承性的影响;6.熟悉子类对象向上转型的实现方法和Object类的基本用法;7.理解多态种类、意义、实现条件及基本应用;8.理解内部类的作用、种类、实现方法及注意事项;9.理解类与类之间的关系,了解单例模式的实现机理;10.理解抽象类、抽象方法概念,熟悉它们的声明、使用。
二、实验内容与步骤1.(基础题)根据题意及注释补充所缺少代码,然后运行程序public Student(){}public Student(String sno, String sname, int age) {this.sname=sname;this.sno=sno;this.age=age;} public String getSno() {return sno;}public void setSno(String sno) {this.sno = sno;}public String getSname() {return sname;}public void setSname(String sname) {this.sname= sname;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}(1): class CollegeStudent extends Student(2): getSno()(3): getSname()(4): getAge()(5): major(6): student.setAge(26)(7): student.setSname("Jack")(8): cstudent.setSname("Jerry")(9): cstudent.setSno("1840700101")(10): cstudent.setAge(23)(11): cstudent.setMajor("物联网工程")回答相关问题:(1)程序中有多少个类,哪个是主类?哪个是基类?哪个是子类?(2)程序中子类继承了基类哪些成员?基类对象如何给成员赋初值?子类对象又是如何给成员赋值?(3)是否可以不定义Student类的无参构造器?2.(基础题)分析、运行以下程序,并回答相关问题:(1)分析程序,找出有问题的代码,请问出错原因是什么?(2)修改程序中的错误。
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. 在实验过程中,重点是要区分好实例和类,灵活掌握类的调⽤。
继承的含义实验报告
一、实验目的1. 理解继承的概念及其在面向对象编程中的重要性;2. 掌握Java中继承的实现方式;3. 熟悉继承中成员的访问权限;4. 掌握子类与父类之间的关系。
二、实验环境1. 操作系统:Windows 102. 编程语言:Java3. 开发工具:Eclipse三、实验内容1. 定义一个父类Person,包含以下属性和方法:- 属性:name(姓名)、age(年龄)- 方法:setName(String name)、getName(String name)、setAge(int age)、getAge(int age)、toString()2. 定义一个子类Student,继承自Person类,包含以下属性和方法:- 属性:id(学号)- 方法:setId(int id)、getId(int id)3. 编写main方法,创建Person和Student对象,并输出对象信息。
4. 定义一个父类Animal,包含以下属性和方法:- 属性:name(名字)、age(年龄)- 方法:setName(String name)、getName(String name)、setAge(int age)、getAge(int age)、toString()5. 定义一个子类Dog,继承自Animal类,包含以下属性和方法:- 属性:breed(品种)- 方法:setBreed(String breed)、getBreed(String breed)6. 编写main方法,创建Animal和Dog对象,并输出对象信息。
7. 定义一个父类Vehicle,包含以下属性和方法:- 属性:brand(品牌)、model(型号)- 方法:setBrand(String brand)、getBrand(String brand)、setModel(String model)、getModel(String model)、toString()8. 定义一个子类Car,继承自Vehicle类,包含以下属性和方法:- 属性:color(颜色)- 方法:setColor(String color)、getColor(String color)9. 编写main方法,创建Vehicle和Car对象,并输出对象信息。
java类的继承实验报告
java类的继承实验报告Java类的继承实验报告引言:在面向对象的编程语言中,继承是一种重要的概念。
Java作为一种面向对象的编程语言,也提供了类的继承机制。
本实验旨在通过编写Java程序,深入理解和掌握Java类的继承。
实验目的:1. 理解继承的概念和原理;2. 掌握Java中类的继承的语法和用法;3. 实践继承的实际应用。
实验过程:1. 创建父类和子类在实验中,我们首先创建一个父类和一个子类。
父类可以是一个基本的类,子类则继承了父类的属性和方法。
这样,子类就可以在不改变父类的基础上,扩展自己的功能。
2. 继承的语法和用法Java中,使用关键字"extends"来实现类的继承。
子类通过继承父类,可以获得父类的属性和方法,并且可以在子类中添加新的属性和方法。
在实验中,我们可以通过创建子类对象,并调用继承自父类的方法来验证继承的正确性。
3. 方法的重写在继承中,子类可以重写父类的方法。
这样,当子类调用该方法时,实际上执行的是子类重写后的方法。
通过方法的重写,我们可以实现多态性的效果。
4. 实际应用在实验中,我们可以选择一个具体的应用场景,例如动物类的继承。
我们可以创建一个父类Animal,包含基本的属性和方法,然后创建子类Dog和Cat,分别继承Animal类,并添加自己的特有属性和方法。
通过这个实例,我们可以更好地理解继承的实际应用。
实验结果:通过实验,我们成功地创建了父类和子类,并验证了继承的正确性。
我们还成功地重写了父类的方法,实现了多态性的效果。
最后,我们还通过实际应用的例子,更好地理解了继承的实际应用。
实验总结:通过本次实验,我们深入理解和掌握了Java类的继承。
继承是面向对象编程中的重要概念,通过继承,我们可以实现代码的重用和扩展。
在实际应用中,继承也可以帮助我们更好地组织代码,提高代码的可读性和可维护性。
然而,继承也有一些限制和注意事项。
首先,Java中只支持单继承,即一个子类只能继承一个父类。
实验五 继承与派生实验报告
实验五继承与派生一、实验目的( 1 )熟练掌握类的继承,能够定义和使用类的继承关系。
( 2 )掌握派生类的声明与实现方法。
( 3 )掌握类构造函数的初始化列表与作用域分辨符的使用方法。
二、实验工具与准备工作在开始实验前,应回顾或复习相关内容。
需要一台主算机,其中安装有VisualC + + 6 .0 、VisualC + + 2005 、VisualC + + 2005 ExpreSS 、Dev 一C + +或MinGW Developer Studio 等集成开发环境软件。
三、实验内容完成设计性实验项目8.7 创建一个表示雇员信息的employee类,其中包含数据成员name、empNo和salary,分别表示雇员的姓名、编号和月薪。
再从employee类派生出3个类worker、technician和salesman,分别代表普通工人、科研人员、销售人员。
三个类中分别包含数据成员productNum、workHours和monthlysales,分别代表工人每月生产产品的数量、科研人员每月工作的时数和销售人员每月的销售额。
要求各类中都包含成员函数pay,用来计算雇员的月薪,并假定:普通工人的月薪=每月生产的产品数×每件产品的赢利×20%科研人员的月薪=每月的工作时数×每小时工作的酬金销售人员的月薪=月销售额×销售额提成。
#include<iostream>using namespace std;class employee{protected:char name[20];int empNo;float salary;public:employee(char *cp="李强",int no=1001);employee(employee&);void setname(char *cp);void setempNo(int no);void setsalary(float sa);char*getname();int getempNo();float getsalary();void display();employee compsalary(employee *emp);};employee::employee(char *cp,int no){int i=0;while(*cp){name[i]=*cp;i++;cp++;}name[i]='\0';empNo=no;}employee::employee(employee &em) {int i=0;while([i]){name[i]=[i];i++;}name[i]='\0';empNo=em.empNo;salary=em.salary;}void employee::setname(char *cp) {int i=0;while(*cp){name[i]=*cp;i++;cp++;}name[i]='\0';}void employee::setempNo(int no) {empNo=no;}void employee::setsalary(float sa) {salary=sa;}char*employee::getname(){return name;}int employee::getempNo(){return empNo;}float employee::getsalary(){return salary;}void employee::display(){cout<<"工号为"<<empNo<<"的雇员"<<name<<"的月薪为"<<salary<<endl; }employee employee::compsalary(employee *emp){if(this->salary>=emp->salary)return *this;elsereturn *emp;}class worker : public employee{public:worker(char*,int,int);void setproductNum(int n){ productNum=n;}int getproductNum(){ return productNum;}void pay();private:int productNum;static float proper; //每件产品的利润};float worker::proper=30; //假设每件产品的利润为30元worker::worker(char *name,int no,int pronum):employee(name,no){productNum=pronum;}void worker::pay(){salary=productNum*proper*0.2;}class technician : public employee{public:technician(char*,int,float);void sethours(float h){ workHours=h;}float gethours(){ return workHours;}void pay();private:float workHours;static float payperhour; //科研人员每小时工作的酬金};float technician::payperhour=50; //假设科研人员每小时工作的酬金为50元technician::technician(char *name,int no,float hours):employee(name,no){workHours=hours;}void technician::pay(){salary=workHours*payperhour;}class salesman : public employee{public:salesman(char*,int,float);void setmonthlysales(int num){ monthlysales=num;}int getmonthlysales(){ return monthlysales;}void pay();private:float monthlysales;static float percent; //销售人员的销售提成};float salesman::percent=0.6; //假设销售人员的销售提成为60% salesman::salesman(char *name,int n,float sn):employee(name,n){monthlysales=sn;}void salesman::pay(){salary=monthlysales*percent;}void main(){worker w1("王某",1001,1000);technician t1("李某",1002,200);salesman s1("许某",1003,10000);w1.pay();t1.pay();s1.pay();cout<<"工人"<<w1.getname()<<"的月薪为"<<w1.getsalary()<<"元\n";cout<<"科研人员"<<t1.getname()<<"的月薪为"<<t1.getsalary()<<"元\n";cout<<"销售人员"<<s1.getname()<<"的月薪为"<<s1.getsalary()<<"元\n";}8.8 创建一个automobile类表示汽车,其中包含数据成员brand和speed,分别表示汽车的品拍和行驶速度;成员函数run和stop表示行驶和停止。
C++上机实验报告实验五
age=n;
}
//数据输出函数
voidDog::showNumber()
{
cout<<"Number:"<<number<<endl;
}
void Dog::showAge()
{
cout<<"Age:"<<age<<endl;
}
intmain()
{
Dogdog1(12,0);
ﻩdog1.setAge(7);
ﻩvoid showNumber();
ﻩvoid showAge();
};
Animal::Animal(int a)//Animal构造函数
{
age=a;
}
Dog::Dog(intn,inta)//Dog构造函数
{
number=n;
ﻩage=a;
}
voidDog::setAge(int n)//Dog成员函数,setAge
error C2248:‘age’ :cannot access privatemember declaredin class ‘Animal’
把age改为公有成员变量后重新编译就可以了。程序名:lab7_1.cpp。
2.编写程序定义一个基类BaseClass,构造其派生类DerivedClass,在构造函数和析构函数中用cout输出提示信息,观察构造函数和析构函数的执行情况。程序名:lab7_2.cpp。
3.用debug功能跟踪程序lab7_2的执行过程,观察基类和派生类的构造函数和析构函数的执行情况。
4.编写程序定义一个车(vehicle)基类,由此派生出自行车(bicycle)类、汽车(motorcar)类,注意把vehicle派生为虚基类。再从bicycle和motorcar派生出摩托车(motorcycle)类,在main()函数中测试这个类。程序名:lab7_3.cpp。
子类的继承实验报告
#### 一、实验目的1. 理解Java中类的继承机制。
2. 掌握子类继承父类属性和方法的基本方法。
3. 熟悉方法覆盖(重写)和构造函数的继承。
4. 了解多态的概念及其在继承中的应用。
#### 二、实验环境1. 开发工具:Eclipse IDE2. 编程语言:Java3. 操作系统:Windows 10#### 三、实验内容本次实验主要围绕以下几个内容展开:1. 创建一个父类`Animal`,包含基本属性和方法。
2. 创建几个子类,如`Dog`、`Cat`等,继承自`Animal`类。
3. 在子类中重写父类的方法,以展示多态性。
4. 创建一个测试类,测试父类和子类的方法调用。
#### 四、实验步骤1. 创建父类`Animal`:```javapublic class Animal {private String name;private int age;public Animal(String name, int age) { = name;this.age = age;}public void eat() {System.out.println(name + " is eating."); }public void sleep() {System.out.println(name + " is sleeping."); }public String getName() {return name;}public int getAge() {return age;}}```2. 创建子类`Dog`:```javapublic class Dog extends Animal {public Dog(String name, int age) {super(name, age);}@Overridepublic void eat() {System.out.println(getName() + " is eating bones.");}@Overridepublic void sleep() {System.out.println(getName() + " is sleeping in the kennel."); }}```3. 创建子类`Cat`:```javapublic class Cat extends Animal {public Cat(String name, int age) {super(name, age);}@Overridepublic void eat() {System.out.println(getName() + " is eating fish.");}@Overridepublic void sleep() {System.out.println(getName() + " is sleeping on the sofa."); }}```4. 创建测试类`TestInheritance`:```javapublic class TestInheritance {public static void main(String[] args) {Animal dog = new Dog("Buddy", 5);Animal cat = new Cat("Kitty", 3);dog.eat();dog.sleep();cat.eat();cat.sleep();}}```5. 编译并运行程序:- 使用Eclipse IDE打开实验项目,将上述代码分别放入对应的Java文件中。
实验五_继承与多态_(学号+姓名)
实验结果:
实验总结(结论或问题分析):
实验成绩
任课教师签名
郭俊恩
实验报告
课程名称
Java程序设计
实验名称
实验五继承与多态
日期
学生学号
姓名
班级
实验目的:
通过本次实验,要求学生能进一步掌握继承和多态的概念,熟练定义类、派生类、抽象类、抽象方法、虚拟方法和重载方法。
实验条件:
电脑一台、能上网查阅资料。
实验内容与步骤:
首先定义基本几何图形的抽象基类(Shape),然后定义Shape的派生类Circle(圆形)、Square(正方ห้องสมุดไป่ตู้)和Triangle(三角形)。要求通过抽象方法、虚拟方法和重载方法来计算各种图形的面积和周长。(提示:求三角形的面积用海伦公式: ,其中a,b,c是三角形的边长,L=(a+b+c)/2,即周长的一半。)
java实验报告类的继承
java实验报告类的继承Java实验类与继承实验报告实验课程:Java面向程序设计实验实验内容:类与对象院(系):计算机学院专业:计算机科学与技术(软件工程方向)班级:学生姓名:学号:指导教师:2014年 3 月26 日一、实验目的:1、掌握用类来封装对象的属性和行为的方法;2、掌握对象的组合和参数传递;3、掌握类变量与实例变量、类方法与实例方法的区别。
二、实验内容(-)实验题目一:编写一个java应用程序,该程序中有两个类:Tank和Fight具体要求如下:1、Tank类有一个double类型变量speed,用于刻画坦克的速度;一个int型变量bulletAmount,用于刻画坦克的炮弹数量。
定义了speedUp()和speedDown()方法,体现坦克有加速、减速行为;定义了setBulletAmount(int p)方法,用于设置坦克炮弹的数量;定义了fire()方法,体现坦克有开炮行为。
1.程序源代码:package p1;public class Tank {}double getSpeed(){}void fire(){}}package p1;public class Fight {public static void main(String args[]){Tank tank1,tank2; tank1=new Tank(); if(bulletAmount=1){ bulletAmount=bulletAmount-1; System.out.println(打出一发炮弹); } else{ System.out.println(没有炮弹了,无法开火); } return speed; double speed; int bulletAmount; void speedUp(int s){ speed=s+speed; } void speedDown(int d){ } void setBulletAmount(int m){ } return bulletAmount; bulletAmount=m; if(speed-d=0)speed=speed-d; speed=0; else int getBulletAmount(){} tank2=new Tank(); tank1.setBulletAmount(10); tank2.setBulletAmount(10); System.out.println(tank1的炮弹数量:+tank1.getBulletAmount()); System.out.println(tank2的炮弹数量:+tank2.getBulletAmount()); tank1.speedUp(80); tank2.speedUp(90);System.out.println(tank1目前的速度:+tank1.getSpeed()); System.out.println(tank2目前的速度:+tank2.getSpeed()); tank1.speedDown(15); tank2.speedDown(30); System.out.println(tank1目前的速度:+tank1.getSpeed()); System.out.println(tank2目前的速度:+tank2.getSpeed()); System.out.println(tank1开火:); tank1.fire(); System.out.println(tank2开火:); tank2.fire(); tank2.fire(); System.out.println(tank1的炮弹数量:+tank1.getBulletAmount()); System.out.println(tank2的炮弹数量:+tank2.getBulletAmount()); } 2.实验结果:图13、实验课后练习:(1)改进speedUp方法,使得Tank类的对象调用它能将Speed值超过220;答:只需加入如下代码,其实验结果如图2:void speedUp(int s){if(s+speed=200)//加入判断语句即可speed=s+speed;}图2:tank2加速200,超过220,所以tank2数值保持不变(2)增加一个刹车方法:void brake(),Tank类的对象调用它将speed的值变为0.答:只需增加如下代码:其结果如图3所示:void brake(){} speed=0;System.out.println(tank2加速200:);tank2.speedUp(200);System.out.println(tank2调用brake后:); tank2.brake();篇二:JAVA继承实验报告JAVA语言程序设计实验报告实验一实验题目:面向对象编程指导老师:卢照专业班级:计算机科学与技术系1106班姓名:****(20111006**)2014年3月20日一、实验名称:面向对象编程二、实验目的:1.熟悉Java开发运行环境。
5.子类与继承
方法
class A{ void f(){ } void p(){ } } class B extends A{ void f(){ } void g(){ } }
A f() p()
B f() f()
p() g()
方法
class A{ void f(){ } void p(){ } } class B extends A{ void f(){ } void g(){ } A a=new A(); }
Java技术及其应用
练习
课后习题5—6
Java技术及其应用
知识点小结
方法重写与方法重载的区别 方法重写:子类方法与父类方法同名,且参数 个数类型一致,返回类型相同或子类。 方法重载:方法名相同,参数个数或类型不同 ,返回类型相同
Java技术及其应用
重写的方法
重写父类的方法时,不可以降低方法的访问权限 class A{ protected float f(float x,float y){ return x-y; } } class B extends A{ float f(float x,float y){ public float f(float x,float y) } return x+y; } } Java技术及其应用
子类的继承性
从父类未继承的成员 从父类继承的成员
子类对象引用
子类特有的成员
Java技术及其应用
例题
class A{ private int x; void setX(int x){ this.x=x; } int getX(){ return x; } } class B extends A{ double y=12; void setY(int y){ this.y=y+x; } double getY(){ return y; } }
上机实践5子类与继承
实验1中国人、北京人和美国人1 相关知识点由继承而得到的类称为子类,被继承的类称为父类(超类),Java不支持多重继承,即子类只能有一个父类。
人们习惯地称子类与父类的关系是“is-a”关系。
如果子类和父类在同一个包中,那么,子类自然地继承了其父类中不是private的成员变量作为自己的成员变量,并且也自然地继承了父类中不是private的方法作为自己的方法,继承的成员变量或方法的访问权限保持不变。
子类和父类不在同一个包中时,父类中的private 和友好访问权限的成员变量不会被子类继承,也就是说,子类只继承父类中的protected和public访问权限的成员变量作为子类的成员变量;同样,子类只继承父类中的protected和public访问权限的方法作为子类的方法。
子类声明的成员的变量的名字和从父类继承来的成员变量的名字相同时,将隐藏掉所继承的成员变量。
方法重写是指:子类中定义一个方法,这个方法的类型和父类的方法的类型一致或者是父类的方法的类型的子类型,并且这个方法的名字、参数个数、参数的类型和父类的方法完全相同。
子类如此定义的方法称作子类重写的方法。
子类继承的方法所操作的成员变量一定是被子类继承或隐藏的成员变量。
重写方法既可以操作继承的成员变量、调用继承的方法,也可以操作子类新声明的成员变量、调用新定义的其他方法,但无法操作被子类隐藏的成员变量和方法。
2 实验目的本实验的目的是让学生巩固下列知识点。
子类的继承性。
子类对象的创建过程。
成员变量的继承与隐藏。
方法的继承与重写。
3 实验要求编写程序模拟中国人、美国人是人,北京人是中国人。
除主类外,程序中还有4个类:People、ChinaPeople、AmericanPeople和BeijingPeople类。
要求如下。
People类有权限是protected的double型成员变量height和weight,以及public void speakHello()、public void averageHeight()和public void averageWeight()方法。
Java语言程序设计实验类与对象子类与继承
Java语言程序设计实验类与对象子类与继承实验目的:1.理解类与对象的概念,并能够创建类和对象。
2.理解子类与继承的概念,并能够使用继承实现类的扩展和重用。
实验内容:1. 创建一个名为Person的类,包含以下属性:姓名(name)、年龄(age)、性别(gender)。
-提供构造方法用于初始化对象。
- 提供getter和setter方法用于访问和修改属性。
- 提供toString方法用于返回对象的字符串表示。
2. 创建一个名为Student的子类,继承自Person类,新增以下属性:学号(studentId)、班级(classroom)。
-提供构造方法用于初始化对象。
- 提供getter和setter方法用于访问和修改属性。
- 重写父类的toString方法,将新增属性也包含在返回的字符串中。
3. 创建一个名为Teacher的子类,继承自Person类,新增以下属性:工号(teacherId)、职称(title)。
-提供构造方法用于初始化对象。
- 提供getter和setter方法用于访问和修改属性。
- 重写父类的toString方法,将新增属性也包含在返回的字符串中。
4. 创建一个名为Test的类,包含main方法。
- 在main方法中创建一个Person对象,设置其属性并打印。
- 在main方法中创建一个Student对象,设置其属性并打印。
- 在main方法中创建一个Teacher对象,设置其属性并打印。
实验步骤:1. 创建一个名为Person的类,包含姓名、年龄、性别三个属性,并提供构造方法、getter和setter方法以及toString方法。
```javapublic class Personprivate String name;private int age;private String gender;public Person(String name, int age, String gender) = name;this.age = age;this.gender = gender;}public String getNamreturn name;}public void setName(String name) = name;}public int getAgreturn age;}public void setAge(int age)this.age = age;}public String getGendereturn gender;}public void setGender(String gender) this.gender = gender;}public String toStrinreturn "Person{" +"name='" + name + '\'' +", age=" + age +", gender='" + gender + '\'' +'}';}```2. 创建一个名为Student的子类,继承自Person类,新增学号和班级两个属性,并提供构造方法、getter和setter方法以及重写的toString方法。
java实验报告类构造函数与继承
实验报告课程名称: Java程序设计成绩评定:实验项目名称:实验5:类构造函数与继承指导教师:学生姓名:学号:专业班级:实验项目类型:基础实验地点:验时间:一、实验目的与要求:1、理解类和对象的区别,掌握构造函数的使用,熟悉通过对象名引用实例的方法和属性,进一步掌握方法调用时参数的传递;2、掌握package、jar打包功能与应用;4、掌握类的继承,理解继承中的覆盖现象.二、实验内容:1、按照要求完成程序public class Test{public static void main(String args[]){System.out.println("创建父类对象:");SuperClass sc0 = new SuperClass();System.out.println("\n创建第一个子类对象:");SubClass sc1 = new SubClass();System.out.println("\n创建第二个子类对象:");SubClass sc2 = new SubClass(1);}}class SuperClass{SuperClass( ){System.out.println("父类的构造函数");}}class SubClass extends SuperClass{SubClass( ){System.out.println("子类的第一个构造函数");}SubClass(int i){System.out.println("子类的第二个构造函数");}}要求:1)运行程序写出结果;创建父类对象:父类的构造函数创建第一个子类对象:父类的构造函数子类的第一个构造函数创建第二个子类对象:父类的构造函数子类的第二个构造函数2)去掉SubClass的所有构造函数,然后将Test类中main方法的最后两行语句删除。
继承与多态实验报告
继承与多态实验报告继承与多态实验报告在面向对象编程中,继承和多态是两个重要的概念。
通过继承,我们可以创建新的类,并从现有的类中继承属性和方法。
而多态则允许我们使用父类的引用来指向子类的对象,实现同一操作具有不同的行为。
本实验旨在通过实际的编程实践,加深对继承和多态的理解。
实验一:继承在这个实验中,我们创建了一个动物类(Animal),并从它派生出了两个子类:狗类(Dog)和猫类(Cat)。
动物类具有一些共同的属性和方法,如名字(name)和发出声音(makeSound)。
子类继承了父类的属性和方法,并可以添加自己的特定属性和方法。
在编写代码时,我们首先定义了动物类,并在其中实现了共同的属性和方法。
然后,我们创建了狗类和猫类,并分别在这两个类中添加了自己的特定属性和方法。
通过继承,我们可以在子类中直接使用父类的方法,并且可以根据需要进行重写。
实验二:多态在这个实验中,我们使用多态的概念来实现一个动物园的场景。
我们定义了一个动物园类(Zoo),并在其中创建了一个动物数组。
这个数组可以存储不同类型的动物对象,包括狗、猫等。
通过多态,我们可以使用动物类的引用来指向不同类型的动物对象。
例如,我们可以使用动物类的引用来指向狗对象,并调用狗类特有的方法。
这样,我们可以统一处理不同类型的动物对象,而不需要为每种类型编写特定的处理代码。
实验三:继承与多态的结合应用在这个实验中,我们进一步探索了继承和多态的结合应用。
我们定义了一个图形类(Shape),并从它派生出了三个子类:圆形类(Circle)、矩形类(Rectangle)和三角形类(Triangle)。
每个子类都实现了自己的特定属性和方法。
通过继承和多态,我们可以在图形类中定义一些通用的方法,如计算面积和周长。
然后,我们可以使用图形类的引用来指向不同类型的图形对象,并调用相应的方法。
这样,我们可以轻松地对不同类型的图形进行统一的处理。
结论:通过本次实验,我们进一步理解了继承和多态的概念,并学会了如何在编程中应用它们。
java教程--子类与继承.ppt
默认继承类
ng.Object类: 所有类的祖先 class A{ } 相当于 class A extends ng.Object{ } 如果缺省extends子句,则该类为ng.Object 的子类。
Java技术及其应用
ng.Object类
它处于Java开发环境的类层次树的根部,其他所 有的类都直接或间接地为它的子类。该类定义了 一些所有对象最基本的状态和行为,例如: equals()判断两个对象引用是否相同,等价于== getClass()返回一个对象在运行时所对应的类的 表示,从而可以得到相应的信息。 toString()返回对象的字符串表示。
Java中支持多层继承。
再思考一下继承的作用?
1、提高代码复用度,减少代码; 2、方便扩展,在以前的基础上进行改进 3、总之,取其精华、引入创新
本章学习内容
1、子类继承父类的属性和方法 2、父类的属性和方法不够用怎么办? 研究:子类增加新的属性和方法 3、父类如果想保留某些属性和方法怎么办? 研究:父类设定某些属性和方法不允许继承 4、父类的某些属性和方法,不太适合子类怎么办? 研究:子类修改父类的属性和方法 5、父类不想被继承怎么办? 研究:为了保密性,类可设置为不允许继承 6、父类允许被继承,但是不想被修改属性和方法怎么办? 父类的某些属性和方法允许继承,但是不允许子类修改;
子类的继承性
若子类和父类在同一个包内,子类可以继承父类中 访问权限设定为public、 protected、 default的成 员变量和方法。 若子类和父类不在同一个包内,子类可以继承父类 中访问权限设定为public、 protected的成员变量 和方法。
例题 正常继承
class A{ int x; void setX(int x){ this.x=x; } int getX(){ return x; } } class B extends A{ double y=12; void setY(int y){ this.y=y+x; } double getY(){ return y; } }
第5章子类与继承
UniverStudent geng = new UniverStudent();
geng.number=6609;
geng.tellHeightAndWeight();
geng.tellNumber();
System.out.print("geng会做加减乘除:");
result=geng.add(x,y);
protected方法的权限如下列(1)、(2)所
述。
(1)对于子类D中声明的protected成员变量和方法, 如果object要访问这些protected成员变量和方法,只 要Other类和D类在同一个包中就可以了。
(2)如果子类D的对象的protected成员变量或 protected方法是从父类继承的,那么就要一直追溯 到该protected成员变量或方法的“祖先”类,即A类, 如果Other类和A类在同一个包中,那么object对象能 访问继承的protected变量和protected方法。
double re=geng.div(x,y);
System.out.printf("%d÷%d=%f\n",x,y,re);
}
}
当子类和父类不在同一个包中时,父类中的private 和友好访问权限的成员变量不会被子类继承,也就 是说,子类只继承父类中的protected和public访问权 限的成员变量作为子类的成员变量;同样,子类只 继承父类中的protected和public访问权限的方法作为 子类的方法。
zhang.tellNumber();
System.out.print("zhang会做加减:");
int result=zhang.add(x,y);
子类与继承笔记
子类与继承笔记一、基本概念。
(一)继承的定义。
在面向对象编程中,继承是一种机制,它允许创建一个新的类(子类或派生类),这个新类从一个现有的类(父类或基类)中获取属性(成员变量)和方法(成员函数)。
子类继承父类的特征,并且可以添加自己特有的属性和方法,还可以对从父类继承的方法进行重写(覆盖)。
(二)继承的意义。
1. 代码复用。
- 避免重复编写相同的代码。
例如,如果有一个“动物”类,它具有“吃”和“呼吸”等方法。
当创建“狗”类和“猫”类时,由于它们都是动物,都具有这些基本行为,通过继承“动物”类,就不需要在“狗”类和“猫”类中重新编写“吃”和“呼吸”的方法代码。
2. 层次结构建模。
- 可以更好地对现实世界中的事物进行建模。
在现实中,事物往往具有层次关系。
例如,在图形系统中,“图形”是一个基类,它可能有属性如颜色、位置等。
然后有“圆形”“矩形”等子类,它们继承了“图形”类的基本属性,同时又有自己独特的属性(如圆形的半径、矩形的长和宽)。
二、在编程语言中的实现(以Java为例)(一)语法。
1. 定义父类。
- 例如,定义一个简单的父类“Animal”:java.class Animal {private String name;public Animal(String name) { = name;}public void eat() {System.out.println(name + " is eating."); }}2. 定义子类。
- 定义一个“Dog”子类继承“Animal”类:java.class Dog extends Animal {public Dog(String name) {super(name);}public void bark() {System.out.println("The dog is barking."); }}- 在上述代码中,“extends”关键字用于表示继承关系。
子类与继承
public class Circle extends Geometry { double r; Circle(double r) { this.r=r; } public double getArea() { return(3.14*r*r); } }
public class Pillar { Circle bottom; //bottom是抽象类Geometry声明的变量 double height; Pillar (Geometry bottom,double height) { this.bottom=bottom; this.height=height; } public double getVolume() { return bottom.getArea()*height; //bottom可以调用子类重写的 getArea方法 } }
•无法直接操作: •被隐藏的成员变量和方法; •但 可 以 使 用 super 关 键 字 操 作 隐 藏 的 变 量 和 方 法 (第四节)
例3, 情况1 如果将子类改为: double computer(float x,float y){ „„ } 情况2 如果将父类改为: double computer(float x,float y){ „„ } 情况3 如果将子类改为: float computer(float x,float y, double z){ „„ } 情况4 如果将父类改为: protected float computer(float x,float y, double z){ „„ }
例9
• §6.9
面向抽象编程
35
2010-8-1
在设计一个程序时,可以通过在 abstract 类中声明若干个 abstract 方法, 表明这些方法在整个系统设计中的重要性, 方法体的内容细节由它的非 abstract 子类 去完成。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
public void actionPerformed(ActionEvent event)
{
if (urlStack.size() <= 1) return;
try
{
// get URL from back button
urlStack.pop();
// show URL in text field
3.用URL对象作为参数,调用setPage()方法,将HTML文件读到JeditorPane容器中,在该容器中的HTML文件,会被解释执行,即可看到网页的运行效果。
4.窗口中按BorderLayout页面布局各组件。
二、实验题目:
用户在JTextField中输入URL,
按回车或单击访问键(JButton),程序利用JEditorPane来显示网页内容
editorPane.setPage(url.getText());
}
catch (IOException e)
{
editorPane.setText("Exception: " + e);
}
}
};
JButton loadButton = new JButton("Load");
loadButton.addActionListener(listener);
*/
class EditorPaneFrame extends JFrame
{
public EditorPaneFrame()
{
setTitle("EditorPaneTest");
setSize(DEFAULT_WIDTH, DEFAULT_HEIGHT);
final Stack<String> urlStack = new Stack<String>();
frame.setVisible(true);
}
}
/**
This frame contains an editor pane, a text field and button
to enter a URL and load a document, and a Back button to
return to a previously loaded document.
class EditorPaneTest
{
public static void main(String[] args)
{
JFrame frame = new EditorPaneFrame();
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
ActionListener listener = new
ActionListener()
{
public void actionPerformed(ActionEvent event)
{
try
{
// remember URL for back button
urlStack.push(url.getText());
panel.add(url);
panel.add(loadButton);
panel.add(backButton);
panel.add(new JLabel("Editable"));
panel.add(editable);
add(panel, BorderLayout.SOUTH);
}
private static final int DEFAULT_WIDTH = 600;
三、实验步骤(详细的基本操作步骤)
import java.awt.*;
import java.awt.event.*;
import java.io.*;
import .*;
import java.util.*;
import javax.swing.*;
import javax.swing.event.*;
final JEditorPane editorPane = new JEditorPane();
final JTextField url = new JTextField(30);
// set up hyperlink listener
editorPane.setEditable(false);
editorPane.addHyperlinkListener(new
{
editorPane.setText("Exception: " & set up checkbox for toggling edit mode
final JCheckBox editable = new JCheckBox();
editable.addActionListener(new
HyperlinkListener()
{
public void hyperlinkUpdate(HyperlinkEvent event)
{
if (event.getEventType() == HyperlinkEvent.EventType.ACTIVATED)
{
try
{
// remember URL for back button
【JAVA程序设计】实验报告
班级:计12本2学号:1212210222姓名:张浩
实验5子类与继承
实验类型
设计
实验日期
2014-12-12
实验地点
2s-417
实验时间(星期节次)
星期五三四节
指导教师
刘红霞
成绩
一、实验目的及要求:
1.创建URL类的对象,将URL对象指向要获取的网站的HTML文件。
2.定义JEditorPane对象,对象调用setEditable()方法将编辑属性设为false。
}
});
add(new JScrollPane(editorPane), BorderLayout.CENTER);
// put all control components in a panel
JPanel panel = new JPanel();
panel.add(new JLabel("URL"));
private static final int DEFAULT_HEIGHT = 400;
}
四、实验总结:
本次试验让我们对交互界面JTextField、JButton、JEditorPane的基本操作有了初步的了解与掌握,对于URL类的创建也得到了练习。
url.addActionListener(listener);
// set up back button and button action
JButton backButton = new JButton("Back");
backButton.addActionListener(new
ActionListener()
ActionListener()
{
public void actionPerformed(ActionEvent event)
{
editorPane.setEditable(editable.isSelected());
}
});
// set up load button for loading URL
urlStack.push(event.getURL().toString());
// show URL in text field
url.setText(event.getURL().toString());
editorPane.setPage(event.getURL());
}
catch (IOException e)
String urlString = urlStack.peek();
url.setText(urlString);
editorPane.setPage(urlString);
}
catch (IOException e)
{
editorPane.setText("Exception: " + e);
}