零基础入门到精通I课后测试（Part 1）

(I 01,02)开篇,基本语言构成（共10题）
Java所定义的版本中，不包括（） 2 Points
○A.JavaEE
●B.JavaHE
○C.JavaME
○D.JavaSE
Correct Answer（+2 Points）
变量命名规范说法正确的是（） 2 Points
○A.变量由字母，下划线，数字，$符号随意组合
●B.变量不能以数字作为开头
○C.A和a在Java中是同一个变量
○D.不同类型的变量，可以起相同的名字
Correct Answer（+2 Points）
下列叙述中，正确的是（） 2 Points
●A.Java语言的标识符是区分大小写的
○B.源文件名与public类名可以不相同
○C.源文件扩展名为.jar
○D.源文件中public类的数目不限定义
Correct Answer（+2 Points）
下列JavaDOC注释正确的是（） 2 Points
○A. /阿拓老师很帅/
○B. //阿拓老师很帅/
●C. /**阿拓老师很帅/
○D. /阿拓老师很帅/
Correct Answer（+2 Points）
执行语句int a = ‘2’后，a的值是（） 2 Points
○A.2
●B.50
○C.49
○D.0
Correct Answer（+2 Points）
在Java语言中，下列运算符合法的是（） 2 Points
●A. &&
○B. <>
○C. ===
○D. :=
Correct Answer（+2 Points）
下面哪个选项在编译时不会出现错误或警告（） 2 Points
○A.float f=1.3;
●B.char c=’a’;
○C.byte b=200;
○D.boolean b=1;
Correct Answer（+2 Points）
十进制16的十六进制表示形式是（） 2 Points
●A.0X10
○B.0X16
○C.0XA
○D.016
Correct Answer（+2 Points）
若下列所用变量均已经正确定义，以下表达式中不合法的是（） 2 Points
○A.x>>3
●B.+++j
○C.a=x>y?x:y
○D.x%4
Correct Answer（+2 Points）
为一个boolean类型变量赋值时，可以使用（） 2 Points
○A.boolean = 1;
●B.boolean a = (9>=10);
○C.boolean a = “真”;
○D.boolean a == false;
Correct Answer（+2 Points）
(I 03)基础语法（共10题）
以下程序的运行结果是（）
public class Increment{
public static void main(String[] args){
int a;
a = 6;
System.out.println(a);
System.out.println(a++);
System.out.println(a);
}
}
2 Points
○A. 666
●B. 667
○C. 677
○D. 676
Correct Answer（+2 Points）
以下代码，执行结果为（）
public class Test{
public static void main(String[] args){
char c = 65;
System.out.println(“c = “ + c);
}
}
2 Points
○A. c = 65
●B. c = A
○C. 编译错误
○D. 执行错误
Correct Answer（+2 Points）
在Java中下列关于自动类型转换说法正确的是（）【多选题】 5 Points
●A. 基本数据类型和String相加结果一定是字符串型
○B. char类型和int类型相加结果一定是字符
○C. double类型可以自动转换为int
●D. char + int + double结果一定是double
Correct Answer（+5 Points）
下列输出结果是（）
int a = 0;
while(a<5){
switch(a){
case 0 :
case 3 : a = a + 2;
case 1 :
case 2 : a = a + 3;
default : a = a + 5;
}
}
System.out.println(a); 2 Points
○A. 0
○B. 5
●C. 10
○D. 其他
Correct Answer（+2 Points）
以下代码，执行结果为（）
public class IfTest{
public static void main(String[] args){
int x = 3;
int y = 1;
if(x=y)
System.out.println(“不相等”);
else
System.out.println(“相等”);
}
}
2 Points
○A.不相等
●B.相等
○C.第五行代码会引起编译错误
○D.程序正常执行，但没有任何输出结果
Wrong Answer（+0 Points）
Correct Answer:
C.第五行代码会引起编译错误
解析：= 是赋值运算符 == 是比较运算符，if语句括号中（）必须是Boolean型，因此第五行代码会引起编译错误。
拓展： Java中0 1 不能和true false转化。
public static void main(String [] args){
int x = 5;
boolean b1 = true;
boolean b2 = false;
if((x == 4) && !b2)
System.out.print(“1 “);
System.out.print(“2 “);
if((b2 = true) && b1)
System.out.print(“3 “);
}
上述程序的执行结果是（） 2 Points
●2
○3
○1 2
○2 3
Wrong Answer（+0 Points）
Correct Answer:
2 3
解析：if 不带大括号，若满足条件只执行if后的一条语句，题中第一个if 中x == 4 为false，其后的第一条打印语句不执行，第二条打印语句顺序执行，此时打印输出2，第二个if b2赋值true，b1为true，短路与前后均为true，if 条件满足执行打印输出3，因此最终结果为2 3
下列代码输出结果是（）
int i = 10;
while(i > 0){
i = i++;
if(i == 10){
break;
}
} 2 Points
○A.while循环执行10次
○B.死循环
●C.循环一次都不执行
○D.循环执行一次
Wrong Answer（+0 Points）
Correct Answer:
D.循环执行一次
解析：i 初始值为10，i = i++语句执行过程为i 在内存空间里先备份一个原值（10），在进行自增最后将备份空间中i的原值重新赋值回来，因此结果为10，满足if 条件执行break语句，循环执行一次。
下面代码输出结果是（）
int i = 0,s = 0;
do{
if(i%2 == 0){
i++;
continue;
}
i++;
s = s + i;
}while(i < 7);
System.out.println(s); 2 Points
○A. 16
○B. 12
○C. 28
●D. 21
Wrong Answer（+0 Points）
Correct Answer: **
B. 12
解析：第一次循环：0 可以对2取余（0 % 2）结果为0，if 满足条件 i自增此时i =1，s = 0；第二次循环：i = 2，s = 2；第三次循环：if 满足条件 i= 3，s = 2；第四次循环：i = 4，s = 6；第五次循环：if 满足条件i = 5，s = 6；第六次循环：i = 6，s = 12；第七次循环：if满足条件i = 7，s = 12；此时循环不满足条件，输出打印s为12。
拓展：continue 语句执行结果为：结束本次循环，若满足条件执行下次循环，不满足则循环结束。
代码如下，运行结果是（）
public static void main(String[] args) {
int i = 1;
int j = 1;
for(;i<=5;){
for(;j<=5;){
if(j==3){
break;
}
System.out.print(j++);
}
i++;
}
System.out.print(“-“);
System.out.print(i);
System.out.print(j);
} 2 Points
○A.1212121212-63
○B.1212121212-66
●C.12-63
○D.12-66
Correct Answer（+2 Points）
Given:
public class Breaker2{
static String o = “”;
public static void main(String[] args){
z:for(int x = 2; x < 7; x++){
if(x==3)
continue;
if(x==5)
break z;
o = o + x;
}
System.out.println(o);
}
}
What is the result? 2 Points
○A.2
●B.24
○C.234
○D.246
Correct Answer（+2 Points）
(I 04)数组（共10题）
以下代码能够正确初始化(或默认初始化)数组的是（） 2 Points
○A. int[] a;
○B. a = {1,2,3,4,5};
○C. int[] a = new int[5]{1,2,3,4,5};
●D. int[] a = new int[5];
Correct Answer（+2 Points）
定义了一维int型数组a[10]后，下面错误的引用是（） 2 Points
○A.a[0] = 1;
○B.a[0] = 52;
●C.a[10] = 2;
○D.a[1] = a[2] a[0];
Correct Answer（+2 Points）
当访问无效的数组下标时，会发生（） 2 Points
○A.终止程序
●B.抛出异常
○C.系统崩溃
○D.直接跳过
Correct Answer（+2 Points）
关于数组默认值，错误的是（） 2 Points
○A.String—null
●B.Boolean—true
○C.float—0.0f
○D.int—0
Correct Answer（+2 Points）
执行完代码”int[] x = new int[25];”后，以下说法正确的是（） 2 Points
●A.x[24]为0
○B.x[24]未定义
○C.x[25]为0
○D.x[0]为null
Correct Answer（+2 Points）
代码如下，选项说法正确的是（）
public class ArrayTest {
public static void main(String[] args) {
int fl[], f2[];
fl = new int[10];
f2 = fl;
System.out.println(“f2[0]=” + f2[0]);
}
} 2 Points
○A.打印f2[0]=0
○B.打印f2[0]=NaN
●C.第3行会产生编译时异常
○D.第5行会产生编译时异常
Wrong Answer（+0 Points）
Correct Answer:
A.打印f2[0]=0
解析：代码执行过程为：int f1[],f2[] ,在栈内存空间定义两个数组变量f1,f2；fl = new int[10]，在堆内存空间开辟10个地址连续的空间，f1变量中存放的是该空间的引用；f2 = fl，将f1中的地址引用复制一份给f2；因此打印输出的结果为f2[0]=0
下列说法错误的有(多选题) 2 Points
○A.数组是一种对象
●B.数组属于一种原生类
●C.int number = []{31,23,33,43,35,63};
●D.数组的大小可以任意改变
Correct Answer（+2 Points）
下列合法的数组说明语句是（） 2 Points
○A.int a[] = “String”;
○B.int a[5] = {0.1,2,3,4};
○C.char a = “String”;
●D.char a[] = {0,1,2,3,4,5};
Correct Answer（+2 Points）
下面不是创建数组的正确语句的选项是（） 2 Points
○A.float f[][] = new float[6][6];
○B.float []f = new float[6];
○C.float f[][] = new float[][6];
●D.float [][]f = new float[6][];
Wrong Answer（+0 Points）
Correct Answer:
C.float f[][] = new float[][6];
解析：float f[][] = new float[6][6];float []f = new float[6];float [][]f = new float[6][];分别为二维数组，一维数组的标准写法
代码如下，输出结果是（）
public static void main(String[] args) {
int[][] array = new int[3][2];
array[0][0]=1;
array[0][1]=2;
array[1]=array[0];
array[0]=new int[4];
array[0][0]=10;
System.out.println(array[1][0]);
} 2 Points
○A.1
●B.10
○C.0
○D.产生异常
Wrong Answer（+0 Points）
Correct Answer:
A.1
解析：该题中代码执行的底层原理int[][] array = new int[3][2];此时在栈内存中定义一个二维数组array存放堆内存空间新创建的二维数组的地址引用，堆内存中的二维数组存储的是一维数组的地址， array[0][0]=1; array[0][1]=2; 分别将堆内存空间中的索引为0 0 ，0 1的数组赋值为1 2array[1]=array[0]; 将array[0]的地址引用赋值给array[1]，array[0]=new int[4]; array[0][0]=10;在堆内存中开辟出一个新的大小为4的数组空间，并将地址索引赋值给array[0]，因此打印输出的是array[1]新的地址引用指向的数组中的值为1
(I 05)面向对象（共10题）
对象的特征在类中表示为变量结构，称之为（） 2 Points
○A. 对象
●B. 属性
○C. 方法
○D. 数据类型
Correct Answer（+2 Points）
对象的行为在类中表示为函数结构，称之为（） 2 Points
○A. 对象
○B. 属性
●C. 方法
○D. 数据类型
Correct Answer（+2 Points）
以下程序编译运行后的输出结果为（）
public class Test{
public int x,y;
Test(int x,int y){
this.x = x;
this.y = y;
}
public static void main(String[] args){
Test t1,t2;
t1 = new Test(3,3);
t2 = t1;
t2.x = 5;
t2 = new Test(4,4);
System.out.print(t1.x + t2.x);
}
} 2 Points
○A.3 4
●B.5 4
○C.7
○D.9
Wrong Answer（+0 Points）
*Correct Answer:
D.9
解析：代码执行过程，Test t1,t2;t1 = new Test(3,3);在栈内存中定义两个Test类变量，并在堆内存空间构造一个属性为3 3的对象将该地址引用赋值给t1，t2 = t1;t2.x = 5;将t1的地址引用赋值给t2，并修改x属性为5，此时t1的属性x也为5，t2 = new Test(4,4);在堆内存空间构造一个属性为4 4的对象将该地址引用赋值给t2，此时t2的对象空间的属性为4 4，因此输出打印的是5 + 4 由于属性为int整型所以+符号为运算符号，结果为9
在Java中，一个类可同时定义为许多同名的方法.
这些方法的形式参数个数，类型或顺序各不相同
传回的值可能各不相同，这种面向对象的特征称为() 2 Points
○A.隐藏
○B.覆盖
●C.重载
○D.无此特性
Correct Answer（+2 Points）
关于类的叙述正确的是（） 2 Points
○A.在类中定义的变量称为类的成员变量，在别的类中可以直接使用
○B.成员变量的作用范围仅仅是当前类的方法中，或当前类的控制流块中
○C.使用别的类的方法仅仅需要引用方法的名字即可
●D.若类没有定义构造方法，JVM都会为类生成一个默认的无参数构造方法
Correct Answer（+2 Points）
下面哪个选项编译不会出错（）
2 Points

○A.
●B.
○C.
○D.
Correct Answer（+2 Points）
给定Java代码如下所示，在//#处添加哪个选项，不可以构成方法重载（）
public class Test{
public void fun(int x,int y,int z){}
//#
}

2 Points
○A.public int fun(int x,int y,float z){return 0;}
○B.public int fun(char x,int y,int z){return 0;}
○C.public void fun(int x,int z){}
●D.public void fun(int z,int y,int x){}
Correct Answer（+2 Points）
在Java中，关于构造方法，下列说法错误的是（） 2 Points
○A.构造方法的名称必须与类名相同
○B.构造方法可以携带参数
●C.构造方法不可以重载
○D.构造方法没有返回值
Correct Answer（+2 Points）
有以下程序片段且Interesting不是内部类
下列哪个选项不能插入到1.行（）
1.
2.public class Interesting{
3. //#省略代码
4.} 2 Points
○A.import java.util.*;
○B.package mypackage;
○C.class OtherClass{}
●D.public class MyClass{}
Correct Answer（+2 Points）
以下代码的输出结果是?（）
public class B{
public static B t1 = new B();
public static B t2 = new B();
{
System.out.println(“构造块”);
}
static{
System.out.println(“静态块”);
}
public static void main(String[] args){
B t = new B();
}
} 2 Points
○A.静态块 构造块 构造块 构造块
○B.构造块 静态块 构造块 构造块
●C.构造块 构造块 静态块 构造块
○D.构造块 构造块 构造块 静态块
Correct Answer（+2 Points）