JAVA练习

第一题：

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

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

实验要求：

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

outerRadius = oRadius; //初始化外半径 return innerRadius; //返回内半径 color = c; //设置颜色

ring.setOuterRadius(6); //设置圆环ring的外半径为6

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

运行有错误发生吗？分析错误的原因

有错误发生，因为Ring ring = new Ring(5,8,\是在调用参数，构造方法的调用参数必须与在定义构造方法的参数列表中的参数一一对应（调用参数应当与相应参数的数据类型相匹配）

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

Public Ring(){

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

没有变化

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

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

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

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

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

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

运行错误。innerRadius 和outerRadius的类修饰词是private，不被外界所用。

可以将定义 public double getInnerRadius( ) public double getOuterRadius( ) 改为 public double innerRadius( ) public double outerRadius( )

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

main()函数中分别创建两个对象ring1，ring2以显示周长。 public double ring1() {return (innerRadius*2*3.1415);} public double ring2() {return (outerRadius*2*3.1415);} 在main()函数中添加： System.out.println(\圆环的内圆周长：\ System.out.println(\圆环的外圆周长：\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;

outerRadius = oRadius;//初始化外半径 color = c;} public Ring(){

innerRadius=1.0;

outerRadius=2.0; color=\

public double innerRadius( ) { return innerRadius; } public double outerRadius( ) { return outerRadius;}

public void setInnerRadius(double iRadius) { innerRadius = iRadius;}

public void setOuterRadius(double oRadius) { outerRadius = oRadius;} public void setColor(String c) { color = c; } public double ring1(){

return (innerRadius*2*3.1415);} public double ring2(){ return (outerRadius*2*3.1415);} 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(\圆环的外圆周长：\ System.out.println(\圆环的颜色: \

System.out.println(\圆环的面积: \ ring.setInnerRadius(4);

ring.setOuterRadius(6); ring.setColor(\

System.out.println(\圆环的内半径: \ System.out.println(\圆环的内圆周长：\ 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);情况又会怎样呢？ 不会。因为题目定义了一个Circle的类，里面对pi进行了赋值，且在类里面定义了函数displayNo();，在声明的新的对象cir1中，pi与函数displayNo()的值调用的是Circle类中的值，类本身也可以看做一种对象，简称为类对象。类的静态成员（静态成员域和静态成员方法）隶属于该对象，可以直接通过类名访问累的静态成员域或者调用类的静态成员方法。所以不会报错。 会报错，因为cir1.setRadius(10);是赋予声明的对象cir1新的值，并不是在类中赋予新的值。不具有静态属性的成员域和成员方法均不隶属于类本身所对应的对象，不能直接通过类名访问这些不具有静态属性的成员域和成员方法。而setRadius(int)是不具有静态属性的成员方法。

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

的原因是什么？

会报错。因为圆周率Pi的static去掉后，成员域Pi不具有静态属性，如果需要访问这些不具有静态属性的成员域和成员方法，那么一般需要通过类的实例对象来实现。

C. 程序中的数据成员objectNo为什么要设置成static类型？它的作用是什

么？

因为在输出objectNo的函数中设置的函数是静态的。静态函数才能引用上下文中的静态。

D. 注：源代码StaticTest.java 第三题：

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

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

程序结果分析： z = 5

z= 10 方法域中的X = 8在块内显示 z = 5 z= 10 方法域中的X = 8在块内显示 方法域中的X = 8在块外显示 类域中的X = 2在块外显示

类域中的m = 3在块外显示

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

会报错，因为是在show()函数for中定义的局部变量。

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

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

会报错；因为setm()函数中设置的函数是静态的。“this”用在当前类的非静态成员方法中

可以编译成功；将“static”删除就是将静态成员“setm()”改为非静态成员。此时可以用“this”。

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

了一个变量z，现将这个变量z的名字改成y，编译程序，看其运行情况

不能，因为变量y重复定义了，而z却没定义。若把int z=5改为y=5，便可以运行。 y = 5 y = 10

方法域中的X = 8在块内显示 方法域中的X = 8在块外显示 类域中的X = 2在块外显示 类域中的m = 3在块外显示

For循环给定条件是y<2，而其中又将y赋予值5，所以循环一遍就跳出for循环。接着读出以后程序。

E. 源代码：ScopeTest.java

第四题：

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

实验要求：0+0=0

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

m=a; //初始化变量m n=b; //初始化变量n return a+b+c; //返回加法运算的结果

Overload ov = new Overload(); //声明一个Overload对象ov并初始化 dx = ov.add(2.1,5.3); //调用实型加法函数，参数为2.1，5.3

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

double add(int a,int b){

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

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

会报错。重载不同的参数列表包括方法的参数不同、参数的数据类型不同或者参数的数据类型不同或者参数的数据类型排列不同，不包括返回值类型不同。

C. 源代码：Overload.java 第五题：

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

实验要求：

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

double getRate( ) { return rate; } //返回费率值 number = n; //设置电话号码 receivedTime = d; //设置被叫时间

mobile.setDialledTime(80); //设置主叫时间为80 mobile.display( ); //显示移动电话的信息 B. 在Mobilephone类的display()方法中有如下语句：

System.out.println(\话费: \

试问这时调用的是子类自己的callCost( )还是其父类的callCost( )；如果

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) {this.name = name;} public void setType(String type) { this.type = type;}

public void setCourseScore(int courseNumber, int courseScore)

{courses[courseNumber] = courseScore; //按课程索引号设置课程成绩}} class Seniordtudent extends Student { public Seniordtudent(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]; };

average = total / CourseNo;

if (average>=80&&average<100) courseGrade = \好\ else if (average>=60&&average<80) courseGrade = \中\ else courseGrade = \差\ }}*/ //F. 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]; //累加各门课程成绩 };

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]; //F时改为6 students[0] = new Undergraduate(\陈建平\ students[1] = new Undergraduate(\鲁向东\ students[2] = new Postgraduate(\匡晓华\ students[3] = new Undergraduate(\周丽娜\ students[4] = new Postgraduate(\梁欣欣\//创建姓名为梁欣欣的Postgraduate对象students[4] students[5] = new Seniordtudent(\李明封\//F. for (int i=0; i<5 ;i++) { //F.i改为6 students[i].setCourseScore(0,87); students[i].setCourseScore(1,90); students[i].setCourseScore(2,78); for (int i=0; i<5 ;i++) { //F.i改为6 students[i].calculateGrade(); //B. } //Student st = new Student(\李明\//D.

System.out.println(\姓名\ 类型\ 成绩\ System.out.println(\ for (int i=0; i<5 ;i++) { //F.i改为6 System.out.println(students[i].getName( )+\ \ students[i].getType( )+\ \ students[i].getCourseGrade( )); } /*for (int i=0; i<5 ;i++) { //F.i改为6 if (students[i] instanceof Undergraduate) System.out.println(students[i].getName( )+\是本科生\ else

}*/ }} 第七题：

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

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

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

实验要求：

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

innerObj.show(); //调用Inner对象的show()方法 return sum/data.length; //返回data数组的平均值 System.out.print(data[i]+\ //显示data数组的每个元素 outerObj.checkLocal(); //调用outerObj对象的checkLocal方法 B. 编译完成后将产生4个class文件，分别是InnerClass.class，Outer.class，

Outer$Inner.class，Outer$1Local.class，注意这些类的命名规则，然后运行InnerClassTest.class文件，观察程序输出的结果。 内部类Inner和局部类Local是定义在外部类Outer中。 C. 从程序运行结果来看，内部类Inner和局部类Local都能直接访问外部类

Outer的data[]数组，那么反过来外部类中的方法能否直接访问内部类Inner和局部类Local中的成员呢？将checkInner()方法中的innerObj.show( );改成show( );同时checkLocal()中的localObj.show( );方法改成show( );测试这个结果

答：外部类可以访问内部类和局部类的成员。 若果改变，将会报错。

原因：因为程序中创建了内部类的实例对象，他所调用的方法是在父类中与调用参数相匹配的构造方法他是通过父类型（）的变量指向子类型（即匿名内部类）的实例对象再由该变量被子类型覆盖的成员方法

D. 在内部类Inner的定义前加上static使其变成static嵌套类。

Static class Inner{}

编译会出现什么结果？ 答：会报错。因为在class Inner{}前加上Static后，将内部类变为静态类，静态实名内部类不能直接访问其外部类的非静态成员data。

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

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

答：可以正常运行。因为将外部类的data[]数组加上static，把其定义成

静态成员，静态的内部类是可以访问静态的外部类成员的。

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

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

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

答：可以编译，并且会多出现“从内部类显示数组元素:6 8 9 22 34 7 2 1 15”。创建了静态实名内部类的实例对象。调用了静态实名内部类的构造方法。

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

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

编译运行注意观察错误提示。 答：内部类不能有静态声明。 H. 源代码：InnerClassTest.java 第八题(自已动手)：

实验要求：

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

声音大小。Soundable接口的这些功能将会由三种声音设备来具体实现，它们分别是收声机Radio、随声听Walkman和手机Mobilephone。最后还要设计一个应用程序类来使用这些实现了Soundable接口声音设备类。 B. 程序运行时，先询问用户想听哪种设备，然后程序就会按照该设备的工

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

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

放在包mysound中。由你自己定义的应用程序类来调用。 第一个源文件名为Soundable.java

package mysound;

public interface Soundable {

public void increaseVolume( ); public void decreaseVolume( ); public void stopSound( );

public void playSound( );}

第二个源文件名为Radio.java package mysound;

import mysound.Soundable;

class Radio implements Soundable { public void increaseVolume( ) {

System.out.println(\增大收音机音量\ public void decreaseVolume( ) {

System.out.println(\减小收音机音量\ public void stopSound( ) {

System.out.println(\关闭收音机\

public void playSound( ) {

System.out.println(\收音机播放广播\

第三个源文件名为Walkman.java

package mysound;

import mysound.Soundable; import mysound.Radio;

class Walkman implements Soundable { public void increaseVolume( ) {

System.out.println(\增大随声听音量\ public void decreaseVolume( ) {

System.out.println(\减小随声听音量\ public void stopSound( ) {

System.out.println(\关闭随声听\ public void playSound( ) {

System.out.println(\随声听发出音乐\

第四个源文件名为Mobilephone.java

package mysound;

import mysound.Soundable; import mysound.Radio; import mysound.Walkman;

class Mobilephone implements Soundable { public void increaseVolume( ) {

System.out.println(\增大手机音量\ public void decreaseVolume( ) {

System.out.println(\减小手机音量\ public void stopSound( ) {

System.out.println(\关闭手机\ public void playSound( ) {

System.out.println(\手机发出来电铃声\

第五个源文件名为buxiaocen.java

import java.util.Scanner; import mysound.Soundable; import mysound.Radio; import mysound.Walkman; import mysound.Mobilephone; class People {

private String name; private int age;

public void listen(Soundable s) { s.playSound( ); }} public class buxiaocen {

public static void main(String[] args) { int i,n;

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]);

System.out.println(\调节声音大小? 请输入选择：0-增大音量 1-减小音量 2-关闭电源\ n = scanner.nextInt( ); while(n<2) {if (n==0)

soundDevice[i].increaseVolume( ); else

soundDevice[i].decreaseVolume( );

System.out.println(\调节声音大小? 请输入选择：0-增大音量 1-减小音量 2-关闭电源\

n = scanner.nextInt( );} soundDevice[i].stopSound( ); }}

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