Java2020年PTA期末测试题（判断、选择、填空、程序填空）试题+答案+解析完整版
速览目录：
- 判断题：
- 1——5题
- 6——10题
- 11——13题
- 单选题：
- 1——10
- 11——20
- 21——30
- 31——40
- 41——50
- 51——60
- 61——70
- 71——80
- 81——90
- 91——100
- 101——107
- 填空题：
- 1——6
- 程序填空题：
- 1——1
判断题：
1——5题
1-1
Java系统的标准输入对象是System.in，标准输出对象有两个，分别是System.out和System.err。 (1分)
T
1-2
InputStream类和OutputStream类是所有二进制I/O的根类。 (1分)
T
1-3
Calendar类用于完成日期和时间字段的操作，它可以通过特定的方法设置和读取日期的特定部分，比如年、月、日、时、分和秒等。(1分)
T
1-4
Math.round(double d)方法的作用是，将一个数四舍五入,并返回一个double数。(1分)
F
说明：
round是四舍五入，注意负数5是舍的，例如：Math.round(1.5)值是2，Math.round(-1.5)值是-1；
floor就是直接去掉小数保留整数，即如果参数是正数则小数部分全舍，参数是负数则小数部分全入。 例如：Math.floor(2.6)的值是2，Math.floor(-2.1)的值是-3
1-5
StringBuffer类似一个字符容器，当在其中添加或删除字符时，并不会产生新的StringBuffer对象。(1分)
T
6——10题
1-6
JAVA中拆箱是指将引用数据类型的对象转为基本数据类型。(1分)
T
1-7
java语言中不用区分字母的大写小写。(1分)
F
1-8
数组也是对象。(1分)
T
1-9
Java语言中，变量名可以用汉字表示。(1分)
T
1-10
一个数组可以存放不同类型的数值。(1分)
F
11——13题
1-11
程序运行中可以改变数组的大小。(1分)
F
1-12
Java允许创建不规则数组，即Java多维数组中各行的列数可以不同。(1分)
T
1-13
Java的各种数据类型占用固定长度，与具体的软硬件平台环境无关。(1分)
T
单选题：
1——10
2-1
如果你被要求写一段代码读取一个文本文件，那么一般使用哪种Stream？(1分)
A.DataInputStream
B.ObjectInputStream
C.FileReader
D.FileInputStream
D
2-2
如果需要从文件中读取数据，则可以在程序中创建哪一个类的对象（）。(1分)
A.FileInputStream
B.FileOutputStream
C.DataOutputStream
D.FileWriter
A
2-3
在Java中，以下代码( )正确地创建了一个InputStreamReader对象。(2分)
A.InuptStreamReader(new FileReader(“1.dat”));
B.InuptStreamReader(new FileInputStream(“1.dat”));
C.InuptStreamReader(new BufferReader(“1.dat”));
D.InuptStreamReader (“1.dat”);
B
2-4
下面哪个流类属于面向字符的输入流( ) 。(1分)
A.BufferedWriter
B.FileInputStream
C.ObjectInputStream
D.InputStreamReader
D
2-5
要创建一个新目录，可以用下面( )类实现。(1分)
A.FileInputStream
B.FileOutputStream
C.RandomAccessFile
D.File
D
2-6
在Java中，( )类提供定位本地文件系统，对文件或目录及其属性进行基本操作。。(1分)
A.FileInputStream
B.FileReader
C.File
D.FileWriter
C
2-7
list是一个ArrayList的对象，哪个选项的代码填写到//todo delete处，
可以在Iterator遍历的过程中正确并安全的删除一个list中保存的对象？( )
Iterator it = list.iterator();
int index = 0;
while (it.hasNext()){
Object obj = it.next();
if (needDelete(obj)) { //needDelete返回boolean，决定是否要删除
//todo delete
}
index ++;
}
(1分)
A.list.remove(obj);
B.list.remove(index);
C.list.remove(it.next());
D.it.remove();
D
2-8
Java的集合框架中重要的接口java.util.Collection定义了许多方法。
选项中哪个方法不是Collection接口所定义的？( )(1分)
A.int size()
B.boolean containsAll(Collection c)
C.compareTo(Object obj)
D.boolean remove(Object obj)
C
2-9
下面哪个Map是排序的？(1分)
A.TreeMap
B.HashMap
C.Hashtable
D.WeakHashMap
E.LinkedHashMap
A
2-10
在Java中，关于HashMap类的描述，以下选项错误的是(1分)
A.HashMap使用键/值得形式保存数据
B.HashMap 能够保证其中元素的顺序
C.HashMap允许将null用作键
D.HashMap允许将null用作值
B
11——20
2-11
以下代码段将创建几个对象?
String s1="bc";
String s2="bc";
(1分)
A.2
B.3
C.0
D.1
D
2-12
如下程序输出（ ）
public class Test {
public static void main(String[] args) {
String s = "Java";
StringBuilder buffer = new StringBuilder(s);
change(s);
System.out.println(s);
}
private static void change(String s) {
s = s + " and HTML";
}
}(1分)
A.Java
B.Java and HTML
C.and HTML
D.什么都不显示
A
说明：
1：代码中有没有StringBuilder buffer = new StringBuilder(s);这条语句，输出结果都一样
2：字符串当作参数传入一个方法中，只在该方法中进行改变，若要在main方法中发生改变，这需要方法有返回值
2-13
以下代码输出（ ）。
public static void main(String[] args) {
String[] tokens = "Welcome to Java".split("o");
for (int i = 0; i < tokens.length; i++) {
System.out.print(tokens[i] + " ");
}
}(1分)
A.Welcome to Java
B.Welc me to Java
C.Welc me t Java
D.Welcome t Java
C
2-14
以下有关Calendar类相关描述，错误的是（）(1分)
A.
Calendar类是一个抽象类，不可以被实例化
B.
添加和修改时间的功能就可以通过Calendar类中的add()和set()方法来实现
C.
在使用Calendar.MONTH字段时，月份的起始值是从从1开始
D.
Calendar.Date表示的是天数，当天数累加到当月的最大值时，如果继续再累加一次，就会从1开始计数，同时月份值会加1
C
2-15
下列选项中，对Math.random()方法描述正确的是( )(1分)
A.
返回一个不确定的整数
B.
返回0或是1
C.
返回一个随机的double类型数，该数大于等于0.0小于1.0
D.
返回一个随机的int类型数，该数大于等于0.0小于1.0
C
2-16
若double val = Math.ceil(-11.9);，则val的值是（ ）(1分)
A.
11.9
B.
-11.0
C.
-11.5
D.
-12.0
B
说明：
math.ceil(x)返回大于等于参数x的最小整数,即对浮点数向上取整.
math.floor(x)返回小于参数x的最大整数,即对浮点数向下取整
2-17
StringBuffer类的append()方法的返回值类型是（）(1分)
A.
String
B.
void
C.
StringBuilder
D.
StringBuffer
D
2-18
阅读下面一段代码，代码的输出结果是（）
Integer in1 = new Integer(10);
Integer in2 = new Integer(10);
Integer in3 = 10;
Integer in4 = 10;
System.out.print(in1 == in2);
System.out.print(in1 == in3);
System.out.print(in3 == in4);(1分)
A.
falsefalsetrue
B.
truetruetrue
C.
falsefalsefalse
D.
falsetruefalse
A
2-19
下列选项中，关于包装类描述错误的是（）(1分)
A.
包装类的作用之一就是将基本类型包装成引用类型
B.
包装类它可以完成在基本类型与String类型之间的转换
C.
包装类一共有八个，对应的基本数据类型
D.
我们可以继承包装类，以完成自定义包装
D
2-20
阅读下面的代码，输出结果是（）
public static void main(String[] args) {
Random random1 = new Random(10);
Random random2 = new Random(10);
for(int i=0;i<5;i++){
System.out.print(random1.nextInt(5));
}
for(int i=0;i<5;i++){
System.out.print(random2.nextInt(5));
}
}(1分)
A.3030130301
B.5048132680
C.3268023579
D.1111111111
A
说明：
对于种子相同的Random对象，生成的随机数序列是一样的
21——30
2-21
下列语句执行后，变量a，c的值分别是（ ）。(1分)
A.1，2
B.2，1
C.1.62，2
D.100，62
B，此题出错，默认选B
2-22
下列不可作为java语言标识符的是（）。(1分)
A.a2
B.$2
C._2
D.22
D
2-23
有一段java 应用程序，它的主类名是a1，那么保存它的源文件名可以是（ ）.(1分)
A.a1.java
B.a1.class
C.a1
D.都对
D
2-24
以下程序段的输出结果是
class Test {
public static void main(String[] args) {
System.out.println(4 + 5 + "" + 3 + 6);
}
}(1分)
A.99
B.4536
C.936
D.459
C
2-25
设有变量定义: short a = 300; 则以下哪一条语句会导致编译错误？(2分)
A.a += 3;
B.a = (short)a + 3;
C.a = (byte)(a + 3);
D.a = (short)(a * 100);
B
说明：
因为(short)a得到的是一个short类型，而3是int类型，所以会报错
2-26
以下二维数组的定义正确的是（ ）(1分)
A.int a[3][2]={{1,2},{1,3},{2,3}}
B.int a[][]=new int[3][]
C.int[][] a=new int[][3]
D.int[][] a=new int[][]
A
2-27
在JAVA中，给定代码片段如下所示，则编译运行后，输出结果是（）。
for (int i = 0; i < 10; i++) {
if (i == 10 - i) {
break;
}
if (i % 3 != 0) {
continue;
}
System.out.print(i + " ");
}(1分)
A.0
B.0 3
C.0 3 6
D.0 3 6 9
B
2-28
下面的方法，当输入为2的时候返回值是多少?（ ）
public int getValue(int i) {
int result = 0;
switch (i) {
case 1:
result = result + i;
case 2:
result = result + i * 2;
case 3:
result = result + i * 3;
}
return result;
}(1分)
A.0
B.2
C.4
D.10
D
2-29
下面代码运行结果显示（ ）。
double temperature = 50;
if (temperature >= 100)
System.out.println("too hot");
else if (temperature <= 40)
System.out.println("too cold");
else
System.out.println("just right");(1分)
A.too hot
B.too cold
C.just right
D.too hot too cold just right
C
2-30
下列语句序列执行后，k 的值是( )
int x=6, y=10, k=5;
switch( x%y ){
case 0: k=x*y;
case 6: k=x/y;
case 12: k=x-y;
default: k=x*y-x;
}(1分)
A.60
B.5
C.0
D.54
D
说明：
没有遇到break就往下执行，直到执行完default
31——40
2-31
以下选项中没有语法错误的是（ ） 。(1分)
A.
while (int i<7) {
i++;
System.out.println(“i is “+i);
}
B.
int j=3;
while(j) {
System.out.println(“ j is “+j);
}
C.
int j=0;
for(int k=0; j + k !=10; j++,k++) {
System.out.println(“ j is “+ j + “k is”+ k);
}
D.
int j=0;
do{
System.out.println( “j is “+j++);
if (j == 3) {
continue loop;
}
}while (j<10);
C
2-32
你怎样强制对一个对象立即进行垃圾收集？(1分)
A.调用 System.gc()
B.调用System.gc(), 同时传递要进行垃圾收集对象的引用
C.调用 Runtime.gc()
D.给这个对象的所有引用设置一个新的值（例如null）
E.垃圾收集是不能被强迫立即执行
E
2-33
下面关于Java的引用的说法正确的是__。(2分)
A.引用实际上就是指针
B.引用本身是原始类型（primitive type）
C.引用就是对象本身
D.一个对象只能被一个引用所指示
A
2-34
关于以下程序代码的说明正确的是（ ） 。
1．class HasStatic{
2． private static int x=100；
3． public static void main(String[ ] args){
4． HasStatic hs1=new HasStatic( );
5． hs1.x++;
6． HasStatic hs2=new HasStatic( );
7． hs2.x++;
8． hs1=new HasStatic( );
9． hs1.x++;
10． HasStatic.x--;
11． System.out.println(“x=”+x);
12． }
13． }(1分)
A.5行不能通过编译，因为引用了私有静态变量
B.10行不能通过编译，因为x是私有静态变量
C.程序通过编译，输出结果为：x=103
D.程序通过编译，输出结果为：x=102
D
2-35
以下关于构造函数的描述错误的是（ ）。(1分)
A.构造函数的返回类型只能是void型。
B.构造函数是类的一种特殊函数，它的方法名必须与类名相同。
C.构造函数的主要作用是完成对类的对象的初始化工作。
D.一般在创建新对象时，系统会自动调用构造函数。
A
说明：
构造函数没有返回值
2-36
下列哪些语句关于Java内存回收的说明是正确的? （ ）(1分)
A.程序员必须创建一个线程来释放内存
B.内存回收程序负责释放无用内存
C.内存回收程序允许程序员直接释放内存
D.内存回收程序可以在指定的时间释放内存对象
B
2-37
若需要定义一个类属性或类方法，应使用哪种修饰符？（ ）(1分)
A.static
B.package
C.private
D.public
A
2-38
有以下程序片段，下列哪个选项不能插入到行1。（ ）
1)
2) public class Interesting{
3) //do sth
4) }(1分)
A.import java.awt.*;
B.package mypackage;
C.class OtherClass{ }
D.public class MyClass{ }
D
2-39
下面哪个函数是public void aMethod(){...}的重载函数？（ ）(1分)
A.void aMethod( ){...}
B.public int aMethod(){...}
C.public void aMethod ( ){...}
D.public int aMethod ( int m){...}
D
2-40
假设类A有如下定义，且a是A类的一个实例，则必定错误的选项是（ ）。
class A {
int i;
static String s;
void method1() { }
static void method2() { }
}(1分)
A.System.out.println(a.i)；
B.a.method1();
C.A.method1();
D.A.method2() ;
C
思考：
类中的实例方法可以用类名直接调用吗？
答：
不可以，实例方法，需要先创建实例，然后才可以调用实例的方法。 在类中可以使用static修饰符修饰类的方法，这样的方法可以不用new类，就可以直接使用类的方法。
41——50
2-41
编译并运行以下程序，以下描述哪个选项是正确的（ ）
1. class A{
2. protected boolean equals(){
3. return super.equals();
4. }
5. }(1分)
A.编译通过运行无异常
B.编译通过但运行时出错
C.行2出错，不能成功编译
D.不能成功编译，行3出错
D
2-42
下列哪个类的声明是正确的？（ ）(1分)
A.abstract final class HI{}
B.abstract private move(){}
C.protected private number;
D.public abstract class Car{}
D
2-43
关于被私有访问控制符private修饰的成员变量，以下说法正确的是（ ）(1分)
A.可以被三种类所引用：该类自身、与它在同一个包中的其他类、在其他包中的该类的子类
B.可以被两种类访问和引用：该类本身、该类的所有子类
C.只能被该类自身所访问和修改
D.只能被同一个包中的类访问
C
2-44
下列方法头中哪一个不与其他方法形成重载(overload)关系?（ ）(1分)
A.void mmm()
B.void mmm(int i)
C.void mmm(String s)
D.int mm()
D
2-45
在Java中用什么关键字修饰的方法可以直接通过类名来调用？（ ）(1分)
A.static
B.final
C.private
D.void
A
2-46
若在某一个类定义中定义有如下的方法：abstract void performDial( );该方法属于（ ）。(1分)
A.接口方法
B.最终方法
C.抽象方法
D.空方法
C
2-47
在Java中，"456"属于（ ）类的对象。(1分)
A.int
B.String
C.Integer
D.Number
B
2-48
声明成员变量时,如果不使用任何访问控制符(public, protected, private)，
则以下哪种类型的类不能对该成员进行直接访问 （ ） .(1分)
A.同一类
B.同一包中的子类
C.同一包中的非子类
D.不同包中的子类
D
2-49
选项中哪一行代码可以替换题目中//add code here而不产生编译错误？（ ）
public abstract class MyClass {
public int constInt = 5;
//add code here
public void method() { }
}(1分)
A.public abstract void method(int a);
B.value = value + 5;
C.public int method();
D.public abstract void anotherMethod() {}
A
说明：
D错误，因为抽象方法不能有方法体
2-50
下面哪个选项中的代码没有定义内部类,或者错误的定义了内部类？ ( )(2分)
A.
public Class Line {
int length;
Class Point {
//内部类代码
}
}
B.
public Class Line {
public Point getPoint() {
return new Point(){
//内部类代码
};
}
}
C.
public Class Line {
//外部类代码
}
Class Point {
//内部类代码
}
D.
public Class Line {
public int calcLength() {
Class Point {
//内部类代码
}
}
}
C
51——60
2-51
下列哪一种叙述是正确的（） 。(1分)
A.abstract修饰符可修饰属性、方法和类
B.抽象方法的body部分必须用一对大括号{ }包住
C.声明抽象方法，大括号可有可无
D.声明抽象方法不可写出大括号
D
2-52
类的实例方法表示的是什么？（ ）(1分)
A.父类对象的行为
B.类的属性
C.类对象的行为
D.类的行为
C
2-53
下面关于缺省构造方法的描述中正确的是（ ）。(1分)
A.当类中没有定义任何构造方法时，Java编译器将为这个类创建缺省构造方法
B.缺省构造方法可以初始化其他方法中定义的变量
C.Java编译器会为所有的类创建缺省构造方法。
D.如果在一个类中定义的构造方法都声明了参数，Java编译器将为这个类创建一个缺省构造方法
A
2-54
对于类与对象的关系，以下说法错误的是（ ）。(1分)
A.类是对象的类型
B.对象由类来创建
C.类是同类对象的抽象
D.对象是创建类的模板
D
2-55
下述哪条关于构造方法的说法，不符合Java语法的规定（ ）。(1分)
A.每个类至少有一个构造方法
B.构造方法必须与类同名
C.构造方法无返回值，其返回值类型必须写为void
D.构造方法可以是private的
C
说明：
Java中如果将一个方法声明为私有的，即通过private关键字来修饰，此时也就意味着该方法只能由这个类本身来调用。构造方法，类似于常规的方法，同样可以被public、protected、private这三个关键词修饰，但是构造方法不能有返回值。我们人为地将构造方法声明为private，这样其他的类就不能直接调用该类生成新的对象，也就避免了同一个类被反复创建的情况，这种情况，该类只有一个对象实例。
2-56
关于类中成员变量的作用范围，下述说法中正确的是（ ）。(1分)
A.只有用public修饰的变量才能在所有方法中使用
B.用private修饰的成员变量可以在main方法中直接使用
C.类中所有成员变量在所有成员方法中有效
D.用static修饰的成员变量只能在用static修饰的方法中使用
C
2-57
方法体内定义的变量称局部变量，下述关于局部变量的说法中错误的是（ ）。(1分)
A.局部变量仅在所定义的代码块内（花括号对内）有效
B.局部变量不能加修饰词修饰
C.局部变量不能与类中的成员变量同名
D.局部变量未经赋值不能使用
C
2-58
为AB类的一个无形式参数无返回值的方法method书写方法头，使得使用类名AB作为前缀就可以调用它，该方法头的形式为（ ）。(2分)
A.static void method( )
B.public void method( )
C.final void method( )
D.abstract void method( )
A
2-59
以下代码的输出结果为（ ）。
public class Pass{
static int j = 20;
public void amethod(int x){
x = x*2;
j = j*2;
}
public static void main(String args[]){
int i = 10;
Pass p = new Pass();
amethod(i);
System.out.println(i+" and "+j);
}
}(1分)
A.错误:方法参数与变量不匹配
B.20 and 40
C.10 and 40
D.10 and 20
C
2-60※
以下关于Java的局部内部类的说法错误的是（ ）(2分)
A.局部内部类只能在当前类中使用
B.局部内部类不能包含静态成员
C.局部内部类可以访问外部类的所有成员
D.在局部内部类中定义的内部类不能被private修饰符修饰
A
61——70
2-61
编译和运行下列程序会出现什么样的结果（ ）。(2分)
public class Ref {
public static void main(String[] args){
Ref r = new Ref();
amethod(r);
}
public void amethod(Ref r){
int i = 99;
multi(r);
System.out.println(i);
}
public void multi(Ref r){
i = r.i * 2;
}
}
A.编译出错
B.输出：99
C.输出：198
D.运行出错
A
说明：
有两处编译错误：
1、不能对类型Ref中的非静态方法amethod(Ref)进行静态引用
2、multi方法对 i 不能识别
2-62
以下程序段输出结果的是（ ）
public class Test {
public static void main(String args[]){
String str="ABCDE";
str.substring(3);
str.concat("XYZ");
System.out.print(str);
}
}(1分)
A.DE
B.DEXYZ
C.ABCDE
D.CDEXYZ
C
说明：
上面对字符串的操作对原字符串没发生改变
2-63
要产生[20，999]之间的随机整数使用哪个表达式？ （ ）(1分)
A.(int)(20+Math.random()*97)
B.20+(int)(Math.random()*980)
C.(int)Math.random()*999
D.20+(int)Math.random()*980
B
2-64
下列关于System类的叙述中，错误的是（ ）。(1分)
A.System类是一个final类
B.System类不能实例化
C.System类中没有定义属性
D.System类主要提供了系统环境参数的访问
C
2-65
在Java中，负责对字节代码解释执行的是 （ ）(2分)
A.应用服务器
B.虚拟机
C.垃圾回收器
D.编译器
B
java中负责对字节代码解释执行的是虚拟机，虚拟机将得到的字节代码进行编码运行
2-66
有一个类A，以下为其构造方法的声明，其中正确的是（）。(3分)
A.void A(int x){...}
B.A(int x){...}
C.a(int x){...}
D.void a(int x){...}
B
2-67
对于构造方法，下列叙述不正确的是（ ）。(1分)
A.构造方法的方法名必须与类名相同
B.构造方法的返回类型只能是void型
C.构造方法可以对该类对象的实例变量进行初始化工作
D.一般在创建新对象时，系统会自动调用构造方法
B
2-68
下面说法正确的是（）(1分)
A.如果源代码中有package语句，则该语句必须放在代码的第一行
B.如果源代码中有import语句，则该语句必须放在在代码的第一行
C.如果源代码中有main方法，则该方法必须被放在代码的第一行
D.如果某文件的源代码中定义了一个public的接口，接口名和文件名可以不同
A
2-69
下面代码的输出的结果是()。
class Person {
static String country="A城市" ;
}
public class Test{
public static void main(String args[]) {
Person p1=new Person();
Person p2=new Person();
p1.country="B城市";
p2.country="C城市";
System.out.println(p1.country);
System.out.println(p2.country);
}
}(1分)
A.B城市 C城市
B.B城市 B城市
C.A城市 C城市
D.C城市 C城市
D
说明：
全局变量，看最后变化后的值
2-70
一个*.java文件中可以包含多少个public类？(1分)
A.最多1个
B.最少1个
C.只能是0个
D.不限制
A
71——80
2-71
一个类在重写其父类的某个方法时，在重写方法的定义中，哪个部分可以与父类被重写方法的定义不同？(1分)
A.访问修饰符
B.方法名
C.返回值类型
D.方法形参
A
2-72
以下对封装的描述正确的是(1分)
A.只能对一个类中的方法进行封装，不能对属性进行封装
B.如果子类继承了父类，对于父类中进行封装的方法，子类仍然可以直接调用
C.封装的意义不大，因此在编码时尽量不要使用
D.封装的主要作用在于对外隐藏内部实现细节，增强程序的安全性
D
2-73
访问修饰符作用范围由大到小是(1分)
A.private-default-protected-public
B.public-default-protected-private
C.private-protected-default-public
D.public-protected-default-private
D
2-74
以下（）不是Object类的方法(1分)
A.clone（）
B.finalize（）
C.hasNext（）
D.toString（）
C
2-75
以下描述正确的有(1分)
A.方法的重写应用在一个类的内部
B.方法的重载与返回值类型无关
C.构造方法不能重载
D.构造方法可以重写
B
构造方法不能重写！构造方法也不能被继承！构造方法可以重载！
方法的重载与返回值类型无关，但是方法的重写与返回值类型有关
2-76
在Java中，下面对于构造函数的描述正确的是。(1分)
A.类必须显示定义构造函数
B.构造函数的返回类型是void
C.一个类可以定义多个构造函数
D.构造函数和类有相同的名称，并且不能带任何参数
C
2-77
已知类的继承关系如下：
class Employee;
class Manager extends Employee;
class Director extends Employee;
则以下语句哪个能通过编译？ ( )。(1分)
A.Employee e = new Manager();
B.Manager m = new Director();
C.Director d = new Manager();
D.Director d = new Employee();
A
2-78※
以下说法错误的是（ ）(1分)
A.静态方法可以直接访问本类的静态变量和静态方法
B.静态方法可以直接访问本类的非静态变量和非静态发方法
C.非静态方法可以直接访问本类的静态变量和静态方法
D.非静态方法可以直接访问本类的非静态变量和非静态方法
B
2-79
在Java中，一个类可同时定义许多同名的方法，这些方法的形式参数的个数、类型或顺序各不相同传回的值也可以不相同，这种面相对象程序特性称为（ ）。(1分)
A.隐藏
B.覆盖
C.重载
D.Java不支持此特性
C
2-80
分析如下代码。
public class Test {
public static void main(String[] args) {
double radius;
final double PI= 3.15169;
double area = radius * radius * PI;
System.out.println("Area is " + area);
}
}
如下说法哪句是正确的？(1分)
A.程序编译错误，因为变量radius没有初始化。
B.程序编译错误，因为常量PI定义在方法中。
C.程序没有编译错误但运行时会出错，因为radius没有初始化。
D.程序编译和运行正确。
A
81——90
2-81
分析如下代码。
class Circle {
private double radius;
public Circle(double radius) {
radius = radius;
}
}
如下哪句是正确的？(1分)
A.程序有一个编译错误，因为没有main方法。
B.程序可以编译，但没有创建一个特定radius的Circle对象。对象的radius始终为0。
C.程序有一个编译错误，因为不能radius = radius。
D.程序无法编译，因为Circle没有缺省的构造函数。
B
2-82 x
在main方法中第二条println语句的输出是什么？
public class Foo {
int i;
static int s;
public static void main(String[] args) {
Foo f1 = new Foo();
System.out.println("f1.i is " + f1.i + " f1.s is " + f1.s);
Foo f2 = new Foo();
System.out.println("f2.i is " + f2.i + " f2.s is " + f2.s);
Foo f3 = new Foo();
System.out.println("f3.i is " + f3.i + " f3.s is " + f3.s);
}
public Foo() {
i++;
s++;
}
}(1分)
A.f2.i is 1 f2.s is 1
B.f2.i is 1 f2.s is 2
C.f2.i is 2 f2.s is 2
D.f2.i is 2 f2.s is 1
B
2-83
要使类中的某个成员变量只能被它自身访问到，该变量可用什么修饰符修饰？( )(1分)
A.protected
B.public
C.private
D.应不加修饰符
C
2-84
指出下列程序的运行结果( )
public class ObParm{
static int j=20;
public static void main(String argv[]){
int i=10;
ObParm p=new ObParm();
p.amethod(i);
System.out.println(i);
System.out.println(j);
}
public void amethod(int x){
x=x*2;
j=j*2;
}
}(1分)
A.10 40
B.20 40
C.10 20
D.20 20
A
2-85
若在某一个类定义中定义有如下的方法： final void aFinalFunction( ),则该方法属于( )。(1分)
A.本地方法
B.静态方法
C.最终方法
D.抽象方法
C
2-86
将以下哪种方法插入行3是不合法的。
1．public class Test1{
2． public float aMethod（float a，float b）{ }
3．
4．}(1分)
A.public float aMethod（float a， float b，float c）{ }
B.public float aMethod（float c，float d）{ }
C.public int aMethod（int a， int b）{ }
D.private float aMethod（int a，int b，int c）{ }
B
2-87
将以下哪种方法插入行6是不合法的。（ ） 。
1．public class Test1 {
2． public float aMethod（float a，float b） throws
3． IOException { }
4． }
5．public class Test2 extends Test1{
6．
7．}(1分)
A.float aMethod（float a，float b）{ }
B.public int aMethod（int a，int b）throws Exception{ }
C.public float aMethod（float p，float q）{ }
D.public int aMethod（int a，int b）throws IOException{ }
A
2-88
类Teacher和Student是类Person的子类,下面的代码中最后一句语句的运行结果是( ).
Person p;
Teacher t;
Student s;
//p,t and s are all non-null.
if(t instanceof Person) {
s=(Student)t;
}(1分)
A.编译时正确，但运行时错误
B.将构造一个Student对象
C.表达式是错误的
D.表达式是合法的
C
说明：
instanceof是Java、php的一个二元操作符（运算符），和==，>，<是同一类东西。由于它是由字母组成的，所以也是Java的保留关键字。它的作用是判断其左边对象是否为其右边类的实例，返回boolean类型的数据。可以用来判断继承中的子类的实例是否为父类的实现。相当于c#中的is操作符。java中的instanceof是通过返回一个布尔值来指出，这个对象是否是这个特定类或者是它的子类的一个实例。
2-89
在Java中，能实现多重继承效果的方式是（ ）。(1分)
A.接口
B.继承
C.内部类
D.适配器
A
2-90
下列选项中，用于实现接口的关键字是 （ ）。(1分)
A.interface
B. implements
C. abstract
D.class
B
91——100
2-91※
关于接口的声明，错误的是( ) 。(1分)
A.接口中所有的成员属性都是public static final修订的常量
B.接口中的成员属性在声明时可以省略修订关键字
C.接口中所有的方法都是public abstract final修订的
D.接口中所有的方法都是public abstract修订的
C
2-92
下面的概念，哪个不是关于对象的多态性的体现。(1分)
A.方法的重载
B.方法的继承
C.方法的覆盖
D.对象的上、下转型
B
2-93
关于抽象类，下面叙述错误的是（） 。(1分)
A.包含抽象方法的类必须是抽象类
B.抽象方法只需要声明，不需要实现
C.抽象类可以实例化
D.抽象类中可以没有抽象方法
C
2-94
在使用super 和this关键字时，以下描述正确的是(1分)
A.
在子类构造方法中使用super（）显示调用父类的构造方法，super（）必须写在子类构造方法的第一行，否则编译不通过
B.
this（）和super（）可以同时出现在一个构造函数中
C.
super（）和this（）不一定要放在构造方法内第一行
D.
this（）和super（）可以在static环境中使用，包括static方法和static语句块
A
2-95
以下对继承的描述错误的是(1分)
A.Java中的继承允许一个子类继承多个父类
B.Java中的继承存在着传递性
C.父类更具有通用性，子类更具体
D.当实例化子类时会递归调用父类中的构造方法
A
2-96
以下对接口描述错误的有(1分)
A.接口没有提供构造方法
B.接口中的方法默认使用public、abstract修饰
C.接口中的属性默认使用public、static、final修饰
D.接口不允许多继承
D
2-97
以下代码，描述正确的有
interface IDemo{
public static final String name;1
void print();2
public void getInfo();3
}
abstract class Person implements IDemo{4
public void print(){
}
}(1分)
A.第1行错误，没有给变量赋值
B.第4行错误，没有实现接口的全部方法
C.第2行错误，方法没有修饰符
D.第3行错误，没有方法的实现
A
2-98
以下程序运行结果是
public class Test extends Father{
private String name="test";
public static void main(String[] args){
Test test = new Test();
System.out.println(test.getName());
}
}
class Father{
private String name="father";
public String getName() {
return name;
}
}(1分)
A.father
B.编译出错
C.test
D.运行出错，无输出
A
说明：
Test类中没有get方法，所以去调用其父类中已有的get方法
如果Test类中写出其get方法那么就显示结果“test”
2-99
下列选项中关于java中super关键字的说法错误的是(1分)
A.super关键字是在子类对象内部指代其父类对象的引用
B.super关键字不仅可以指代子类的直接父类，还可以指代父类的父类
C.子类可以通过super关键字调用父类的方法
D.子类可以通过super关键字调用父类的属性
B
2-100
如下代码的输出是（ ）。
public class Test {
public static void main(String[] args) {
Object o1 = new Object();
Object o2 = new Object();
System.out.print((o1 == o2) + " " + (o1.equals(o2)));
}
}(1分)
A.false false
B.true true
C.false true
D.true false
A
101——107
2-101
已知类的继承关系如下：
class Employee;
class Manager extends Employee;
class Director extends Employee; 则以下语句哪个能通过编译？ ( )。(1分)
A.Employee e = new Manager();
B.Director d = new Manager();
C.Director d = new Employee();
D.Manager m = new Director();
A
2-102
对于下列代码:
class Parent {
public int addValue( int a, int b) {
int s;
s = a+b;
return s;
}
}
class Child extends Parent { }
下述哪个方法可以加入类Child?(1分)
A.int addValue( int a,int b ){// do something...}
B.public void addValue (int a,int b ){// do something...}
C.public int addValue( int a){// do something...}
D.public int addValue( int a,int b )throws MyException {//do something...}
C
说明：
C选项不属于重写也不属于重载，这是子类自己的方法
当方法名和参数和父类一样的时候，已经说明这是方法的重写，然后因为重写的时候返回值类型要相同，所以这个B选项不正确
注意：
方法的重写是指两个方法的返回值、方法名、参数的类型和个数相同(子类重写父类的方法)。
方法的重写，不能发生在同类中，只能发生在子类中。
2-103
在某个类中存在一个方法：void getSort(int x),以下能作为这个方法的重载的声明的是( )(1分)
A.public get (float x)
B.int getSort(int y)
C.double getSort(int x,. int y)
D.void get(int x, int y)
C
2-104
设类B是类C的父类，下列声明对象x1的语句中不正确的是?(1分)
A.B x1 = new B( );
B.B x1=new C( );
C.C x1 = new C( );
D.C x1=new B( );
D
2-105
下列哪个叙述是正确的？(1分)
A.一个类最多可以实现两个接口
B.允许接口中只有一个抽象方法
C.如果一个抽象类实现某个接口，那么它必须要重写接口中的全部方法
D.如果一个非抽象类实现某个接口，那么它可以只重写接口中的部分方法
B
2-106
下列选项中，用于定义接口的关键字是( )。(1分)
A.import
B.implements
C. interface
D. protected
C
2-107
下面中哪个可以在Test的子类中使用：（ ）
class Test { protected int method (int a, int b) { return 0; }
}(1分)
A.int method (int a, int b) { return 0; }
B.private int method (int a, int b) { return 0; }
C.private int method (int a, long b) { return 0; }
D.public short method (int a, int b) { return 0; }
C
权限由小到大 ：public > protected > 默认 > private
填空题：
1——6
3-1
集合按照存储结构的不同可分为单列集合和双列集合，单列集合的根接口是（ ），双列集合的根接口是（ ）。
Collection
Map
整个集合类按照存储的结构被分为单列集合和双列集合，单列集合的根接口是Collection，双列集合的根接口是Map集合。在Collection接口中主要有两个子接口，分别是List和Set。List集合的特点是元素有序、包含重复元素，Set集合的特点是元素无序、不包含重复元素。Map集合中存储的是键值映射关系，元素都是成对出现的，就像上学时的同桌一样。Map接口的主要子接口有HashMap和TreeMap。
3-2
请写出以下程序运行结果：
//环境 JDK 1.5及以上
public static void main(String args[])
{
Set<Integer> set=new TreeSet<Integer>();
List<Integer> list=new ArrayList<Integer>();
for (int i=-3;i<3;i++)
{
set.add(i);
list.add(i);
}
for (int i=0;i<3;i++)
{
set.remove(i);
list.remove(i);
}
System.out.println(set+" "+list);
}
程序运行的输出结果为:
[-3, -2, -1] [-2, 0, 2]
说明：
remove方法用于移除Set集合中的指定对象。
ArrayList类remove用来移除指定下标下的元素
3-3
使用Iterator遍历集合时，首先需要调用（ ）方法判断是否存在下一个元素，若存在下一个元素，则调用（ ）方法取出该元素。
hashNext()
next()
3-4
InputStreamReader类是用于将（ ）转换为（ ）。
字节流
字符流
3-5
在调用SimpleDateFormat的( )方法时，会将Date对象格式化成如模板格式的时间形式。
format()
3-6
在程序中需要调用其静态方法( )来得到一个Calendar对象。
getInstance()
程序填空题：
1——1
4-1
下列程序使用泛型机制创建一个数组列表对象，并向其添加三个元素，利用迭代器遍历该数组列表，请把程序补充完整。
import java.util.*;
public class Main{
public static void main(String[] args) {
List< 1 > al=new ArrayList< 2 >();
al.add("red");
al.add("yellow");
al.add("blue");
ListIterator< String > listIter=al.listIterator();
while( 3 )
System.out.print( 4 +" ");
1、String
2、String
3、listIter.hasNext()
4、listIter.next()