目录
JAVA复习题
一、基础知识
1、JAVA中导入某一类用的关键字是（ ）
A） using B）use C）import D） include
2、JAVA语言中声明类的关键字是（ ）
A）using B）class C）namespace D）Main
3、JAVA程序中,使用关键字（ ）来创建自定义的包。
A）package B）new C）import D）try
4、在JAVA中，要导入util包中的所有类的正确语句是（ ）
A）import java.util.*; B）import java.util.*
C）using java.util.*; D）#include < java.util.*>;
5、在JAVA中，一些数据类型为引用类型，当引用类型的值为（ ）时，表明没有引用
任何对象。
A）Empty B）null C）Nothing D）0
6、JAVA语言中的标准输出流System.out中包含两个输入方法：print ()和println ()。
它们之间的唯一区别是（ ）
A）println ()方法输出后换行，print ()方法输出后不换行
B）println ()方法可以格式化输出，print ()方法不可以
C）print ()方法输出后换行，println ()方法输出后不换行
D）print ()方法可以格式化输出，println ()方法不可以
7、在JAVA程序中，使用（ ）关键字来创建数组
A）new B）array C）static D）this
8、在数组中使用for循环语句，下列那些选项中的说法不正确？（ ）。
A）for语句可以不使用索引就能遍历整个数组
B）for语句总是从索引1遍历到索引length
C）for可以遍历整个数组，也可以不遍历整个数组
D）如果需要修改数组元素就必须在for语句中使用索引
二、方法
01、声明方法时，如果有参数，则必须写在方法名后面的小括号内，并且必须指明它的
类型和名称，若有多个参数，需要用（ ）隔开。
A）逗号 B）分号 C）冒号 D）不能定义多个参数
02、在JAVA 语言中，方法重载的主要方式有两种，包括（ ）和参数类型不同的重载。
A）参数名称不同的重载 B）返回类型不同的重载
C）方法名不同的重载 D）参数个数不同的重载
03、下列关于重载的说法，错误的是（ ）。
A）方法可以通过指定不同的参数个数重载
B）方法可以通过指定不同的参数类型重载
C）方法可以通过指定不同的参数名称重载
D）方法不可以通过指定不同的返回值类型重载
04、调用重载方法时,系统根据（ ）来选择具体的方法｡
A）方法名 B）参数的个数和类型
C）参数名及参数个数 D）方法的返回值类型
05、在JAVA程序中，定义如下方法，下面选项中（ ）错误的实现对该方法的方法重载。
public String doing(int value, String s){//省略代码}
A）public int doing(int value, String s){//省略代码}
B）public String doing(String s, int value){//省略代码}
C）public void doing(String s, int value) {//省略代码}
D）public void doing(){//省略代码}
06、JAVA类中，下列函数重载是否合法？（ ）
public void showInfo(int i){…}
public bool showInfo(int i) {…}
A）合法 B）不合法
07、在JAVA同一个类中，（ ）允许相同名称、不同参数个数或者参数类型的方法存在。
A）方法重写 B）方法重载 C）方法取消 D）方法覆盖
08、关于JAVA语言中方法的签名不包括以下哪项？（ ）。
A）方法名 B）形参类型 C）形参个数 D）返回值类型
09、JAVA中调用方法时想给方法传递任意个数的int型参数时，应如何写形参（ ）。
A）int a B）int[] a C）int... a D）无法实现
10、下列参数类型中（ ）是 JAVA中不允许使用的。
A）值参数 B）引用参数 C）可变参数 D）指针参数
11、关于JAVA中的可变参数,下列说法错误的是（ ）
A）可变参数必须是函数的最后一个参数｡
B）可变参数必须是一维数组
C）可变参数的声明同普通数组一样
D）可变参数所对应的实参的个数是不固定的
12、在JAVA中，某程序在一个类中编写了两个同名的方法，该段代码的运行结果是（ ）。
public class Test{
public static void main(String[] args) {
String musicName = "还是觉得你最好";
song("分手总要在雨天");
}
static void song(){
System.out.println("忘记你我做不到");
}
static void song(String musicName){
System.out.println(musicName);
}
A）忘记你我做不到 B）还是觉得你最好 C）分手总要在雨天 D）没有输出
13、下面代码的输出结果是（ ）。
class Test{
public static void main(String[ ] args) {
int radius = 2;
double area = getArea(radius);
System.out.print(area);
}
static double getArea(int r) {
return 3.14 * r * r;
}
}
A）2 B）3.14 C）12.56 D）6.28
14、下面代码的运行结果是（ ）
class Test{
public static void main(String[ ] args) {
int num1 = 34;
int num2 = 55;
increase(num1, num2);
System.out.printf("%d和%d", num1, num2);
}
static void increase (int num1, int num2) {
num1++;
num2++;
}
}
A）35和56 B）34和55 C）34和56 D）35和55
15、下面代码输入的结果是：（ ）
public class Test{
public static void main(String[] args) {
int[] nums = {1, 2, 3, 4};
trunCate(nums);
System.out.print(nums[1]);
}
static void trunCate(int[] arr)
{
arr[1] = 99;
}
}
A）2 B）99 C）1 D）语法错误，不能运行
三、类和对象
01、面向对象三个基本特性是（ ）。
A）抽象，继承，派生 B）类，对象，方法
C）封装，继承，多态 D）对象，属性，方法
02、静态方法只能直接访问（ ）成员
A）静态 B）动态 C）实例 D）静态和实例
03、以下符合对象和类的关系的是哪一组？（ ）
A）人和老虎 B）书和汽车 C）楼房和土地 D）松树和植物
04、在JAVA语言中，下列哪项是正确的main方法说明？（ ）．
A）public main(String[] args)
B）public static void main(String[] args)
C）private static void main(String[] args)
D）void main()
05、在JAVA中new关键字的作用是（ ）
A）新建对象实例 B）定义包 C）调用类 D）引入包
06、下列的（ ）不是构造函数的特征｡
A）构造函数的函数名和类名相同
B）构造函数可以重载
C）构造函数可以带有参数
D）可以指定构造函数的返回值//构造函数为了初始化成员变量的值
public class Person {
// 成员变量
private String name;
private int age;
// 无参数的构造函数
public Person() {
// 初始化代码（如果需要的话）
this.name = "Unknown";
this.age = 0;
System.out.println("无参数的构造函数被调用");
}
// 带参数的构造函数
public Person(String name, int age) {
// 使用参数初始化成员变量
this.name = name;
this.age = age;
System.out.println("带参数的构造函数被调用，姓名：" + name + "，年龄：" + age);
}
07、以下关于JAVA中的构造函数说法正确的是（ ）。
A）构造函数可以有参数
B）构造函数有返回值
C）一般情况下，构造函数总是private类型的
D）构造函数可以通过类的实例调用
08、以下说法正确的是( )
A）构造函数名不必和类名相同
B）一个类可以声明多个构造函数
C）构造函数可以有返回值
D）编译器可以提供一个默认的带一个参数的构造函数
09、在JAVA类中，（ ）。
A）允许有多个相同名称的构造函数 B）允许有多个不相同名称的构造函数
C）至少要自定义一个构造函数 D）只能有一个构造函数
10、JAVA类中的构造函数的特点是（ ）。
A）一个类中,只能有一个构造函数 B）构造函数的名称与类名称一样
C）构造函数在对象销毁时自动执行 D）要求构造函数至少有两个参数
11、JAVA的方法分为实例方法和静态方法，实例方法可以访问（ ），静态方法只能访问静态成员。
A）静态成员 B）静态成员和非静态成员 C）非静态成员 D）动态成员
12、在JAVA中，创建类的实例需要使用的关键字是（ ）
A）this B）base C）new D）as
13、在JAVA编程中，访问修饰符控制程序对类中成员的访问，如果不写访问修饰符，类中成员的默认访问权限是（ ）。
A）public B）private C）(package) D）protected
14、在类的定义中，类的（ ）描述了该类的对象的行为特征
A）类名 B）方法 C）所属的包 D）私有域
15、在类的内部能够直接使用该类的（ ）成员名进行访问。
A）私有 B）公用 C）保护 D）任何
16、在JAVA中，（ ）访问修饰符修饰的成员可以包内访问的。
A）public B）protected C）默认的 D）private
17、在JAVA中，class关键字前面的关键字是表示访问级别，下面哪个关键字的访问级别是表示只有在同一个包内该类是可访问的? ( )。
A）public B）private C）protected//不仅一个包的其他类，不同包的子类也可以 D）默认的
18、在JAVA程序中，使用关键字（ ）来定义静态成员。
A）malloc B）class C）private D）static
19、在JAVA中，创造一个对象时，系统执行的是（ ）中的语句。
A）main方法 B）构造函数 C）初始化函数 D）字符串函数
20、分析下列程序:
class MyClass{
private String _sData = "";
public void setData(String s) { _sData = s;}
} 在 其他类的main 函数中,在成功创建该类的对象 obj 后,下列哪些语句是合法的? （ ）
A）obj.setData("It is funny"); B）System.out.print(obj.setData());
C）obj.setData(100); D）System.out.print(obj._sData);
21、JAVA中MyClass 为一自定义类，其中有以下方法定义
public void hi(int n){⋯⋯}
使用以下语句创建了该类的对象：MyClass obj = new MyClass();
那么，可如何访问类MyClass 的hi方法？( )。
A）obj.hi(); B）obj::hi(); C）MyClass.hi(); D）MyClass::hi();
22、以下程序的输出结果是（ ）。
class Test{
public static void main(String[] args){
MyStruct s1 = new MyStruct(1, 2);
s1.x = 2;
s1.Sum();
}
}
class MyStruct{
public int x;
public int y;
public MyStruct(int i, int j){
x = i;
y = j;
}
public void Sum(){
int sum = x + y;
System.out.println("the sum is " + sum );
}
}
A）the sum is 4 B）the sum is 3
C）the sum is 2 D）the sum is 0
23、class Student{
String type = ”学员”;
String name = ”李明”;
}
public class Test{
public static void main(String[] args) {
Student stu = new Student(); //代码1
System.out.println (stu.type); //代码2
System.out.println (stu.name); //代码3
}
}在JAVA中，关于以上JAVA代码的描述正确的是（ ）。
A）代码1错误 B）代码2错误 C）代码3错误 D）代码都正确
24、在下面的类定义中，无参构造函数的作用是（ ）
public class MyClass{
private MyClass() { }
public static int Counter;
public static int IncrenentCounter(){
return ++Counter;
}
}
A）在创建类的实例时初始化类的域
B）因为是private的，因此不起任何作用
C）防止创建类的实例
D）什么都不作
25、下列语句是类Myclass的一部分，obj是Myclass的一个对象。
void Change(int i) {
i++;
}
public void test(){
int a=100;
Change(a);
System.out.println(a);
}
则调用obj.test()后，控制台输出（ ）
A）0 B）100 C）101 D）1
四、继承
01、面向对象编程中的“继承”的概念是指（ ）
A）对象之间通过消息进行交互
B）派生自同一个基类的不同类的对象具有一些共同特征
C）对象的内部细节被隐藏
D）派生类对象可以不受限制地访问所有的基类对象
02、在JAVA的类结构中，class关键字前面的关键字是表示访问级别，下面哪个关键字表示该类只能被这个类的成员或派生类成员访问? ( )。
A）public B）private C）默认的 D）protected
03、类的以下特性中，可以用于方便地重用已有的代码和数据的是( ).
A）多态 B）封装 C）继承 D）抽象
04、下列关于JAVA继承说法中，哪个选项是正确的（ ）
A）派生类可以继承多个基类的方法和属性。
B）派生类必须通过super关键字调用基类的构造函数
C）继承最主要的优点是提高代码性能
D）继承是指派生类可以获取其基类特征的能力。
05、下列关于继承机制的描述中不正确的是（ ）
A）提供继承机制有利于提高软件模块的可重用性及可扩充性。
B）继承机制使面向对象的语言能够更准确的描述客观世界，使软件开发方式变简单。
C）继承机制使得软件开发过程效率更高。
D）继承机制使得软件开发的难度相对增加。
06、下列关于继承的理解，错误的是（ ）
A）子类可以从父类中继承其所有的成员。
B）无论是否声明，子类都继承自Object类。
C）假如，类M继承自类N，而类N又继承自类P，则类M也继承自类P。
D）子类应是对基类的扩展。子类可以添加新的成员，但不能除去已继承成员的定义。
07、以下关于继承的说法错误的是（ ）。
A）Object类是所有类的基类
B）派生类不能直接访问基类的私有成员
C）protected修饰符既有公有成员的特点，又有私有成员的特点
D）基类对象引用不能引用派生类对象
08、继承具有（ ），即当基类本身也是某一类的派生类时，派生类会自动继承
间接基类的成员。
A）规律性 B）传递性 C）重复性 D）多样性
09、在JAVA语言中，以下关于继承的说法错误的是（ ）。
A）一个子类不能同时继承多个父类
B）任何类都是可以被继承的
C）子类继承父类，也可以说父类派生了一个子类
D）Object类是所有类的父类
10、在JAVA中，如果类C继承自类B，类B继承自类A，则以下描述正确的是（ ）。
A）C不仅继承了B中的成员，同样也继承了A中的成员
B）C只继承了B中的成员
C）C只继承了A中的成员
D）C 不能继承了A或B中的成员
11、在JAVA中，定义派生类时，指定其基类应使用的语句是( )。
A）Inherits B） extends C）Class D）Overrides
12、在JAVA程序中，如果类B要继承类A，类B正确的定义为（ ）。
A）public class B inherit A B）public class B extends A
C）public class B :: A D）public class B from A
13、关于super关键字，下列使用方法错误的是：（ ）
A）在子类中，super可以调用父类的构造函数
B）在子类中，super关键字可以访问父类的公共属性
C）在子类中，super关键字不可以调用父类的protected成员
D）在子类中，super关键字不可以调用父类的private成员
14、派生类访问基类的成员，可使用（ ）关键字
A）super B）this C）out D）external
15、JAVA程序中的类MyClass中的成员变量var1如下：
public class MyClass{
private int var1;
} 则可以访问var1的有（ ）。
A）在MyClass类中 B）在MyClass的派生类中
16、下列关于覆盖和重载的描述，正确的是（ ）
A）覆盖只发生在父类和子类之间，而重载可以发生在同一个类中
B）覆盖方法可以不同名，而重载方法必须同名
C）final修饰的方法可以被覆盖，但不能被重载
D）覆盖和重载是一回事儿
17、JAVA代码如下，代码的输出结果是（ ）。
class Test{
public static void main(String[] args) {
Student s = new Student();
s.sayHi();
}
}
class Person{
public void sayHi() {
System.out.println("你好，我是一个人");
}
}
class Student extends Person{
public void sayHi() {
System.out.println("你好，我是一名学生");
}
}
A）学生 B）你好，我是一名学生
C）你好，我是一个人 D）空
18、如果不希望类的某个方法在派生类中进一步改进，则该将方法声明成（ ）
A）abstract B）public C）final D）override
19、以下关于最终类的说法，正确的是（ ）
A）最终类可以用作基类 B）最终类可以是抽象类
C）最终类永远不会有任何派生类 D）最终类或最终方法可以重写或继承
20、当开发者不希望自己编写的类被继承，或者有的类已经没有再被继承的必要时，
我们通常对class使用哪一个关键字？( )
A）final B）virtual C）abstract D）override
21、在JAVA中利用final修饰的类（ ）。
A）最终类，不能继承 B）最终类，可以继承 C）表示基类 D）表示派生类
五、抽象类和接口
01、下列关于多态的说法中，哪个选项是正确的（ ）
A）重写方法时可以为方法指定别称
B）抽象类中不可以包含非抽象方法
C）抽象方法是实现多态的唯一手段
D）多态性是指以相似的手段来处理各不相同的派生类
02、在派生类是非抽象类的情况下，以下说法正确的是（ ）。
A）非抽象方法必须在派生类中重写，抽象方法不需要重写
B）非抽象方法可以在派生类中重写，抽象方法必须重写
C）非抽象方法必须在派生类中重写，抽象方法也必须重写
D）非抽象方法可以在派生类中重写，抽象方法不需要重写
03、在JAVA中，使用（ ）访问修饰符修饰的方法被称之为抽象方法。
A）this B）abstract C）new D）virtual
04、下面关于抽象类的说法正确的是 （ ）
A）抽象类可以被实例化 B）含有抽象方法的类一定是抽象类
C）抽象类可以是静态类和最终类 D）抽象类中的抽象方法可以在其它类中重写
05、下面关于抽象类的说法正确的是？（ ）
A）抽象类只能做子类 B）抽象类可以被实例化
C）抽象类不能被实例化 D）一个抽象类只能有一个子类
06、下列关于抽象类的说法错误的是（ ）。
A）抽象类可以实例化 B）抽象类可以包含抽象方法
C）抽象类可以包含非抽象方法 D）抽象类可以引用派生类的实例
07、在JAVA的语言特性中，关于抽象类，以下描述正确的是（ ）。
A）在抽象类包含全部已经实现的方法的时候，抽象类可以实例化
B）子类可以同时实现多个抽象类
C）使用void关键字标注一个抽象类
D）抽象类可以包含己经实现的方法
08、下列类的定义中哪个是合法的抽象类？（ ）
A）final abstract class C1{ public abstract void test(); }
B）public abstract void test();
C）abstract class C1 { static abstract void test(); }
D）abstract class C1 { public abstract void test(); }
09、 public abstract class Animal{
public abstract void eat();
public void Sleep(){ // … }
}以下关于JAVA代码地描述正确的是（ ）。
A）该段代码正确
B）代码错误，因为类中存在非抽象方法
C）代码错误，因为类中方法没有实现
D）通过代码Animal an = new Animal();可以创建一个Animal对象
10、下列关于JAVA面向对象应用的描述中，哪项是正确的？（ ）。
A）派生类是基类的扩展，派生类可以添加新的成员，也可去掉已经继承的成员
B）abstract方法的声明必须同时实现
C）声明为final的类不能被继承
D）接口像类一样，可以定义并实现方法
11、下列说法中，正确的是（ ）。
A）派生类对象可以强制转换为基类对象
B）在任何情况下，基类对象都不能转换为派生类对象
C）接口不可以实例化，也不可以引用实现该接口的类的对象
D）基类对象可以访问派生类的成员
12、在JAVA中，关于接口下面说法错误的是（ ）
A）接口是一组规范和标准
B）接口可以约束类的行为
C）接口中的方法只能是未实现的方法
D）接口中的方法可以指定具体实现，也可以不指定具体实现
13、以下说法不正确的是（ ）
A）一个类可以实现多个接口
B）一个派生类可以继承多个基类
C）在JAVA中实现多态，派生类中重写基类的方法须保持方法签名不变
D）子类能添加新方法
14、在JAVA中，一个类（ ）
A）可以继承多个类 B）可以实现多个接口
C）在一个程序中只能有一个子类 D）只能实现一个接口
15、下列关于接口的说法，哪项是正确的（ ）
A）接口可以被类继承，本身也可以继承其他接口。
B）定义一个接口，接口名必须使用大写字母I开头
C）接口像类一样，可以定义并实现方法
D）类可以继承多个接口，接口只能继承一个接口
16、在JAVA中定义接口时，使用的关键字是（ ）
A）interface B） : C）class D）overrides
17、以下关于接口的说法，不正确的是（ ）
A）接口不能实例化
B）接口中声明的所有函数成员隐式地为public和abstract
C）接口默认的访问修饰符是private
D）继承接口的任何非抽象类型都必须实现接口的所有成员。
六、异常处理
01、下列关于异常的描述正确的是（ ）
A）在JAVA中一个try块只能有一个catch块
B）一个try块可能产生多个异常
C）可以使用throws回避方法中的异常
D）finally块是异常处理所必需的
02、程序运行可能会出现两种错误：可预料的错误和不可预料的错误，对于不可预料的
错误，可以通过JAVA语言提供的哪个方法来处理这种情形（ ）
A）中断调试 B）逻辑判断 C）跳过异常 D）异常处理
03、JAVA程序中，可使用try···catch 机制来处理程序出现的（ ）错误
A）语法 B）运行 C）逻辑 D）拼写
04、在JAVA语言中，下列异常处理结构中有错误的是（ ）
A）catch{ }finally{ } B）try{ }finally{ }
C）try{ }catch{}finally{ } D）try{ }catch{ }
05、使用（ ）关键字可以引发异常？
A）new B）this C）throw D）Exception
06、异常捕获发生在（ ）块中？
A）try B）catch C）finally D）throw
07、一般情况下，异常类存放在什么包中？（ ）
A）生成异常类所在的包 B）java.Exception包
C）java.Diagnostics包 D）java.lang包
08、程序运行过程中发生的错误，叫作（ ）
A）版本 B）断点 C）异常 D）属性
09、在JAVA 中，程序使用（ ）语句抛出系统异常。
A）run B）throw C）catch D）finally
10、为了能够在程序中捕获所有的异常,在 catch语句的括号中使用的类名为（ ）
A）Exception B）ArithmeticException
C）NullPointerException D）以上三个均可
11、下面对异常说法不正确的是（ ）
A）try/catch块为基本引发异常的组合 B）在捕获异常时,可以有多个 catch块
C）无论异常是否发生,finally块总会执行 D）try块和 finally 不能连用
12、通过继承（ ）类，用户可以创建自己的异常类。
A）Exception B）SystemException
C）ApplicationException D）UserException
14、下列关于异常处理的表述中哪些是正确的（ ）？
A）try、catch、finally三个字句必须同时出现，才能正确处理异常
B）catch字句能且只能出现一次
C）try字句中所抛出的异常一定能被catch字句捕获
D）无论异常是否抛出，finally子句中的内容都会被执行。
七、程序编写
1、编程：要求写一个学生类，该类的描述如下：
类的名字：Student，该类具有二个私有成员变量：姓名:字符串类型 name,年龄:整型age;
该类有两个构造方法：一个初始化名字，一个初始化年龄;
该类对name成员有一组set和get方法：分别给姓名(name)赋值和获取姓名(name)值;
该类具有两个方法：run()方法、jump()方法，要求在这两个方法中打印出自己的状态:
run()方法中打印：“I’m running” jump()方法中打印：“I’m jumping”。
class Student{
private String name;
private int age;
public Student(String name){
this.name = name; }
public Student(int age){
this.age = age; }
public void setName(String value){
name = value ; }
public String getName( ){
return name; }
public void run(){
System.out.println("I\’m running"); }
public void jump(){
System.out.println("I\’m jumping");}
}
public class Test{
public static void main(String[] args){
Student student = new Student(18);
Student.setName("张三");
student.run();
student.jump();
}
}
2、判断回文数的方法定义
boolean isHuiwen(int m) {
int t = m, n = 0;
while(t != 0){
n = n * 10 + t % 10;
t /= 10;
}
if(n == m)
return true;
else
return false;
}
3、编程
interface IPerimeter{ // 接口
double getPerimeter(); } // 求周长
abstract class Shape2D{ // 二维图形抽象类
public abstract double getArea(); } // 求图形面积
class Rectangle extends Shape2D implements IPerimeter {
// 长方形继承二维图形,实现接口
private double length; // 长
private double width; // 宽
public Rectangle(double length, double width){ // 构造方法
this.length = length;
this.width = width;
}
public double getArea(){ // 重写，求长方形面积方法
return length * width ;
}
public double getPerimeter(){ // 实现，求长方形周长方法
return 2 * (length + width);
}
}
class Circle extends Shape2D implements IPerimeter{ // 圆
public final double Pi = 3.14159; // 定义常量字段 Pi
private double radius; // 半径
public Circle(double r) { // 构造函数
radius = r;
}
public double getArea(){ // 重写，求圆面积方法
return Pi * radius * radius ;
}
public double getPerimeter(){ // 实现，求圆周长方法
return 2 * Pi * radius ;
}
}
4、将整数中的偶数数字逆序生成一个新数字的方法定义。
int getOushuPreOrder(int n) {
int m = 0;
while(n != 0) {
if(n % 10 % 2 == 0)
m = m * 10 + n % 10;
n /= 10;
}
return m;
}
5、class Point {
private double x;
private double y;
public Point(double x, double y) {
this.x = x;
this.y = y;
}
public double getX() {
return x;
}
public void setX(double x) {
this.x = x;
}
public double getY() {
return y;
}
public void setY(int y) {
this.y = y;
}
@Override
public String toString() {
return "Point: (" + x + ", " + y + ")";
}
}
6、class Circle {
private Point center;
private double radius;
public Circle(Point p, double radius) {
center = new Point(p.getX(), p.getY());
this.radius = radius;
}
public Circle() {
this(new Point(0,0), 1);
}
public Circle(Point p) {
this(p,1);
}
public Circle(double radius) {
this(new Point(0,0), radius);
}
public Point getP() {
return center;
}
public void setP(Point p) {
center = new Point(p.getX(), p.getY());
}
public double getRadius() {
return radius;
}
public void setRadius(double radius) {
this.radius = radius;
}
@Override
public String toString() {
return "Circle: center " + center.toString() + ", radius=" + radius;
}
}
八、程序阅读题
（01）以下程序的输出结果是 （ a=7,b=8）。
class B{
private int a, b;
public B(int i, int j) { a = i; b = j; }
public void printB() {
System.out.println( "a=" + a + ",b=" + b ); } }
class A{
private B c;
public A(int i, int j) { c = new B(i, j); }
public void printA() { c.printB(); } }
public class AAA{
public static void main(String[] args){
A ob = new A(7, 8); ob.printA(); } }
（02）以下程序的输出结果是（ B.F B.F ）。
class A{
public void f() { System.out.print("A.F "); } }
class B extends A{
public void f() { System.out.print("B.F "); } }
public class Test{
public static void main(String[] args){
B b = new B(); A a = b;
b.f(); a.f(); } }
（03）以下程序的输出结果是（ 11113333 ）。
class CatchIT {
public static void main(String[] args) {
try { int nTheZero = 0; int nResult = 10 / nTheZero;
} catch (ArithmeticException divEx) {
System.out.print("1111");
} catch (Exception Ex) {
System.out.print("2222");
} finally {
System.out.print("3333");
}
} }
（04）以下程序的输出结果是（ -1 1 -2 3 2 1 ）
class A {
private int x = 0, y = 0;
public A() { this(-1, 1) ; }
public A(int x, int y) {
this.x = x; this.y = y; }
public void show() {
System.out.printf("%d %d", x, y); } }
class B extends A {
private int z;
public B() { z = -2; }
public B(int x, int y, int z) {
super(x, y); this.z = z; }
public void show() {
super.show();
System.out.printf(" %d ", z); } }
class C {
public static void main(String[] args) {
B b1 = new B(), b2 = new B(3, 2, 1);
b1.show(); b2.show(); } }
（05）以下程序的输出结果是（ x = 0 y = 0 x = 2 y = -1 ）。
class A {
public A(){ printFields(); }
public void printFields(){
System.out.printf("x = %d y = %d ", 0, 0); } }
class B extends A {
int x = 1, y;
public B() { x = 2; y = -1; printFields(); }
public void printFields(){
System.out.printf("x = %d y = %d ", x, y); } }
class C {
public static void main(String[] args){
B b = new B(); } }
（06）以下程序的输出结果是（ 1 2 2 1 ）。
abstract class Graph {
public abstract int getSides(); }
class Circular extends Graph {
public int getSides() {
return 1; } }
class Square extends Graph {
public int getSides(){
return 2; } }
public class Test {
public static void main(String[] args){
Graph[] array = new Graph[] { new Circular(), new Square(),
new Square(), new Circular() };
for(Graph g : array){
System.out.print(g.getSides() + " "); } } }
九、更多干货
📚 大学生专属福利 —— 期末复习题库、结课作业解决方案，以及毕业设计的专业辅导，一站式服务，让您的学习之路更加顺畅。
💼 个性化定制服务 —— 根据您的特定需求，我们提供定制化的源码和报告，确保您的项目独树一帜。
👨🏫 专业团队支持 —— 我们的专家团队随时待命，为您解答疑惑，提供技术支持。
📢 关注我们 —— 获取最新技术动态，优质文章，以及更多独家资源。
以上内容技术相关问题💌欢迎一起交流学习👇🏻👇🏻👇🏻🔥
serendpityhui
————————————————
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
扫一扫
2808
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
