第九次实验

更新时间：2024-04-03 16:25:01 阅读量：综合文库文档下载

说明：文章内容仅供预览，部分内容可能不全。下载后的文档，内容与下面显示的完全一致。下载之前请确认下面内容是否您想要的，是否完整无缺。

第九次实验

实验一

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-

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

public class Test{

public static void main(String []args){ Point2D p2d1=new Point2D(3,4); Point2D p2d2=new Point2D(6,8); Point3D p3d1=new Point3D(2,1,1); Point3D p3d2=new Point3D(3,4,4);

System.out.println(\和p2d2的距离\ System.out.println(\和p3d2的距离\ System.out.println(p2d1.distance(p2d2)); System.out.println(p3d1.distance(p3d2));

System.out.println(\和p2d2的x,y平移1个单位\ p2d1.offset(1,1); p2d2.offset(1,1);

System.out.println(\和p3d2的x,y平移1个单位\ p3d1.offset(1,1); p3d2.offset(1,1);

System.out.println(\平移后p2d1和p2d2的的距离\ System.out.println(p2d1.distance(p2d2));

System.out.println(\平移后p3d1和p3d2的的距离\ System.out.println(p3d1.distance(p3d2)); } }

3、结果

4、分析

实验四 1、设计一个人员类（Person），以及从Person类派生出助教类（Assistant）、讲师类（Instructor）、副教授类（AssistantProfesson）和教授类（Professor）。四种类型教师的工资收入计算公式如下：

工资收入＝基本工资＋授课时数×每课时报酬

其中，助教基本工资为800元，每课时报酬25元，讲师基本工资为1000元，每课时报酬35元，副教授基本工资为1200元，每课时报酬40元，教授基本工资为1400元，每课时报酬50元。

将人员类定义为抽象类，具体定义如下： abstract class Person { String name; double salary; //工资收入

int hour; //课时

abstract double countSalary(int hour);//计算工资收入

abstract public String toString();//返回员工的姓名、职称、收入字符串

abstract public boolean equals(Person p);//与另一员工比较职称及工资收入是否一样 }

请为四种类型教师自行设计合理的类，但必须继承自Person类，另编写一个测试类测试你所编写的类，要求输入两个员工的姓名，职称和授课时数后分别显示他们的姓名、职称、收入，并比较两人职称及工资收入是否一样。 2、代码

import java.util.*; abstract class Person{ String name; double salary; //工资收入 int hour; //课时 abstract double countSalary(int hour);//计算工资收入 abstract public String toString();//返回员工的姓名、职称、收入字符串 abstract public boolean equals(Person p);//与另一员工比较职称及工资收入是否一样 }

class Assistant extends Person{ double countSalary(int hour){ salary=800+hour*25; return salary; } public String toString(){ return \姓名 \职称 \收入 \ } public boolean equals(Person p){ boolean flag=false; if(this.getClass().equals(p.getClass().getName())&&p.salary==this.salary) flag=true; return flag; } }

class Instructor extends Person{ double countSalary(int hour){ salary=1000+hour*35; return salary; } public String toString(){ return \姓名 \职称 \收入 \ } public boolean equals(Person p){ boolean flag=false; if((p instanceof Instructor)&&p.salary==this.salary) //if(this.getClass().getName().equals(p.getClass().getName())&&p.salary==this.salary) flag=true; return flag; } }

class AssistantProfesson extends Person{ double countSalary(int hour){ salary=1200+hour*40; return salary; } public String toString(){ return \姓名 \职称 \收入 \ } public boolean equals(Person p){ boolean flag=false; if(this.getClass().getName().equals(p.getClass().getName())&&p.salary==this.salary) flag=true; return flag; } }

class Professor extends Person{ double countSalary(int hour){ salary=1400+hour*50; return salary; } public String toString(){ return \姓名 \职称 \收入 \ } public boolean equals(Person p){ boolean flag=false; if(this.getClass().getName().equals(p.getClass().getName())&&p.salary==this.salary) flag=true; return flag; } }

public class Test4{ public static void main(String []args){ Assistant p1=new Assistant(); p1.name=\李强\ p1.countSalary(10); System.out.println(p1.toString()); Instructor p2=new Instructor(); p2.name=\陈晨\ p2.countSalary(10); System.out.println(p2.toString()); Instructor p3=new Instructor();

p3.name=\陈五\ p3.countSalary(10); System.out.println(p3.toString()); System.out.println(\陈晨和李强比较\ String out=p1.equals(p2) ? \两人职称及工资收入一样\两人职称及工资收入不一样\ System.out.println(out); System.out.println(\陈晨和陈五比较\ String out1=p2.equals(p3) ? \两人职称及工资收入一样\两人职称及工资收入不一样\ System.out.println(out1); Scanner reader=new Scanner(System.in); } }

3、结果

3、分析

学会使用get.class() getName()和instanceof 方法的使用

实验五 1、代码

public class StringExample{

public static void main(String args[]) {

String s1=new String(\ String s2=new String(\

if(s1.equals(s2)) { // 使用equals方法判断s1与s2是否相同 System.out.println(\与s2相同\ } else{

System.out.println(\与s2不相同\ }

String s3=new String(\

if(s3.equals(220302)){ //判断s3的前缀是否是“220302” System.out.println(\吉林省的身份证\ }

int position=0;