《CoreJava》理论试题题库答案版

《CoreJava》理论试题题库答案版得分阅卷人
一、单选题(20题，共38分)
1、(2分)基本数据类型float的包装类是哪项,(C) A( Integer B( Double
C( Float D( Character 2、(2分)使用下列哪个修饰符定义的类不能被继承( C ) A. static B. abstract C. final D. Native
3、(1分)下列类的定义，错误的是( D ) A. public class test extends Object{……} 学院班级姓名 B. final class operators{……}
密封线内不要答题 C. class Point{……}
D. void class Point{……}
4、(2分)静态内部类是指使用(B)来修饰的内部类 A(final B.static
C.public
D.protected
5、(2分)匿名内部类的特点下面错误的是(b) A、匿名内部类没有构造方法
B、匿名内部类是静态的
C、它主要用于继承其他类或实现接口
D、它是一个特殊的局部内部类
6、(2分)下列哪个类不是java基本数据类型的封装类,( C )
A. Integer;
B. Byte;
C. String;
D. Character;
7、(1分)基本数据类型char的包装类是哪项,( D )
A int
B char
C String
D Character
8、(2分)阅读以下程序代码，作出分析:public class Test { public static void main(String[]
args) { boolean b = true; b=new Apple().equals(new Apple()); System.out.println(b); }}class
1 / 49
Apple{}该程序的输出结果是:(A)
A(false
B(true
C. 不确定结果
D. 编译错误
9、(2分)List接口的特点是哪项,(C)
A(不允许重复元素，元素无顺序
B(不允许重复元素，元素无顺序
c(允许重复元素，元素有顺序
D(允许重复元素，元素无顺序
10、(2分)关于HashMap和HashTable的说法错误的是( D ): A. HashMap和HashTable都是Map接口的实现类
B. HashTable是线性安全的
C. HashMap是线性不安全的
D(HashTable要比HashMap的性能高一点
11、(2分)当程序调用一个null对象的方法或属性时，这将引起(A )异常
A NullPointerException
B NumberFormatException
C IndexOutOfBoundException
D 以上都可能
12、(2分)局部内部类是定义在(B)
A.外部类里面 B、外部类的某个方法里面 C、通过实现接口来实现 D、都可以
13、(1分)创建一个数据库对象的关键字是( D )
A、alter
B、new
C、add
D、create 14、(2分):在数据库中，下列表示整型数据类型的是(B)。

A、double B、int C、date D、decimal 15、(2分)创建视图必须使用的下列哪个语句( B ) A. create picture
B. create view
C. create sight
D. create vict
16、(2分)SELECT查询中，要把结果中的行按照某一列的值进行排序，所用到的子句是:( A )
A、ORDER BY
B、WHERE
C、GROUP BY
D、HAVING
2 / 49
17、(4分)与HAVING子句一起使用的子句是( D )。

A(ORDER BY B(WHERE
C(JOIN D(GROUP BY 18、(2分) 用于执行insert 语句使用的JDBC方法是( D )
A、createStatement
B、Class.forName
C、executeQuery
D、executeUpdate
19、(1分) 实现了Set集合接口的类是哪项,( C )
A. ArrayList
B. HashTable
C. HashSet
D. Collection
20、(2分) 要实例化ArrayList类的一个对象，此类继承了List接口，下列哪个方法是正确的(B )
A、 ArrayList myList=new Object()
B、List myList=new ArrayList()
C、 ArrayList myList=new List()
D、List myList=new List()
关于Java语言以下说法正确的是( C )
A:Java是低级语言
B:Java语言开发完的代码只能运行在Windows系统上
C:Java是高级语言
:Java语言运行不需要依赖其他的环境。

编写后可以直接在别电脑识别。

D
21.关于Java语言在dos下运行Hello类的命令正确的是( B ) A:>java hello
B:>java Hello
C:>javac hello.java
D:>javac Hello.java
22.JDK和JRE的区别下面说法正确的是( A )
A:如果只是运行Java程序，可以只安装JRE，无需安装JDK B:JDK只能运行Java程序，不能编译
C:Java程序安装JRE就可以编译Java程序
D:安装了JRE，Java语言就不区分大小写了
23.如果在DOS下运行java 报“’java’不是内部命令，也不是可以运行的程序或批处理文件”。

可
能是什么原因,下面说法错误的是(D)
A:没有安装JDK
B:没有配置环境变量
C:配置的环境变量有问题
D:Java代码有问题
24.( B )公司在1995年年初发布了java语言
A:Symbian公司
3 / 49
B:sun公司
C:MicroSoft公司
D:IBM公司
25.下面不属于java语言体系的是( D ) A:J2ME
B:J2SE
C:J2EE
D:JDK
26.DOS中，从根目录起开始描述目录的路径叫( A )
A:绝对路径
B:相对路径
C:当前路径
D:缺省路径
27.DOS中，从一个目录转向另一个目录，应使用的命令( B ) A:MD
B:CD
C:DEL
:DIR D
28.下面不属于高级语言的是( D ) A:Java
B:C#
C:Python
D:汇编
29.Android系统用那种语言开发程序 ( A )
A:Java
B:C#
C:Python
D:汇编
30.Java语言编译后，跨平台是依赖( A )翻译给不同操作系统的计算机
A:JVM
B:JRE
C:.class 文件
D:.java文件
31.下面数据JDK安装后，不属于该文件夹内容的是(D)
A:bin
B:jre
C:lib
4 / 49
D:System
32.下面数据JDK安装后，不是JDK的目录是(B) A:bin
B:System
C:lib
:jre D
33.下面数据JDK安装后，关于JRE目录解释正确的是(D) A:该路径下存放了JDK的各种工具命令。

B:该路径下存放了JDK提供的一些简单示例代码 C:该路径
下存放的是JDK工具命令的实际执行程序 D:该路径下安装的就是Java程序所必须的运行时环境。

34.启动运行窗口的快捷键是(C)
A:ctrl+f
B:ctrl+r
C:Win键+R
D:alt+/
35.在启动运行窗口输入( B )打开dos窗口 A:regedit
B:cmd
C:ipconfig
D:dir
36.在dos窗口输入( C ),检验安装程序是否有问题 A:regedit
B:cmd
C:java
D:dir
37.编译Java程序的命令是( A ) A:javac
B:cmd
C:ipconfig
D:dir
38.运行Java程序的命令是( D ) A:javac
B:cmd
C:ipconfig
D:java
5 / 49
39.Windows下配置环境变量时与其他的路径进行分割的符号是( A )
A:;
B:.
C::
D:%
40..J2ME这个版本的主要作用，解释正确的是( B ) A:是整个JAVA技术的核心和基础
B:主要用于控制移动设备和信息家电等有限存储的设备。

C:提供了企业应用开发相关的完整方案。

D:和J2SE没有区别
41..J2EE这个版本的主要作用，解释正确的是( C ) A:是整个JAVA技术的核心和基础
B:主要用于控制移动设备和信息家电等有限存储的设备。

C:提供了企业应用开发相关的完整方案。

D:和J2SE没有区别
42..J2SE这个版本的主要作用，解释正确的是( A ) A:是整个JAVA技术的核心和基础，他是J2ME和J2EE编程的基础。

B:主要用于控制移动设备和信息家电等有限存储的设备。

C:提供了企业应用开发相关的完整方案。

D:和J2EE没有区别
43..作为开发JavaSE程序,需要安装( A )工具
A:JDK
B:jre
C:lib
D:System
44..Android是什么( C )
A:是一个品牌
B:是一个功能
C:是操作系统
D:是Java程序所必须的JRE环境。

45..开发Java程序出了需要安装JDK以外还需要配置( A ) A:环境变量
B:DOS窗口
C:运行空间目录
D:JRE环境。

46..Java文件，经过JVM编译后的文件后缀名是什么,( B ) A:.java
6 / 49
B:.class
C:.avi
D:.mp3
47..关于Java语言在dos下编译Hello类的命令正确的是( D )
A.>java hello
B.>java Hello
C.>javac hello.java
D.>javac Hello.java
48..Windows64位操作系统和windows32位系统安装,,,说法正确的是( B ) A:可以安装同一个JDK文件
B:不可以安装同一个JDK
C:安装JRE后，,,,可以安装同一个安装文件
D:以上说法都不正确。

49..不属于,,,,(,的,,，三大分类是，说法错误的是( D )
A:核心,,，
B:可选API
C:特殊API
D:以上说法都不正确
50..如下代码: int a = 2;do{System.out.println("你好
");a++;}while(a<4);如下描述正确的是(B):
A、在控制台中，你好被打印1次
B、在控制台中，你好被打印2次
C、在控制台中，你好被打印3次
D、每执行一次循环a都加2
51..在java中，for关键字的作用是(C):
A、定义变量
B、定义函数
C、实现循环
D、定义类
52..如下代码for(int i = 0;i<10;i++){System.out.println("welcome");} 下面说法正确的有(C):
A、循环会执行5次
B、循环会执行11次
C、每循环一次，i都会加1
D、每循环一次，i都会加2
53..下列代码的不可能输出结果(D)public class Person{static String
arr[] = new String[5];public
static void main(String a[]) {arr[1] = “2”;arr[4]=”0”; for(int i=0;i<arr.length;i++)System.out.print(arr[i]);}}
A、输出null
B、2
C、0
7 / 49
D、运行时将产生错误
54..如下代码可能输出的是:“public cl ass Person{static int arr[] = new int[5];public static void
main(String a[]) {for(int
i=0;i<arr.length;i++);System.out.print(arr[0]);}}( C ) A、编译时将产生错误
B、编译时正确，运行时将产生错误
C、输出零
D、输出空
55..关于下面代码段说法正确的是(B)for(int
count=0;count<3;count++){System.out.print(count+
“，”);count*=0.1;}
A、编译错误;
B、死循环;
C、0,1,2;
D、0,1,2,3
56..不论循环条件判断的结果是什么， (B)循环将至少执行一次。

A(while
B(do-while
C(for
D. 以上都不是
57..如下代码:for(int i = 0;i<count;i++){System.out.println("hello");} 如果想让hello在控制台中打
印3次，则count的值应该为(C)
1 A(
B(2
C(3
D. 4
58..下面能实现循环的关键字是( C ): A、if
B、else
C、while
D、switch
59..对于while(循环条件){循环体}循环，在每次执行循环之前，都先对循环
条件求值，
如果循环条件为( B )则不运行循环体部分。

A、true
B、false
8 / 49
C、1
D、0
60..下列语句输出的结果是:( A ) public class Lx3 { public static void main(String[] args) {
int a=0, b=11; do{
if(b%2==0)
a += b;
b++; }
while(b <= 10); System.out.print(a); }} A:0
B:1
C:2
D:3;
61..下列语句输出的结果是:( C ) public class Lx3 { public static void main(String[] args) {
int a=0, b=1; do{
if(b%2==0)
a += b;
b++; }
while(b <= 10); System.out.print(a); }} A:编译错误
B:25
C:30
9 / 49
D:55
62..下列程序运行结果是:(C)
public class X3 {
public static void main(String[] args) {
for(int i=0; i<10; i++){ if(i==5) break; System.out.print(i); } }} A:编译错误
B:1234
C:01234
D:12345
63..下列程序运行结果是:(D)
public class Test {
public static void main(String[] args) { while(1==1){
System.out.println("test"); } }} A:编译错误; B:运行时报错
C:true
D:死循环，一直打印true test
64..下列语句输出的结果为(B)。

int count =0;
while(count<3) ;{
System.out.print(count+“;”);
count++;}
A. 语法编译错误
B. 死循环
10 / 49
C. 0;1;2
D. 0;1;2;3
65..下列关于循环语句说法错误的是(C)。

A(do-while语句至少执行一次
B(do-while要先执行do里面的语句，然后在判断条件是否成立 C(do-while 语句与while语句没有区别
D. do-while语句书写不当会产生死循环现象
66..以下表达式不可以作为循环条件的是( D )。

A. i==5
B. i>5
C. bEqual = str.equals("q").
D. i=0
67..下面能实现循环的关键字是(C): A、if
B、else
C、do while
D、switch
68..对于do{循环体}while{循环条件}循环，下面说法正确的是( A )。

A、循环体至少执行一次
B、循环条件的值为true时，才会第一次执行循环体
C、循环体一直会执行
D、循环体一直都不执行
69..如下代码:
int a = 0;
do{
11 / 49
System.out.println("hello");
a++;
}
while(a<3)，如下描述正确的是(C ):
A、在控制台中，hello打印1次
B、在控制台中，hello打印2次
C、在控制台中，hello打印3次
D、在控制台中，hello一次都不会被打印
70..下列关于循环语句说法错误的是( C )。

A(do-while语句至少执行一次
B(do-while要先执行do里面的语句，然后在判断条件是否成立 C(do-while 语句与while语句没有区别
D. do-while语句书写不当会产生死循环现象
71..以下表达式不可以作为循环条件的是( D )。

B. i>5
C. bEqual = str.equals("q")
D. count =i
72..下列关于运算符优先级的说法中，不正确的一个是( C ) (A)运算符按照优先级顺序表进行运算
(B)同一优先级的运算符在表达式中都是按照从左到右的顺序进行运算的 (C)同一优先级的运算符在表达式中都是按照从右到左的顺序进行运算的
(D)括号可以改变运算的优先次序
73..在JAVA语言中:下列选项不是逻辑运算符的是( C ) A.&&
B.||
C.%
12 / 49
D.!
74..为一个boolean类型变量赋值时，可以使用( B )方式。

A. boolean
a=ture:
B. boolean a=true;
C. boolean a="真";
D. boolean a==false;
75..下列关于基本数据类型的说法中，正确的一项是( D )。

(A)boolean类型变量的值只能取1或0
(B)float是带符号的16位浮点数
(C)double是带符号的32位浮点数
(D)boolean类型变量的取值为true和false
76..java里面用来表示语句结束的分隔符是( A )。

A. ;
B. ，
C. 。

D.{ }
77..Java代码中，语句间的分隔符的是( C ) A.//
B.\\
C.;
D.:
78..Java代码中单行注释是( B ) A. /
B. //
13 / 49
C. ///
D. /*
79..下列( C )不是合法的标识符,
A.Student
C.-5
D._person
80..下列标示符中，属于正确声明的是:( D ) A:1test B:test+01
C:test，01
D:test01
81..设a、b为long型变量，x、y为float型变量，ch为char类型变量且它们均已被赋值，则下列
语句中正确的是( B )。

(A)switch(x+y) {} (B)switch(ch+1) {} (C)switch ch {} (D)switch(a+b); {}
82..下面能实现循环的关键字是( C ):
A、if
B、else
C、while
D、switch
83..对于while(循环条件){循环体}循环，在每次执行循环之前，都先对循环条件求值，如果循环条件
为( A )则运行循环体部分。

14 / 49
A、true
B、false
C、1
D、0
84..下列程序运行结果是:( D )
public class Test {
public static void main(String[] args) {
while(1==1){
System.out.println("test"); } }}
A:编译错误
B:运行时报错
C:true
D:死循环，一直打印test
85..如下代码:
for(inti = 0;i<10;i++){ System.out.println("welcome"); }
下面说法正确的有( A ):
A、循环会执行10次
B、循环会执行11次
C、每循环一次，i都会加3
D、每循环一次，i都会加2
86..下列关于增强型for循环(foreach循环)的描述正确的是:( A ) A:增强型for循环语法更简洁，方便阅读。

B:增强型for循环与普通for循环相比，只有优点，没有缺点，应大量使用，放弃普通for循环;
C:增强型for循环效率相当低，不要使用它;
15 / 49
D:增强型for循环在任何时候都可以被替换成普通for循环
87..关于数组，下列说法中不正确的是( C )。

A :数组是最简单的复合数据类型，是一系列数据的集合
B :数组元素可以是基本数据类型、对象或其他数组
C :定义数组时必须分配内存
D :一个数组中所有元素都必须具有相同的数据类型
88..设有下列数组定义语句:
int a[] = {1, 2, 3};
则对此语句的叙述错误的是( C )。

A :定义了一个名为a的一维数组
B :a数组有3个元素
C :a数组元素的下标为1,3
D :数组中每个元素的类型都是整数
89..执行语句:int[] x = new int[20];后，下面哪个说法是正确的,( C )
A :x[19]为空
B :x[19]未定义
C :x[19]为0
D :x[0]为空
90..下列程序的运行结果( C )public class X6_3_1 {public static void main(String[] args)
{int a[]={12,39,26,41,55,63,72,40,83,95};int i1=0,i2=0;for(int i=0;i<a.length;i++)if(a[i] %2 == 1) i1++;else
i2++;System.out.println(i1+"\t"+i2); }
A:4 6
B:程序错误
C:6 4
D:3 7
91..下面foreach循环的程序输出结果是( D )。

public class Lx1{public static void main(String[]
args) {int a[]={1,5,3,9,7};Arrays.sort(a); for(int s0:a)
System.out.print (s0); } A:15397
B:程序错误
C:13597
D:13579
92..设有下列数组定义语句: int b[][]= {{1, 2}, {3}};则对此语句的叙述不正确的是( D )。

A: 定义了一个名为b的二维数组
B: b数组 b[1][1]为0
C: b数组 b[1][0]为3
D: b数组 b[1][0]为1
93..设有下列数组定义语句: int a[][]= {{1, 2}, {3}};则对此语句的叙述正确的是( D )。

16 / 49
A: 定义了一个名为a的一维数组
B: a数组 a[1][1]为0
C: a数组元素的下标为1,3
D: 数组中每个元素的类型都是整数
94..设有下列数组定义语句: int a[][]= {{1, 2}, {3}};则此a[1][0]的值为( A )。

A: 3
B: 1
C: 2
D: 空值
95..下列程序输出的结果是:( B )public class Lx1 {public static void main(String[] args)
{String a[][]
={{"","","",""},{""},{"",""}};System.out.println(a[2].length);}} A:1 B:2
C:3
D:4
96..下列程序输出的结果是:(C )public class Lx1 {public static void main(String[] args)
{String a[][]
={{"","","",""},{""},{"",""}};System.out.println(a.length);}} A:1 B:2
C:3
D:4
97..下列程序输出的结果是:( D )public class Lx1 {public static void main(String[] args)
{String a[][]
={{"","","",""},{""},{"",""}};System.out.println(a[0].length);}} A:1 B:2
C:3
D:4
98..下面foreach循环的程序输出结果是( C )。

public class Lx1{
public static void main(String[] args) {
int a[]={1,5,3,9,7};
for(int s0:a)
System.out.print (a[s0]);
}
17 / 49
}
A:15397
B:程序错误
C:5程序错误
D:13579
99..下面foreach循环的程序输出结果是( A )。

public class Lx1{
public static void main(String[] args) {
int a[]={1,5,3,9,7};
for(int s0:a) System.out.print (s0);
}
}
A:15397
B:程序错误
:5程序错误 C
D:13579
100..阅读以下程序，选择正确的运行结果:( C )public class X6 { public static void main(String[]
args) {int a[][]={{}};System.out.println(a.length + “,”，
a[0].length); }} A:0,0;
B:0,1;
C:1,0;
D:1,1
101..设有下列数组定义语句: int b[][]= {{1, 2}, {3},{}};则对此语句的叙述正确的是( A )。

A: b[2]为空
B: b[1][1]为2
C: b[1][0]为1
D: b[1]为2
102..设有下列数组定义语句: int b[][]= {{1, 2}, {3},{}};则输出b[0][1]的值是( A )。

A: 2
B: 1
C:3
D: 空
18 / 49
103..下列程序输出的结果是:(A )public class Lx1 {public static void main(String[] args) {char
[][]msg={{'3','G','团','队'},{'I','O','S'},{'团','队
'}};System.out.println(msg.length); }}
A:3
B:2
C:6
D:4
104..关于数组，下列说法中正确的是( A )。

A :数组是最简单的复合数据类型，是一系列数据的集合 B :数组元素可以是只能是基本数据类型
C :定义数组时必须分配内存
D :一个数组中所有元素可以有不同的数据类型
105..数组是一种( B )数据类型
A:基本
B:复合
C:字符
D:String
106..若有如下程序段: int index=1; int foo[]=new int[3]; int
bar=foo[index] int baz=bar+index;
程序的执行结果正确的是( B )。

A:整型变量baz的值为0
B:整型变量baz的值为1
C:整型变量baz的值为2
D: 执行有错误
107..数组用来存储一组的数据结构是( D )。

A:不同类型数据
B:整数类型数据
C:对象
D:相同类型数据
108..数组的初始化可以有( D )。

A:默认值是0
B:默认值是true
C:默认值是1
D:静态初始化
109..下列数组的初始化正确的是( B )。

A: int[] score = new int[]; B: int score[] = new int[] {90, 12, 34, 77, 56};
C: int[] score = new int[5] {90, 12, 34, 77, 56};
19 / 49
D: int score= {90, 12, 34, 77, 56};
110..for语句和equals使用;中)阅读下面代码，它完成的功能是( B )。

String[] a= {"
我们", "你好", "小河边", "我们", "读书"}; for(int i = 0; i <a.length; i++)
{ if(a[i].equals("我们")) { a[i] = "他们"; } } A:查找
B:查找并替换
C:增加
D:删除
111..下列数组的初始化不正确的是( C )。

A: int[] score = new int[3];
B: int score[] = new int[] {90, 12, 34, 77, 56};
C: int[] score = new int[5] {90, 12, 34, 77, 56};
D: int score[]= {90, 12, 34, 77, 56};
112..在java语言的数据类型中short到哪种类型必须强制转换( B ) A:int B:byte
C:long
D:boolean
113..现有数组int score[] = new int[] {90, 12, 34, 77, 56}下列正确的
是( D ) A: score[1]=90
B: score[2]=12
C: score[3]=34
D: 此数组共有5个元素
114..下面为数组初始化正确的写法是( A )
A: double c[] = new double[]{1,2} B: double c[] = new double{1,2}
C: double c[] = new double[](1,2) D: double c[] = new double(1,2) 115..对于二位数组int[][] ages = new int[2][3]下列说法正确的是( A ) A:ages[0]的长度为3
B:ages[1]的长度为2
C:ages[0][1]的长度为3
D:ages的长度为3
116..下面能实现循环的关键字是(C)
20 / 49
A:if
B:else
C:while
D:switch
117..对于while(循环条件){循环体}循环，在每次执行循环之前，都先对循环条件求值，如
果循环条件为(A)则运行循环体部分。

A:true
B:false
C:1
D:0
118..对于while(循环条件){循环体}循环，下面选项说法正确的是( A ) A:循环条件为true，执行循环体
B:循环条件为true，不执行循环体
C:循环条件为false，执行循环体
D:循环条件为false，内部会执行一次，再停止。

119..对于while(循环条件){循环体}循环，在每次执行循环之前，都先对循环条件求值，如
)则不运行循环体部分。

果循环条件为(B
A:true
B:false
C:1
D:0
120..下列关于循环语句说法错误的是( C )
A:do-while语句至少执行一次
B:do-while要先执行do里面的语句，然后在判断条件是否成立 C:do-while 语句与while语句没有区别
D: do-while语句书写不当会产生死循环现象
121..以下表达式不可以作为循环条件的是( D) A: i==5
B: i>5
C: bEqual = str.equals("q") D: count =i
122..下面能实现循环的关键字是(C) A:if
B:else
C:do while D:switch
123..对于do{循环体}while{循环条件}循环，下面说法正确的是(A)
21 / 49
A:循环体至少执行一次 B:循环条件的值为true时，才会第一次执行循环体C:循环体一直会执行 D:循环体一直都不执行
124..对于do{循环体}while(循环条件)循环，下面说法正确的有(B)
A:循环条件为真时，执行循环体,并且无法终止循环 B:循环体至少执行一次 C:循环条件为假时，才执行循环体 D:循环体一直会执行
125..在java中，for关键字的作用是(C) A:定义变量
B:定义函数
C:实现循环
D:定义类
126..下列程序:(D)public class News { public static void main(String[] args)
{ for(; ; ){ } }}的运行情况是:
A:编译报错，不能运行; B:编译通过，运行时报错;
C:可以通过编译和运行，输出for没有定义变量;
D:运行后产生死循环，程序无法停止;
127..不论循环条件判断的结果是什么， ( B )循环将至少执行一次。

A:while
B:do-while
C:for
D: 以上都不是
128..下列说法中，不正确的一个是( C )。

A:switch语句的功能可以由if…else if语句来实现
B:若用于比较的数据类型为double型，则不可以用switch语句来实现 C:if …else if语句的执行效率总是比switch语句高
D:case子句中可以有多个语句，并且不需要大括号{}括起来
129..假设a是int类型的变量，并初始化为1，则下列(B )是合法的条件语句, A:if(a){}
B:if(a<=3){}
C:if(a=2){}
D:if(true==1){}
130..不属于结构化程序设计，所规定的三种基本控制结构是 (D )
22 / 49
A:选择
B:循环
C:顺序
D:倒序
131..关于switch语句说法正确的是( A ). A:switch语句中控制表达式的类型是byte、short、char、int。

B:在case标签之后必须在每个代码块加上一条break语句。

C:switch可以完全替代if语句。

D:default语句后面必须要加上break语句
132..设a、b为long型变量，x、y为float型变量，ch为char类型变量且它们均已被赋值，
则下列语句中正确的是( B )。

A:switch(x+y) {}
B:switch(ch+1) {}
C:switch ch {}
D:switch(a+b); {}
133..switch语句中不可以控制表达式的类型可以是( D ). A:byte
B:short
C:char
D:float
) 134..下面能实现循环的关键字是(C
A:if
B:else
C:while
D:switch
135..对于while(循环条件){循环体}循环，在每次执行循环之前，都先对循环条件求值，如
果循环条件为(A)则运行循环体部分。

A:true
B:false
C:1
D:0
136..对于while(循环条件){循环体}循环，下面选项说法正确的是( A ): A:循环条件为true，执行循环体
B:循环条件为true，不执行循环体
C:循环条件为false，执行循环体
D:循环条件为false，不执行循环体，下次执行自动会变为true;
137..对于while(循环条件){循环体}循环，在每次执行循环之前，都先对循环条件求值，如
23 / 49
果循环条件为(B)则不运行循环体部分。

A:true
B:false
C:1
D:0
138..下列程序运行结果是:(D)
public class Test { public static void main(String[] args)
{ while(1==1){ System.out.println("test"); } }}
A:编译错误;
B:运行时报错
C:true
D:死循环，一直打印test
139..下列语句输出的结果为(B)。

int count =0; while(count<3) ;
{System.out.print(count+“;”);count++;} A:语法编译错误;
B: 死循环;
;2; C: 0;1
D: 0;1;2;3
140..下列关于循环语句说法错误的是( C ) A:do-while语句至少执行一次B:do-while要先执行do里面的语句，然后在判断条件是否成立 C:do-while 语句与while语句没有区别
D: do-while语句书写不当会产生死循环现象
141..以下表达式不可以作为循环条件的是( D) A: i==5
B: i>5
C: bEqual = str.equals("q") D: count =i
142..下面能实现循环的关键字是(C) A:if B:else C:do while D:switch 143..java类有(A)个直接父类
A、1
B、2
C、3
D、4
24 / 49
144..子类Apple类继承父类Fruit类，子类定义为(C) A、public class child
B、public class Fruit extends Apple
C、public class Apple extends Fruit
D、public class Apple child Fruit
144/1.. A派生出子类B，B派生出子类C，问以下哪个说法是正确的, ( B)
A、C a0=new A();
B、B a1 =new C();
C、B a2=new A();
D、以上都是正确的
145.. A的子类B，B的子类C，并且在Java源代码中有如下声明: 1. A
a0=new A();
2. A a1 =new B();
3. A a2=new C();
问以下哪个说法是正确的, (D)
A、只有第1行能通过编译
B、第1、2行能通过编译，但第3行编译出错
、第1、2、3行能通过编译，但第2、3行运行时出错 C
D、第1行、第2行和第3行的声明都是正确的
146..以下关于构造方法的描述错误的是(A)。

A、构造方法的返回类型只能是void型。

B、构造方法是类的一种特殊函数，它的方法名必须与类名相同。

C、构造方法的主要作用是完成对类的对象的初始化工作。

D、一般在创建新对象时，系统会自动调用构造方法。

147..以下关于继承的叙述正确的是(A)。

A、在Java中类只允许单一继承
B、在Java中一个类只能实现一个接口
C、在Java中一个类不能同时继承一个类和实现一个接口
D、在Java中接口只允许单一继承
148..以下关于继承的叙述正确的是(A)。

A、在Java中类只允许单一继承
B、在Java中一个类只能实现一个接口
C、在Java中一个类不能同时继承一个类和实现一个接口
D、在Java中接口只允许单一继承
149..阅读下列程序进行选择，描述正确的一项是:(D) public class Test extends T1{——1public static void main(String[] args) { Test.a(); ——2 }}class
T1{ static void a(){——3 System.out.println("this is a super&static test"); }}
25 / 49
A、这段程序中的标记1处报错
B、这段程序中的标记2处报错
C、这段程序中的标记3处报错
D、这段程序的运行结果是输出:this is a super&static test
150..下列说法正确的是( C )
、一个子类可以有多个父类，一个父类也可以有多个子类 A
B、一个子类可以有多个父类，但一个父类只可以有一个子类
C、一个子类可以有一个父类，但一个父类可以有多个子类
D、上述说法都不对
151..下面程序段中的空缺处应该填写(A)
public class Teacher {private int age; //年龄public int getAge() {_______(1)________;}public void setAge(int age) {
if (age<22) {System.out.println("错误～最小年龄应为22岁～
");this.age = 22; //如果不符合年龄要求，则赋予默认值} else {this.age = age;}}} A、(1)return this.age;
B、(1)return this;
C、(1)return super.age; ;
D、以上答案都不正确
152..阅读代码:
public class BaseClass1 {
public String sayHello(){
return "父类1";
}
}
public class BaseClass2 {
public String sayHello(){
return "父类2";
}
}
public class SubClass extends BaseClass1,BaseClass1{
private String sayHello(){
return "子";
}
public static void main(String[] args) {
SubClassss= new SubClass();System.out.println(ss.sayHello()); }
}
运行结果为:(A)
A、编译错误
B、运行时出现错误
C、子类
26 / 49
D、父类1 父类2
153..阅读代码:
public class BaseClass {
public double size=3.5;
}
public class SubClass extends BaseClass{
public SubClass(double size){
System.out.println(size);
}
public SubClass(){
}
public static void main(String[] args) { SubClassss= new SubClass(1.2);
}
}
运行结果为:(A)
A、1.2
B、3.5
、编译错误 C
D、运行出错
154..阅读代码:
public class BaseClass {
int a=1;
}
public class BaseClass1 extends BaseClass{ int a=3;
}
public class SubClass extends BaseClass{ private int count() {
return super.a;
}
public static void main(String[] args) { System.out.println(new SubClass().count()); }
}
运行结果为:(B)
A、编译错误
B、1
C、3
D、运行错误
27 / 49
155..分析代码:
public class BaseClass {
public BaseClass(){
System.out.println("父类");
}
}
public class SubClass extends BaseClass{ public SubClass(){
System.out.println("子类");
}
public static void main(String[] args) { new SubClass();
}
}
运行结果为:(C )
A、父类
B、子类
C、父类子类
D、编译错误
156..分析代码:
public class BaseClass {
private int a=4;
}
public class SubClass extends BaseClass{ int a=2;
private void show() {
System.out.println(a);
}
public static void main(String[] args) { SubClassss= new SubClass();
ss.show();
}
}
运行结果为:(C)
A、4
B、3
C、2
D、编译错误
157..有如下代码:
public class News {
static int a=5;
int b=6;
28 / 49
public static void main(String[] args) {
System.out.println(a);
System.out.println(b);
}
}
请选择正确的描述(A)
、编译报错 A
B、只能输出6
C、分别用两行输出5和6
D、只能输出5
158..下面属于定义类方法的是(B)
A、public void print(){}
B、public static void print(){}
C、public final void print(){}
D、final void print(){}
159..下列程序的运行结果是(C)
public class School {
public static int x = 10;
public static void print(){
x++;
System.out.println(x);
}
public static void main(String[] args){
School s = new School();
s.print();
}
}
A、编译错误
B、10
C、11
D、x
160..关于类方法的描述正确的是(A)
A、类中被static修饰的方法叫类方法;
B、类方法不可以使用对象名.方法名()的形式调用;
C、普通方法可以使用类名.方法名()的形式调用;
D、类方法只能使用类名.方法名()的形式调用;
161..关于类方法的描述不正确的是(D)
A、被static修饰的方法叫类方法;
B、类方法可以使用类名.方法名()的形式调用;
29 / 49
C、类方法也可以使用对象名.方法名()的形式调用;
D、类方法只能使用类名.方法名()的形式调用;
162..关于类的方法说法不正确的是(D)
A、方法返回值必须与方法在定义时的类型匹配
B、方法如果没有返回值，则在定义方法的时候返回值应该说明为void 、方法只有被调用时才能执行 C
D、为了能被调用，方法必须使用public来修饰
163..下面程序中类ClassDemo中定义了一个静态变量sum，分析程序段的输出结果(C) class ClassDemo {
public static int sum=1;
public ClassDemo() {
sum = sum + 5;
}
}
public class ClassDemoTest{
public static void main(String args[]) { ClassDemo demo1=new ClassDemo(); ClassDemo demo2=new ClassDemo(); System.out.println(demo1.sum);
}
}
A、0
B、 6
C、 11
D、 2
164..有一个员工类Emp如下代码:
public class Emp {
private String name;
private int age;
public static int ncount = 81;
public Emp(String name, int age) {
super();
= name;this.age = age;
}
}
类中有几个构造方法(A)
A、1
B、2
C、3
D、没有
30 / 49
165..下列哪种类成员修饰符修饰的变量可以在任意类中访问,(B )
A:protected
B:public
C:default
D:private
166..在Java语言中，哪一个包中的类是java的实用包,( B ) A:ng B:java.util
C:java.io
D:java.applet
167..有一个类B，下面为其构造方法的声明，正确的是( B )。

A:void B(int x) {} B:B(int x) {}
C:b(int x) {} D:void b(int x) {}
168..下面关于类的说法，不正确的是( C )。

A:类是同种对象的集合和抽象B:类属于Java语言中的复合数据类型
C:类就是对象
D:对象是Java语言中的基本结构单位
169..下列程序的运行结果是( C )。

public class X5_1_2 extends x{
int ab(){
static int aa=10;
aa++;
System.out.println(aa);
}
public static void main(String[] args) {
X5_1_2 x=new X5_1_2();
x.ab();
}
}
A:10
B:11
C:编译错误
D:运行成功，但不输出
170..区分类中重载方法的依据是( A )。

A:形参列表的类型和顺序
B:不同的形参名称
C:返回值的类型不同
D:访问权限不同
31 / 49
171..封装是指把对象的( B )隐藏起来，不允许外部直接访问。

A:方法B:属性
C:接口
D:构造器
172..java所有类的根是( D )。

A: Class
B: System
C: Thread
D: Object
173..在Java语言中，不允许使用指针体现出的Java特性是( D) A:可移植 B:解释执行 C:健壮性 D:安全性
下面的程序名为Teacher.java
public class Teacher
{
private String name;
public Teacher(String name) //1
{
= name; //2
}
public static void main(String args[])
{
Teacher s = new Teacher (); //3
}
}
使用如下指令编译:javac Student.java将会得到什么结果,是( B )。

A: 将
会顺利通过编译，并将产生一个Teacher.class的类文件 B: 编译时在//3处出错。