目录
期末考后再补充答案解释Q_Q
最后更新：2019-12-16
---------- ch01-ch02
6. Java源文件必须含有主方法main （错）
解释：一个java源文件当中可以有多个类，但是只能有一个public类 一个类里可以有一个main函数。
7. 假设一个Java源文件中有如下内容，该源文件符合编译器规定（或者说不可以通过编译）（图缺失）（错）
8. 作为Java程序启动入口的main方法必须位于某个public class即公开类中。（错）
解释：一个类里可以有一个main函数，非public的类也可以
10. 一个Java源文件中可以有多个public class（公开类）（错）
解释：只能有一个public类
22. 下面哪些主方法的声明是不正确的：（B）
A. public static void main(String[] args)
B. public void static main(String[] a)
C. public static void mian(String[] a)
D. static public void main(String[] args)
E. public static void main(String args[])
解释：
修饰符（public static）返回值类型 方法名称（参数类型 参数名称，……）{
方法体
return 返回值；
}
23. 假如要用一个变量来保存我们学校的学生的学号值，应该使用下面哪些类型?(D)
A. byte B. int C. class D. long
解释：
学号长度：201910214xxx（十进制12位），从长度上看选择long才合适。
- byte属于Java中的整型，长度为1字节8bit，取值10000000（-128）到 01111111（127），变量初始化默认值为0，包装类Byte。
- short属于Java中的整型，长度为2字节16bit，取值10000000 00000000（-32768）到 01111111 11111111（32767），变量初始化默认值为0，包装类Short。
- int属于Java中的整型，长度为4字节32bit，取值-2^31 （-2,147,483,648）到 2^31-1（2,147,483,647），变量初始化默认值为0，包装类Integer。
- long属于Java中的整型，长度为8字节64bit，取值-2^63 （-9,223,372,036,854,775,808）到 2^63-1（9,223,372,036,854,775,8087），变量初始化默认值为0或0L，包装类Long。
24. 下面哪个不是Java语言中的关键字(B)
A. byte B. java C. class D. public
解释：关键字就那几个，记住就好。（java的源文件后缀名是java，java里没有java这个关键字）
25. 下列语句执行后，打印内容是（D）
int a = 9;
a += (a = 3);
System.out.println(a);
A. 3 B. 6 C. 9 D. 12
运行结果：
解释： a += (a = 3) 等价于 a = a + (a = 3)，java是从左到右运算的，那么相加的后一位a = 3赋值运算其实就没什么作用了（IDEA也帮我提示了），如果相加的两个顺序颠倒一下，那么结果就不一样了：因为a被赋值了，后来相加的a是用 上一步赋值的值来计算的。
31. int a =0; a = a++; 问最后a = ( 0 ).
解释：
a++特点是：先运算后自增，运算后a的值为0，然后a再自增，结果是1才对。实际运行却不是的。
具体深入研究，请看看yuge1123的博客有趣的面试题 int a = 0; a = a++;（点击查看）
35. 以下语句执行后
a的值为（ 2 ），b的值为（ 3 ）
int x, a = 4, b = 2, c = 5;
x c = a = b++;
解释：结合Java运算符相关的知识，可以知道运算顺序是：
x的初始值为0，a的初始值为4，b的初始值为2，c的初始值为5。
b的值赋予a，a的值变为2。
a的值赋予c，c的值变为2。
c的值赋予x，x的值变为2。
开始b++，b的值变为3。
打印a ， b的值，结果分别为2 和 3
---------- ch03
1. 使用System.Out这个标准输出流对象来输出（错）
解释：System是java.lang里面的一个类，类里的out是静态字段，是java.io.PrintStream类的对象。
4. Java中常量没有类型（错）
解释：常量是指在程序的整个运行过程中值保持不变的量。在这里要注意常量和常量值是不同的概念，常量值是常量的具体和直观的表现形式，常量是形式化的表现。通常在程序中既可以直接使用常量值，也可以使用常量。常量不同于常量值，它可以在程序中用符号来代替常量值使用，因此在使用前必须先定义。常量与变量类似也需要初始化，即在声明常量的同时要赋予一个初始值。常量一旦初始化就不可以被修改。它的声明格式为：
// Java 语言使用 final 关键字来定义一个常量
// 其语法如下所示：
final dataType variableName = value
其中，final 是定义常量的关键字，dataType 指明常量的数据类型，variableName 是变量的名称，value 是初始值。
详细点击：Java常量：Java常量的定义和分类
7. 强制类型转换，会把高位字节丢失，只留下低位字节，所以会造成数值位丢失。（错）
解释：低精度数据类型转换成高精度数据类型，数据不丢失。但是高精度数据类型转换成低精度数据类型就有出现有效位数低位数据丢失（将出现逻辑错误）、范围的高位溢出（将出现异常）问题的风险。
详细点击：
14. 6+5%3+2的值是（ D ）
A. 2 B. 1 C. 9 D. 10
解释：比较简单，%是求余运算，5%3得2, 原式 = 6+2+2=10
15. 下面的逻辑表达式中合法的是（ C ）
A. (7+8)&&(9-5) B. (9*5)||(9*7)
C. 9>6&&8<10 D. (9%4)&&(8*3)
解释：&& 和 || 是逻辑运算，表达式两边要是布尔值的运算，故ABD错，C对。
17. 假设int a = 3,b = 2,c = 1;以下语句正确的是（ D ）
A. c=c/float(a/b) B. c=c/((float a)/b)
C. c=(float)c/(a/b) D. c= c/(int)(a/(float)b)
解释：数据类型转换问题，java中的数学计算要求数据的类型一致。
18. Java表达式2^3&5的值是（ C ）
A. 1 B. 2 C. 3 D. 5
解释：^是异或运算，&是与运算。都针对二进制运算。2的二进制是010，3的二进制是011，5的二进制是111
010 ^ 011得011，011&111得011，011的十进制为3。
19. 假设有关变量都已经定义和赋值，则下列正确的语句有（ B ）
A. long lv = i*3+4.5; B. long xl = 10;
C. int x = 87L； D. byte i = 289;
解释：数据类型不匹配问题。
A选项，4.5是double的数据类型，不能从double转换成long类型，编译不通过，A错；
B选项没问题；
C选项，87L是long的数据类型，不能隐式从long转换成int类型，编译不通过，如果需要转换则要显式转换，C错；
D选项，289是int的数据类型，超出byte数据范围，而且不能隐式从int转换成byte类型，编译不通过，如果需要转换则要显式转换，D错；
改错后：
25. 下列语句序列执行后，ch1的值是（ B ）
char ch1 = 'A',ch2 = 'W';
if(ch1 + 2 < ch2) ++ch1;
A. 'A' B. 'B' C. 'C' D. 'W'
解释：
字符类型的运算，涉及背后的编码规则的知识点。
在ASCII码中， 字母对应的数字是：A-Z 65-90， a-z 97-122。
java中也是可以字符+数值的，java也是会自动类型转换的（由低到高，成为隐式转换），相加过程中会将char型先转int型然后相加。 如果由高到低类型的转换就得强转（称为显式转换）。
26. 下列语句序列执行后，i的值是（ D ）
int i = 8, j = 16;
if(i - 1 > j) i--; else j--;
A. 15 B. 16 C. 7 D. 8
解释：计较简单 ，跟着运算一下就可以了。不管--i和i--，++i和i++结果都一样是8，因为if里的判断条件都不符合，没有进入if的运算= =。
29. 以下字符常量中不合法的是（ C ）
A. '|' B. '\' C. "\n" D. '我'
解释：答案应该是B吧，\是转义符，要表示\的字符串常量应该是这么写的 "\\"
37. int a = 4; a = a++; 问 最后a=（ 4 ）
解释：请看ch01-ch02的第31题 ，一样的。
38. 下列语句序列执行后，i的值是（ -1 ）
int i = 10;
do{i /= 2;} while(i-- > 1);
解释：认真运算一遍吧，int运算后会把小数点后的数值省去，在做完while判断后自减。
39. 下列语句序列执行后，j的值是（ 15 ），i的值是（ -1 ）
int j = 1,i;
for(i = 5; i > 0; i -= 2) j *= i;
解释：比较简单。
---------- ch04
2. for语句的循环体中还可以出现while语句（对）
解释：for循环体里面可以嵌套循环。
3. while（true）{/*省略部分代码*/}这样的while语句也一定是死循环。（错）
解释 ：反例 - 我在循环体里面添加break语句不久结束循环了吗。。。
10. 在多重循环嵌套语句中，内层循环中的break语句可以跳出最外层的循环。（错）
解释：多重循环嵌套语句中，内层循环中的break语句会跳出当前的循环体。
12. 有如下一个程序段，执行完之后打印内容是：（B）
outer：
for（int i = 0; i < 3; i++）
inner:
for(int j = 0; j < 2; j++){
if(j == 1) continue outer;
System.out.println(j+" and "+ i +";")
}
A.0 and 0;0 and 1;0 and 2; B. 0 and 0;1 and 0;2 and 0;
C.1 and 0;1 and 1;1 and 2; D. 2 and 0;2 and 1;2 and 2;
解释：
实际运行是A。
这个答案不对吧，质疑。
15. 下面代码段，哪一行会出现编译错误 ( D )
ststic void deal(){ //ln1
int i, j, k; //ln2
i = 100; //ln3
while(i-- > 0){ //ln4
j = i * 2; //ln5
System.out.println("j=" + j);//ln6
k = k+ 1； //ln7
}
}
A.Ln1 B.Ln4 C.Ln5 D.Ln7 E.其他
解释：k声明了，但未分配内存空间，不能计算。编译错误。
27. 若有循环：
int x =5, y=20;
do{y -= x; x += 2;} while{x < y};
则循环体将被执行（A）
A. 2次 B. 1次 C. 0次 D. 3次
解释：do...while...语句先执行后判断是否满足条件。第一次循环后x=7，y=15，不满足x<y。第二次循环后x=9，y=8，满足x<y，跳出循环体，因此总共循环两次。
29. 下列循环中，执行break outer 语句后，所列（C）语句将被执行。
outer:
for(int i = 1; i <10; i++){
inner:
for(int j = 1; j < 10; j++){
if(i * j > 50) break outer;
System.out.println(i * j);
}
}
next:
A.标号为inner的语句 B.标号为outer的语句
C.标号为next的语句 D.以上都不是
解释：break outer语句后，跳出outer的循环体，接着下一个语句的执行。
---------- ch05
1. 构造方法不是成员方法（错）
解释：构造函数：是特殊的成员方法，他的作用是创建对象并初始化成员变量。
4. 类其实是一种数据类型。（对）
解释：“类”是一种数据类型；一个类的值称为对象。
10. 非构造方法的一般成员方法必须要有return语句。（错）
解释：一个方法可以没有返回值，即返回类型为 void，像 main() 方法。
13. 设置器方法，即setter类方法一定是无返回值的，即必须定义为void setXxx(…)这样的形式。（错）
解释：设置器方法会改变数据的值，但是对返回值没有严格要求，可以没有返回值，也可以有返回值，比如设置返回布尔值。
14. 访问器方法，即getter类方法一定不需要使用形式参数。（错）
解释：访问器方法可以获取数据的值，但是对形式参数没有严格要求，可以有形参。
19. 下面这个类定义正确。(对)
public class Student{
int sno = 123;//学号
// 构造方法
public Student(int i){ sno = i;}
public int Student(){return sno;}
}
解释：参考资料：Java对象和类
21. 下面这个类有几个构造方法？（B）
class A{}
A.0 B. 1 C.2 D. 该类定义错误
解释：没有定义类构造方法，那么默认无参构造方法。
24. 下面这个类有（ A）个构造方法。
A. 3 B.4 C.5 D.6
public class A{
private int a, b, c, d;
A(){}
void A(){}
public void A(int _a){
}
protected A(int _b){
}
private A(int _a, int _b){
}
private int A(byte x){
return 1;
}
}
解释：
Java 构造方法有以下特点：
- 方法名必须与类名相同
- 可以有 0 个、1 个或多个参数
- 没有任何返回值，包括 void
- 默认返回类型就是对象类型本身
- 只能与 new 运算符结合使用
注意：构造方法不能被 static、final、synchronized、abstract 和 native（类似于 abstract）修饰。构造方法用于初始化一个新对象，所以用 static 修饰没有意义。构造方法不能被子类继承，所以用 final 和 abstract 修饰没有意义。多个线程不会同时创建内存地址相同的同一个对象，所以用 synchronized 修饰没有必要。
参考资料：Java构造方法
27. 以下那个类声明是正确的（ D ）。
A.public int A1{…}
B.public class TT(){}
C.public class int Show{}
D.public class CD{}
解释：请看24题解释里的Java构造方法的特点。值得注意的是，如果为构造方法定义了返回值类型或使用 void 声明构造方法没有返回值，编译时不会出错，但 Java 会把这个所谓的构造方法当成普通方法来处理。
33. 已知Integer in = 1;则表达式in instanceof Integer的结果为（ A ）
A.true B.false C.1 D.0
解释：instanceof 严格来说是Java中的一个双目运算符，用来测试一个对象是否为一个类的实例。Integer是int的包装类，int则是java的一种基本数据类型。Integer实际是对象的引用，当new一个Integer时，实际上是生成一个指针指向此对象；而int则是直接存储数据值 。
19. 下列代码的执行结果是（A）
public class Test{
public int aMethod(){
static int i = 0; //java:非法的表达式开始
i++;
System.out.println(i);
return i;
}
public static void main(String args[]){
Test test = new Test();
test.aMethod();
}
}
A.编译错误 B.0 C.1 D.运行成功，但不输出
解释：编译错误，非法的表达式开始。静态变量又叫类变量，只能在类内部，方法体外部定义。
static是不属于方法的，是属于一个类的，
是在类加载的时候执行的（也就是初始化），
而方法则是在类实例化的时候才开始执行，
在方法里定义static当然行不通了。参考资料：在方法中为什么不能定义static变量?
48. （题略） 其中含有主方法的字节码文件名（包括扩展名）是（ Class1.class ）
---------- ch05编程题
我的答案，仅供参考，老师没批改
public class Flower{
private String category;
private String name;
private String color;
public String getCategory() {
return category;
}
public void setCategory(String category) {
this.category = category;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
public Flower(String name, String category, String color){
this.category = category;
this.name = name;
this.color = color;
}
public Flower(String name, String category){
this(name, category, "红色");
}
public Flower(){
this(null,null);
}
void desccripe(){
System.out.println("花名:"+getName());
System.out.println("类别:"+getCategory());
System.out.println("颜色:"+getColor());
}
public static void main(String[] args){
Flower flower1 = new Flower("菊花","菊科菊属宿根草本植物","红、黄、白");
Flower flower2 = new Flower("玫瑰","蔷薇目");
Flower flower3 = new Flower();
flower1.desccripe();
flower2.desccripe();
flower3.desccripe();
flower3.setName("紫荆花");
flower3.setCategory("豆科紫荆属");
flower3.setColor("紫红色");
flower3.desccripe();
}
}---------- ch06
2. 非构造方法必须要有返回值。（错）
4. 只能在类里面调用方法。 （错）
13. 成员变量不经初始化，就可以使用。因为它们声明和定义时会有默认值进行初始化。（对）
15. 实例变量只能是成员变量。（对）
22. 下列构造方法的调用方式中，正确的是( C )。
A.按照一般方法调用
B.由用户直接调用
C.只能通过 new 自动调用
D.被操作系统调用
23. 下面程序第几行（第一列的#.是行号）有错？(D)
1public class Test{
2 int m,n;
3 pubilc Test(){}
4 public Test(int a) {m = a;}
5 public static void main (String[] args){
6 Test t1, t2;
7 int j, k;
8 j = 0; k = 0;
9 t1 = new Test();
10 t2 = new Test(j, k);
11 }
12}
A.第 3 行 B.第 5 行 C.第 6 行 D.第 10 行
24. 为AB类的一个无形式参数无返回值的方法method书写方法头，使得使用类名AB作为前缀就可以调用它，该方法头的形式为（ A ）
A.static void method( )
B.public void method( )
C.final void method( )
D.abstract void method( )
27. 在调用方法时，若要使方法改变实参所引用内容的值，可以：(B)
A.用基本数据类型作为参数
B.用对象作为参数
C.A和B都对
D.A和B都不对
28. 类Test1定义如下：
public class Test1{
public float aMethod(float a, float b){}
}
将以下哪个方法放入该类是不合法的。（ B ）
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){}
34. 关于方法内定义的变量，下面描述正确的有（ B ）
A.一定在方法内所有位置可见
B.可能在方法内的局部位置可见
C.在方法外可以使用
D.在方法外可见
---------- ch07
3. 数组元素类型可以是任意类型。（错）
解释：数组（array）是一种最简单的复合数据类型，它是有序数据的集合，数组中的每个元素具有相同的数据类型，可以用一个统一的数组名和不同的下标来确定数组中唯一的元素。故该描述错误。
9. Java中数组可以动态改变长度。（对）
解释：实例化后，数组的大小是固定的。可以改为使用列表ArrayList，它是Java中许多非常有价值的Collections之一。
15. 假设a是含有10个元素的int型数组变量;则下列语句是正确的：（对）
for(int a : a) System.out.println(a);
解释：这道题要的答案要质疑一下。
foreach里的语句是不对的，报错：Duplicate local variable a
如果改成for(int b,a) System.out.println(b)就没问题。
16. 有int[] a = {1, 2, 3};下列哪个语句能将其中的元素值累加1。（A）
A.for(int n : a) n++;
B.for(int i = 0; i < a.length; a[i++]++);
C.for(int i = 0; i < a.length; a[++i]++);
D.for(int i = 0; i < a.length; a[i]=a[i]++);
解释 ：A表示的意思是遍历所有元素，执行n++也就是元素值加1的运算，A正确。
B要质疑，B表示的意思是从0下标开始遍历到结尾，每次循环体结束运算之后，执行a[i++]++，由运算符的运算顺序可以知道a[i++]++表示每次在该数组元素下吧元素值加1，然后指向下一个数组元素。
C和B很像，差别在循环体结束后的语句a[++i]++，这句表示的意思是在循环体开始运算之前执行++i的运算，在寻话题结束之后执行a[++i]++的运算，在i到结尾后，即将进入循环体运算的时候，执行了i++，于是数组里的下标就超出了数组的最大范围，出现了溢出的异常。即使最后没有异常，也并没有全部元素值加1，因为第一个元素跳过去了。故C错误
D出现了死循环。。。因为循环体之后的i值没有变换，一直在第一个循环里转啊转，但如果每一次循环体结束，将i值自增1，a的元素值也并没有加1，因为这个类似 j = j++的运算，j并没有被自增后的值再被赋值，而是会被原来的值覆盖，这个问题以前的作业也有遇过。
18. 已知如下代码段，最后a中的元素值是（A）.
int[] a = {1, 2, 3};
for(int i = 0; i < a.length; i++){
a[i++]++;
}
A.{2,3,4} B.{2, 3, 3} C.{2,2,4} D.{2, 2, 3}
解释 ：理解上一题，是类型题来的，不过答案要质疑，实际结果是C。for循环的意思是从a数组头下标的i为0开始遍历到结尾，循环体结束之后执行a[i++]++和i++的操作，从运算顺序可以知道，是先数组元素自增，然后是下标自增，下标i自增（步数为1）运算了两次，所以它是这么算的a[0]自增，a[2]自增。如果将数组a的元素增多验证一下，也满足。
19. 执行完以下代码int[] x = new int[10];后，以下哪项说明是正确的（B）
A．x[9]为0 B．x[9]未定义
C．x[10]为0 D．x[0]为空
解释 ：在 Java 中可以使用 new 关键字来给数组分配空间。int[] x = new int[10];表示声明数组并分配了内存空间。Java 语言中数组必须先初始化，然后才可以使用。所谓初始化，就是为数组的数组元素分配内存空间，并为每个数组元素赋初始值。能不能只分配内存空间，不赋初始值呢？不行，一旦为数组的每个数组元素分配了内存空间，每个内存空间里存储的内容就是该数组元素的值，即使这个内存空间存储的内容为空，这个空也是一个值（null）。不管以哪种方式来初始化数组，只要为数组元素分配了内存空间，数组元素就具有了初始值。初始值的获得有两种形式，一种由系统自动分配，另一种由程序员指定。
所以x[0]和x[9]的值为null，x[9]未定义，x[10]没有分配内存空间，不能访问。
参考资料：Java一维数组的定义、赋值和初始化
1~4题目背景：【较难】
已知一个方法varSum，它接收一个int型可变长度参数v，方法体实现对这若干个参数求和，并把实际参数个数和与求和结果作为一个含两个元素的int型数组返回。实现该方法的整体程序如下：
/* 程序I */
public class Test2 {
public static int[] varSum(int...v){
int[] r = { /*【1】*/ };
/*【2】*/; //
/*【3】*/;
}
public static void main(String[] args) {
int[] a = varSum(1, 2, 3, 4);
System.out.printf("len=%d,sum=%d", a[0], a[1]);
}
}
打印结果如下：
len=4,sum=10
请分别完成注释【1】~【3】的空（注意所有空都填最简单的最少字符的成分，需要引入的变量用e表示，用其他匹配失败不给分！）：
1. 请问【1】应该填什么？【答题提示：编译能通过的10个字符；不要有多余的空格，否则系统匹配不给分，若需要引入变量请用e表示。】（v.length,0）
2. 请问【2】应该填什么？【答题提示：编译能通过的19个字符；不要有多余的空格，否则系统匹配不给分，若需要引入变量请用e表示。】（for(int e:v)r[1]+=e）
3. 请问【3】应该填什么？【答题提示：编译能通过的8个字符；不要有多余的空格，否则系统匹配不给分，若需要引入变量请用e表示。】（retrun r）
4. 可以看出，可变长度参数背后的本质就是（数组）.【答题提示：填两个汉字】
---------- ch08
2. 包名可以大写(对)
5. 一个Java文件如果用到了其它包的类，就必须使用import语句。（错）
10. 所谓的包访问权限使用package关键字修饰。（错）
19. 在创建对象时必须（C）
A．先声明对象，然后才能使用对象
B．先声明对象，为对象分配内存空间，然后才能使用对象
C．先声明对象，为对象分配内存空间，对对象初始化，然后才能使用对象
D．上述说法都对
20. 关于以下程序代码的说明正确的是（ D ）
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．}
A．5行不能通过编译，因为引用了私有静态变量
B．10行不能通过编译，因为x是私有静态变量
C．程序通过编译，输出结果为：x=103
D．程序通过编译，输出结果为：x=102
22. 假设A类有如下定义，设a是A类的一个实例，下列语句调用哪个是错误的？（C）
class A {
int i;
static String s;
void method1() { }
static void method2() { }
}
A.System.out.println(a.i); B.a.method1();
C.A.method1(); D.A.method2();
23. 关于被私有访问控制符private修饰的成员变量，以下说法正确的是（C）
A．可以被三种类所引用：该类自身、与它在同一个包中的其他类、在其他包中的该类的子类
B．可以被两种类访问和引用：该类本身、该类的所有子类
C．只能被该类自身所访问和修改
D．只能被同一个包中的类访问
31~33题
下面是一个类的定义,根据题目要求回答以下问题
class B{
private int x;
private char y;
public B(int i,char j){
x=i; y=j;
}
public void show(){
System.out.println("x="+x+";y="+y);
}
public void methodC(int x){
this.x=this.x + x;
y++;
show();
}
}
31. 声明和定义类B的一个对象b，将类中的变量x初始化为10、变量y初始化为'A'，请写出相应的语句（应该提供;结尾）。【答题提示：半角字符，不需要多余的空格，否则系统匹配失败给零分】（B b=new B(10,'A');）
32. 若在问题31基础上有方法调用语句：b.show(); 则输出如何？【答题提示：半角字符，不需要多余的空格，否则系统匹配失败给零分】（x=10;y=A）
33. 若在问题31基础上增加语句: b.methodC(1); 则输出为何？【答题提示：半角字符，不需要多余的空格，否则系统匹配失败给零分】（x=11;y=B）
---------- ch09
8. 枚举的序数值都是从0开始。（错）
9. 静态方法中不能有非静态的局部变量。（对）
19. 阅读代码，四个叙述中正确的是（B）
class A{
private int x;
public static int y;
public void fac(String s){System.out.println(s);}
}
A.x、y和s都是成员变量
B.x是实例变量、y是类变量，s是局部变量
C.x和y都是实例变量、s是参数
D.x、y和s都是实例变量
26~28题
有两个程序，分别在下面两个框中描述。
/* 第一个程序 Student.java*/
package zhku.pac1;
public class Student {
public int sno = 123456;
}
/* 第二个程序的第一种写法 B1.java，不完整，需要补充完整并让它通过编译并执行 */
package zhku.pac2;
import static java.lang.System.*;
public class B1 {
public static void main(String[] args) {
out.println(new 【1】 Student().sno);
}
}
26. 请问【1】应该填什么才能让B1.java编译正确并执行？（zhku.pac1.）
---------- ch010
>_< 没有在规定时间完成作业，也没得补做，因为禁止迟交
---------- ch011
1. Java支持多重继承。（错）
4. 不能在子类的非static方法中使用super关键字。（对）
11. final修饰的成员方法只是不想让子类重写。（对）
16. Java语言的类间的继承关系是(B)
A.多重的 B.单重的 C.线程的 D.不能继承
17. 以下关于Java语言继承的说法正确的是(C)。
A.Java中的类可以有多个直接父类
B.抽象类不能有子类
C.Java中的接口支持多继承
D.最终类可以作为其它类的父类
22. 有如下程序，有关该程序的说法和输出正确的是（A）
private class B {
B() {
int i = 1;
System.out.print(i);
}
}
public class P extends B {
static int i = 2;
public static void main(String argv[]) {
P p = new P();
System.out.print(i);
}
}A.编译错误 B.2 C.12 D.1
26~29题
已知有如下程序段：
class A {
String s = "A";
void show(){ System.out.println(s); }
}
class B extends A {
String s = "B";
void show(){ System.out.println(s); }
}
public class TypeConvert {
public static void main(String args[]) {
B b1, b2 = new B();
A a1, a2;
a1 = (A) b2;
a2 = b2;
a1.show(); // [1]
a2.show(); // [2]
b1 = (B) a1;
b1.show(); // [3]
b2.show(); // [4]
}
}执行后，注释[1]~[4]行分别输出什么（回车换行忽略）？
26. 注释[1]行输出（ B）
27. 注释[2]行输出（B）
28. 注释[3]行输出（B）
29. 注释[4]行输出（B）
30. 假如让上述程序强行执行，则会抛出异常，异常内容提示中有一行这样的显示：
Cannot 【1】 the type ATest
请问上面的【1】处应该是一个什么单词？(instantiate)
33~35题
已知有如下程序段：（不可复制）
33. 这个程序输出的son有（3）个.【答题提示：填数字】
34. 注释[3]行输出的（4）.
35. 注释[6]行输出的（son）.
---------- ch012
1.接口也是一种类型。(对)
解释：接口（英文：Interface），在JAVA编程语言中是一个抽象类型，是抽象方法的集合，接口通常以interface来声明。
接口并不是类，编写接口的方式和类很相似，但是它们属于不同的概念。类描述对象的属性和方法。接口则包含类要实现的方法。
6.接口只能被具体类实现。（错）
解释：接口无法被实例化，但是可以被实现。接口可以由具体类实现，也可以由抽象类实现。一个类通过继承接口的方式，从而来继承接口的抽象方法。一个实现接口的类，必须实现接口内所描述的所有方法，否则就必须声明为抽象类。
9.抽象类不可以实现接口。（错）
解释：参考第8题。
12.下列说法中，正确的是(A)
A.类是变量和方法的集合体
B.数组是无序存储的数据的集合
C.抽象类可以实例化
D.类成员数据必须是公有的
解释：A. 说法正确 B. 数组是用来存储固定大小的同类型元素。B错误。 C. 抽象类除了不能实例化对象之外，类的其它功能依然存在。C错误。 D. 类成员可以是public、protected、package或者private的权限，不是必须公有的。D错误。
18.有以下程序，说法正确的是(B).
A.func B.编译错误 C.执行异常 D.以上都不对
解释：【多态】
多态存在的三个必要条件：
继承、重写、父类引用指向子类对象
编译提示说func()在A中没有定义。
当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误；如果有，再去调用子类的同名方法。
因为声明的是接口A，接口是对象之间的一个合约，外部的对象只能够调用接口提供的发方法，A中没有func()方法。
实例化的是B，尽管B中有这个A所没有的新的方法，但是因为A中没有定义这个方法，所以编译出错了。如果外部对象想调用接口中没有提供到的方法，可以强转为子类或者在接口中添加该方法-使得两者之间为“is-a”的关系。
29~30题
已知有如下接口和类，请完成后面的问题。
29.[2]处应该填写什么样的字符序列成分，程序才能正常编译并执行。保留必要的空格，去除不必要的空格。【答题提示：先不管代码风格。使用含有最少字符数的语句让编译通过。否则系统匹配不给分】（public void move()）
30.匿名类：A、要么继承一个类；B、要么实现一个接口。请问上面注释[3]处的匿名类是哪种实现方式？（填A或B或AB）（A）
解释：【内部类和匿名类】
29. 下文的m1.move();语句可知IMove类有move方法，内部类外部调用该类方法，所以要用public修饰，没有返回值，所以要用void修饰。 30. 利用父类的构造函数和自身类体构造成一个类。
扫一扫
3092
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
