第3章-面向对象程序设计-上机实验要求(1)

更新时间：2024-01-22 11:08:01 阅读量：教育文库文档下载

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

第一题：

1. 编写一个圆环类Ring的Java程序。圆环类有3个数据成员，分别是内半径innerRadius，

外半径outerRadius和颜色color，这些属性可以查看get也可以重新设置set。另外，圆环还可以返回其面积。程序运行效果如下图所示：

实验要求：

A. 现将下面的源程序补充完整

B. 现在将Ring ring = new Ring(5,8,\改成Ring ring = new Ring();编译运行有错误

发生吗？分析错误的原因

C. 为程序添加一个默认构造函数，看一下运行结果

Public Ring(){

innerRadius=1.0; outerRadius=2.0; color=\}

D. 把程序中的如下语句:

System.out.println(\圆环的内半径: \

System.out.println(\圆环的外半径: \改成：

System.out.println(\圆环的内半径: \

System.out.println(\圆环的外半径: \

编译运行，其结果如何？应如何修改这个错误？

E. 请为该圆环类再添加两个方法以便能返回内圆和外圆的周长，然后在main()函数中

分别创建两个对象ring1，ring2以显示周长。 F. 注：源代码Ring.java public class Ring {

private double innerRadius; private double outerRadius; public String color;

public Ring(double iRadius, double oRadius, String c) {

innerRadius = iRadius; //初始化外半径

color = c; }

public double getInnerRadius( ) {

//返回内半径 }

public double getOuterRadius( ) {

return outerRadius; }

public void setInnerRadius(double iRadius) {

innerRadius = iRadius; }

public void setOuterRadius(double oRadius) {

outerRadius = oRadius; }

public void setColor(String c) {

//设置颜色 }

public double getArea() {

return (outerRadius * outerRadius - innerRadius * innerRadius) * 3.1415; }

public static void main(String[] args) {

Ring ring = new Ring(5,8,\ System.out.println(\圆环的内半径: \ System.out.println(\圆环的外半径: \ System.out.println(\圆环的颜色: \

System.out.println(\圆环的面积: \

ring.setInnerRadius(4); //设置圆环ring的外半径为6 ring.setColor(\ System.out.println(\圆环的内半径: \ System.out.println(\圆环的外半径: \ System.out.println(\圆环的颜色: \ System.out.println(\圆环的面积: \ } }

第二题：

2. 编写一个圆类Circle，其中有圆周率、半径和圆对象个数，其中圆周率和圆对象个数为

static成员。此外，Circle中还有两个static方法分别是设置圆周率和显示当前圆对象个数，其余都是实例成员，仔细体会静态成员与实例成员的差别和使用方法。程序运行效果如下：实验要求：

A. 请将程序中的语句：

System.out.println(\圆周率是: \cir1.displayNo(); 改成

System.out.println(\圆周率是: \Circle.displayNo();

修改后编译运行，程序会报错吗？为什么？接着如果将语句cir1.setRadius(10);改成Circle.setRadius(10);情况又会怎样呢？

B. 现在将圆周率Pi的static去掉，修改后编译运行，会报错吗？产生错误的原因是什

么？

C. 程序中的数据成员objectNo为什么要设置成static类型？它的作用是什么？ D. 注：源代码StaticTest.java class Circle {

static double pi = 3.14; static int objectNo = 0; int radius;

Circle(int r) {

radius=r; objectNo++; }

Circle( ) {

radius = 2; objectNo++; }

double getArea( ) {

return pi*radius*radius; }

static void setPI(double p) {

pi = p; }

void setRadius(int r) { radius = r; }

static void displayNo( ) { System.out.println(\当前圆对象个数是: \ } }

public class StaticTest {

public static void main( String args[] ) {

Circle cir1 = new Circle(5);

System.out.println(\圆周率是: \ System.out.println(\的半径是: \

System.out.println(\的面积是: \ cir1.displayNo(); cir1.setRadius(10); Circle cir2 = new Circle( );

cir2.setPI(3.1415); System.out.println(\圆周率是: \ System.out.println(\的半径是: \ System.out.println(\的半径是: \ System.out.println(\的面积是: \ cir2.displayNo(); } }

第三题：

3. 查看如下源程序：实验要求：

A. 请先分析程序的运行结果，然后再运行该源代码：

程序结果分析： B. 将程序中的语句//z=20;前面的注释符去掉，编译会报错吗？为什么？

C. 程序中有两个方法setx()与setm()，它们分别是对类中的数据x和m进行设置。现

在将在方法setm()中的ScopeTest.m=m;改成this.m=m，编译程序是否会报错？如果确实会报错，再将setm()方法前面的static修饰符去掉，看是否能编译成功，并解释其中的原因。

D. 在程序中方法show()中定义了一个循环语句，在这个循环语句块里声明了一个变量

z，现将这个变量z的名字改成y，编译程序，看其运行情况 E. 源代码：ScopeTest.java class ScopeTest {

int x;

static int m=0;

void show( ) { int x=8, y; for (y=0; y<2; y++) { int z=5; System.out.println(\ z = 10;

System.out.println(\

System.out.println(\方法域中的X = \在块内显示\ } // z = 20;

System.out.println(\方法域中的X = \在块外显示\ System.out.println(\类域中的X = \在块外显示\ System.out.println(\类域中的m = \在块外显示\ }

void setx(int x){ this.x = x; }

static void setm(int m) { ScopeTest.m = m; }

public static void main(String[] args) { ScopeTest application = new ScopeTest( ); application.setx(2); application.setm(3); application.show( ); } }

第四题：

4. 查看如下源程序，其运行结果如下：

实验要求：

A. 现将下面的源程序补充完整

B. 现向程序添加一个如下所示的新的add()方法

double add(int a,int b){

System.out.println(\整形加法但返回实型值\return (double)(a+b); }

编译时会出现什么情况，这说明了什么问题？

C. 源代码：Overload.java class Overload {

int m,n;

Overload( ) { m = 0; n = 0; }

Overload(int a, int b) {

//初始化变量m //初始化变量n }

int add( ) { System.out.println(\无参加法 \ return m+n; }

int add(int a, int b) { System.out.println(\整型加法 \ return a+b; }

double add(double a, double b) { System.out.println(\实型加法 \ return a+b; }

double add(int a, int b, double c) { System.out.println(\混合加法 \ //返回加法运算的结果 }

public static void main(String[] args) {

int ix,iy; double dx,dy; //声明一个Overload对象ov并初始化

ix = ov.add(); iy = ov.add(3,6); //调用实型加法函数，参数为2.1，5.3 dy = ov.add(3, 6, 2.2); } }

第五题：

5. 查看如下源程序，其运行结果如下：

实验要求：

A. 现将下面的源程序补充完整

B. 在Mobilephone类的display()方法中有如下语句：

System.out.println(\话费: \

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

C. 子类Mobilephone的构造函数中有语句super(b,num);请指出该语句的作用。接着将

该语句删除掉，编译运行程序，看看是否会出现下面的错误，并分析原因。 Inheritance.java:54: 找不到符号符号：构造函数 Telephone() 位置：类 Telephone

Mobilephone(String b, String num, String net) {

^ 1 错误

D. 如果上面语句删除掉了，又想改正其错误，应如何修改？

E. 要调用父类的构造函数可以用super，而要调用本类自身的构造函数可用this，请

试着在Telephone类中新加入一个构造函数如下： Telephone(String b, String n, double r) {

this(b,n); rate = r; }

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

F. 现在在Telephone类为父类，设计一个新的子类叫做小灵通，这个小灵能继承了

Telephone类的属性，但又与移动电话有所区别。 G. 源代码：Inheritance.java 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 getDialledTime( ) { return dialledTime; }

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

void setNumber(String n) {

//设置电话号码 }

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) {

//设置被叫时间 }

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); //设置主叫时间为80 mobile.setReceivedTime(120); tel.display( );

System.out.println( ); //显示移动电话的信息 } }

第六题：

6. 设计三个类分别是学生类Student、本科生类Undergraduate和研究生类Postgraduate。

其中Student类是一个抽象类，它包含一些基本的学生信息，如姓名、所学课程、课程成绩等，而Undergraduate和Postgraduate类都是Student类的子类，它们之间的差别是计算课程成绩等级的方法有所不同。如下表所示：标准 80~100 70~80 60~70 50~60 50以下本科生优秀良好一般及格不及格 90~100 80~90 70~80 60~70 60以下研究生标准优秀良好一般及格不及格假设某班级时既有本科生也有研究生，编写程序统计出全班学生的成绩等级并显示出来。查看如下源程序，其运行结果如下：

实验要求：

A. 现将下面的源程序补充完整

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

students[i].calculateGrade(); }

这里的calculateGrade()方法是按照研究生的标准还是按照本科生的标准来计算的？

C. 在程序Polymorphism类中，哪些语句体现了子类的对象可以赋值给父类的引用变

量？

D. 在程序Polymorphism类的main()方法中添加下的语句：

Student st = new Student(\李明\

此时编译是否会报错？如有错误，请解释原因。

E. 在程序中要判断Student[i]中存放的究竟是Undergraduate对象还是Postgraduate对

象，只需要调用students[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( )+\是研究生\ }

F. 模拟本程序，新增加一个高中生类，它计算成绩等级的标准采用如下方法，然后在

程序中测试并使用它。标准 80~100 60~80 60以下高中生 G. 源代码：Polymorphism.java

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 }

好中差 public abstract void calculateGrade();

public String getName( ) {

//返回学生类型 } public String getType( ) {

return type; } 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) {

//按课程索引号设置课程成绩 } }

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++) {

//累加各门课程成绩 };

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(\周丽娜\ //创建姓名为梁欣欣的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( ));

} } }

第七题：

7. 通过编制一个程序来加深对嵌套类、内部类和局部的理解，该程序要求定义一个外部类

Outer，然后在Outer类中定义一个内部类Inner和局部类Local，Inner类和Local类是任务是显示出外部类中的数组元素，然后求出这些数组元素的平均值。程序运行结果如下图所示：

实验要求：

A. 现将下面的源程序补充完整

B. 编译完成后将产生4个class文件，分别是InnerClass.class，Outer.class，

Outer$Inner.class，Outer$1Local.class，注意这些类的命名规则，然后运行InnerClassTest.class文件，观察程序输出的结果。

C. 从程序运行结果来看，内部类Inner和局部类Local都能直接访问外部类Outer的

data[]数组，那么反过来外部类中的方法能否直接访问内部类Inner和局部类Local中的成员呢？将checkInner()方法中的innerObj.show( );改成show( );同时checkLocal()中的localObj.show( );方法改成show( );测试这个结果 D. 在内部类Inner的定义前加上static使其变成static嵌套类。

Static class Inner{}

编译会出现什么结果？

E. 在上题中由于static嵌套类不能直接访问其外部类的非静态成员，从而导致编译错

误。如果把外部类Outer的data[]数组也定义成static类型，static int data[]看看能否解决这个问题，并解释其中的原因。

F. 在Java中，static嵌套类可以像普通类一样进行声明，现保持上二题所做的修改，

同时在InnerClassTest类的main()方法的最后加上如下语句，然后编译运行观察结果。

Outer.Inner innerObj2=new Outer.Inner(); innerObj2.show();

G. 将源代码恢复到最初的状态，并在此基础上做如下修改：在内部类Inner中新增一

个静态变量static int result;，然后将average()方法所求出的平均值存入该变量中； result=sum/data.length; return result;

编译运行注意观察错误提示。 H. 源代码：InnerClassTest.java class Outer {

private int data[];

Outer(int x[]) { data = x; }