第九次实验

第九次实验

实验一

1、编写一个 Java 程序 , 程序中有一个父类 Telephone,Telephone 类中包含有电话品牌、电话号码、通话时间、费率等属性 , 以及计算话费和显示信息等方法。另外 , 程序中还有另一个类叫作 Mobilephone, 它是 Telephone 的子类 , 除了具有 Telephone 类的属性外 , 它还有自己的属性如网络类型、被叫时间 , 同时它有自己的计算话费和显示信息的方法。 最后程序中应包含一个主类来使用上述两个类并显示它们的信息。 2、代码

class Telephone { String brand, number; double dialledTime; double rate;

Telephone(String b, String n) { brand = b; number = n; }

String getBrand( ) { return brand; }

String getNumber( ) { return number; }

double getrate( ) {

return rate;//代码1 //返回费率值 }

double getDialledTime( ) { return dialledTime; }

void setBrand(String b) { brand = b; }

void setNumber(String n) {

number=n;//代码2 // 设置电话号码 }

void setRate(double r) { rate = r; }

void setDialledTime(double d) { dialledTime = d; }

double callCost( ) {

return dialledTime * rate; }

void display( ) {

System.out.println(\电话品牌: \电话号码: \System.out.println(\通话时间: \费率: \System.out.println(\话费: \} }

class Mobilephone extends Telephone { String network;

double receivedTime;

Mobilephone(String b, String num, String net) { super(b, num); network = net; }

String getNetwork( ) { return network; }

double getReceivedTime( ) { return receivedTime; }

void setNetwork(String n) { network = n; }

void setReceivedTime(double d) {

dialledTime=d;//代码3 //设置被叫时间 }

double callCost( ) {

return (dialledTime + 0.5*receivedTime) * rate; }

void display( ) {

System.out.println(\电话品牌: \电话号码: \+\网络: \

System.out.println(\主叫时间: \被叫时间: \receivedTime +\费率: \

System.out.println(\话费: \} }

public class Inheritance {

public static void main(String[] args) { Telephone tel;

Mobilephone mobile;

tel = new Telephone(\

mobile = new Mobilephone(\tel.setRate(0.2);

tel.setDialledTime(150); mobile.setRate(0.4);

mobile.setDialledTime(80);//代码4 //设置主叫时间为80 mobile.setReceivedTime(120); tel.display( );

System.out.println( );

mobile.display();//代码5 //显示移动电话的信息 } }

3、结果

4、练习

(1) 在 Mobilephone 类的 display() 方法中有如下语句 : System.out.println(\话费 :\

试问这里调用的是子类自己的 callcost() 还是其父类的 callcost(); 如果想要在此处调用 父类的 callcost() 应如何处理。 子类 super.callCost()

(2) 子类 Mobilephone 的构造函数中有语句 super(b,num): 请指出该语句的作用。 然后请将该语句删除掉 , 编译运行程序 , 看看是否会出现编译错误 , 并分析原因。

调用父类的构造方法 会出错 在调用子类构造方法时总是先调用父类的构造方法

事实上 , 如果在子类的构造函数中不显式地使用 super 来调用父类的构造函数的话 ,那么 系统将自动调用父类的无参或默认的构造函数。因此为了纠正这个错误 , 可试着在Telephone 类中加入一个无参的构造函数。

Telephone() { brand = null; number = null; }

(3) 要调用父类的构造函数可以用 super 关键字 , 而要调用本类自己的构造函数可以用 this 关键字 , 请试着在 Telephone 类中加入一个构造函数如下 : Telephone (String b ,String n,double r){ this(b,n); rate =r; }

然后在主程序中用这个构造函数来创建一个 Telephone 对象 , 看看它能否起作用。 能起作用

实验二

1、请设计 3 个类 , 分别是学生类 Student, 本科生类 Undergaduate, 研究生类 Postgraduate,其中 Student 类是一个抽象类 , 它包含一些基本的学生信息如姓名、所学课程、课程成绩等 , 而Undergraduate 类和 Postgraduate 都是 Student 类的子类 , 它们之间的主要差别是计算课程成绩等级的方法有所不同 , 研究生的标准要比本科生的标准高一些 , 如表 1-2 所示。

表 1-2 课程成绩等级 本科生标准 80--100 70--80 60--70 50--60 50 以下 优秀 良好 一般 及格 不及格 80--90 70--80 60--70 60 以下 研究生标准 90--100 优秀 良好 一般 及格 不及格 假设某班级里既有本科生也有研究生 , 请编写程序统计出全班学生的成绩等级并显示出来。此题关键是设计一个学生数组 , 既能存放本科生对象 , 又能存放研究生对象。 2、代码

abstract class Student {

final static int CourseNo = 3; String name; String type;

int[] courses;

String courseGrade;

public Student(String name) { this.name = name;

courses = new int[CourseNo];

courseGrade=\代码1 //初始化courseGrade为空串 }

public abstract void calculateGrade();

public String getName( ) { return name; }

public String getType( ) {

return type;//代码2 //返回学生类型 }

public String getCourseGrade( ) { return courseGrade; }

public int getCourseScore(int courseNumber) { return courses[courseNumber]; }

public void setName(String name) { this.name = name; }

public void setType(String type) { this.type = type; }

public void setCourseScore(int courseNumber, int courseScore) {

courses[courseNumber]=courseScore;//代码3 //按课程索引号设置课程成绩 } }

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=total+courses[i];//代码4 // 累加各门课程成绩 };

average = total / CourseNo;

if (average>=80&&average<100) courseGrade = \优秀\

else if (average>=70&&average<80) courseGrade = \良好\ else if (average>=60&&average<70) courseGrade = \一般\ else if (average>=50&&average<60) courseGrade = \及格\ else courseGrade = \不及格\ } }

class Postgraduate extends Student { public Postgraduate(String name) { super(name); type = \研究生\ }

public void calculateGrade() { int total = 0;

double average = 0;

for (int i = 0; i < CourseNo; i++) { total += courses[i]; };

average = total / CourseNo;

if (average>=90&&average<100) courseGrade = \优秀\

else if (average>=80&&average<90) courseGrade = \良好\ else if (average>=70&&average<80) courseGrade = \一般\ else if (average>=60&&average<70) courseGrade = \及格\ else courseGrade = \不及格\ } }

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(\梁欣欣\代码5 // 创建姓名为梁欣欣的Postgraduate对象students[4]

for (int i=0; i<5 ;i++) {

students[i].setCourseScore(0,87); students[i].setCourseScore(1,90); students[i].setCourseScore(2,78); }

for (int i=0; i<5 ;i++) {

students[i].calculateGrade(); }

System.out.println(\姓名\类型\成绩\ System.out.println(\

for (int i=0; i<5 ;i++) {

System.out.println(students[i].getName( )+\ students[i].getType( )+\ students[i].getCourseGrade( )); } } }

3、结果

4、练习

(l) 在 Polymorphism 类中有一个循环语句用来计算每个学生的成绩等级 for(int i=0;i<5;i 十 +){

student[i].calculateGrade(); }

请问这里的 calculateGrade() 方法是按照研究生的标准还是按照本科生的标准来计算的。 当对象是研究生时按照研究生的标准，是本科生按照本科生的标准来计算 (2) 现在请在程序 Polymorphism 类的 main() 方法中添加如下的语句 Student st=new Student (\李明 \

此时编译是否会报错 , 如有错误 , 请解释原因。 abstract类不能用new运算符创建对象

(3) 在程序中要判断 student[i] 中存放的究竟是 Undergraduate 对象还是 Postgraduate对象 , 只需要调用 student[i].getType() 方法即可 , 然而 Java 提供了一个 instanceof 运算也可以完成这一任务 , 它能判断出一个对象所属的类 , 请将以下代码添加到程序中进行测试。

for (int i=0;i<5;i++){

if(students[i] instanceof Undergraduate)

System.out.println(students[i].getName()+\是本科生 \else

System.out.println(students[i].getName()+\是研究生 \

(4)现在请模仿本程序 , 新增一个高中生类 , 它计算成绩等级的标准采用如下方法 , 然后 在主程序中测试并使用它。 80~100 好 60~80 中 60 以下 差

class High extends Student { public High(String name) { super(name); type = \高中生\ }

public void calculateGrade() { int total = 0;

double average = 0;

for (int i = 0; i < CourseNo; i++) { total += courses[i]; };

average = total / CourseNo;

if (average>=80&&average<100) courseGrade = \好\

else if (average>=60&&average<80) courseGrade = \中\ else courseGrade = \差\ } }

实验三

1、分别编写四个类Point，Point2D，Point3D，Test来表示一维、二维和三维的点及测试类，使之满足下列要求：

(1) Point类的成员变量和成员方法如下所示： 成员变量 int x；

成员方法 ①构造函数Point（int x），实现对成员变量x的初始化 ② void offset(int a)实现对一维点x坐标的平移

③ double distance（Point p）计算当前点到一维点p的距离 (2) Point2D类是Point类的直接子类，其成员变量和成员方法如下所示：

成员变量 int x，y；(分别为二维空间的X,Y方向坐标)，x可从父类继承。 成员方法 ①构造函数Point2D（int x, int y），实现对成员变量x，y的初始化，可先调

用父类的构造函数super（x），实现对x坐标的初始化。

② void offset(int a, int b)实现对二维点坐标的平移，可先调用父类的offset函数实现对x坐标的平移。

③ double distance（Point p）覆盖父类的距离函数，计算当前点到二维点p的距离

(3) Point3D类是Point2D类的直接子类，其成员变量和成员方法如下所示：

成员变量 int x，y，z；(分别为三维空间的X,Y,Z方向坐标)，x，y可从父类继承。 成员方法 ①构造函数Point3D（int x, int y,int z），实现对成员变量x，y，z的初始化，

可先调用父类的构造函数super（x,y），实现对x ，y坐标的初始化。

② void offset(int a, int b,int c)实现对三维点坐标的平移，可先调用父类

的offset函数实现对x，y坐标的平移。

③ double distance（Point p）覆盖父类的距离函数，计算当前点到三维点p的距离

(4)在测试类Test的主函数main()中实例化两个Point2D的对象p2d1，p2d2，打印出它们之间的距离，再实例化两个Point3D的对象p3d1，p3d2，打印出他们之间的距离。 2、代码 class Point{ int x;

Point(int x){ this.x=x; }

void offset(int a){ x=x+a; }

double distance(Point p){

return Math.abs(this.x- p.x); } }

class Point2D extends Point{ int x,y;

Point2D(int x, int y){ super(x); //this.x=x; this.y=y; }

void offset(int a, int b){ super.offset(a); y=y+b; }

double distance(Point p){ return p.x),2)+Math.pow(Math.abs(this.y-y),2)); } }

class Point3D extends Point2D{ int x,y,z;

Point3D (int x, int y,int z){ super(x,y); this.z=z; }

void offset(int a, int b,int c){ super.offset(a,b); z=z+c; }

Math.sqrt(Math.pow(Math.abs(this.x-

本文来源：https://www.bwwdw.com/article/n476.html