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

第一题：

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; }

void checkInner() { Inner innerObj = new Inner(); //调用Inner对象的show()方法 System.out.println(\内部类计算的平均值: \ }

void checkLocal() { class Local {

void show() { System.out.print(\从局部类显示数组元素:\ for (int i=0; i

int average() {

int sum=0; for (int i=1; i

} }; Local localObj = new Local();

localObj.show( );

System.out.println(\局部类计算的平均值: \ }

class Inner {

void show() { System.out.print(\从内部类显示数组元素:\ for (int i=0; i

int average() {

int sum=0; for (int i=1; i

public class InnerClassTest {

public static void main(String[] args) {

int a[] = {6,8,9,22,34,7,2,1,15}; Outer outerObj = new Outer(a); outerObj.checkInner(); //调用outerObj对象的checkLocal方法 } }

第八题(自已动手)：

实验要求：

A. 设计和实现一个Soundable接口，该接口具有发声功能，同时还能调节声音大小。

Soundable接口的这些功能将会由三种声音设备来具体实现，它们分别是收声机Radio、随声听Walkman和手机Mobilephone。最后还要设计一个应用程序类来使用这些实现了Soundable接口声音设备类。

B. 程序运行时，先询问用户想听哪种设备，然后程序就会按照该设备的工作方式来发

出声音（注：这里发出声音，只是要大家显示出相应的文字提示即可）。在运行过程中，一直提示增大音量、减小音量还是关闭手机，只有在选择关闭手机时，才会结束程序的运行。程序运行效果如下图所示：

C. 要求Soundable接口、收声机Radio、随声听Walkman和手机Mobilephone放在包

mysound中。由你自己定义的应用程序类来调用。

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