Java程序设计基础习题答案

Java程序设计基础课后习题参考答案

第2章

1. 关于Java Application 的入口方法main()的检验：

main()方法的参数名是否可以改变？ main()方法的参数个数是否可以改变？ 该方法名是否可以改变？

参考答案：(1)main()方法的参数名可以改变。(2)main()方法的参数个数不可以改变。(3)该方法名不可以改变。

2. 当一个程序没有main()方法时，能编译吗？如果能编译，能运行吗？ 参考答案：当一个程序没有main()方法是，是可以编译通过的，但是不能给运行，因为找不到一个主函数入口。

3. 下列语句能否编译通过？

byte i = 127; byte j = 128;

long l1 = 999999; long l2 = 9999999999;

参考答案：byte i 和 long l1可以编译通过。而 byte j 和long l2 超出自身数据类型范围，所以编译失败。

4. 下列语句能否编译通过？

float f1 = 3.5; float f2 = 3.5f;

参考答案：java中浮点型的数据在不声明的情况下都是double型的，如果要表示一个数据是float型的，必须在数据后面加上“F”或“f”;因此，float f1 无法编译通过。

5. 验证int 和char，int和double等类型是否可以相互转换。

参考答案：(1)char类型可以转换为int 类型的，但是int类型无法转换为char类型的；(2)int 可以转换为 double类型的，但是double类型无法转换为int 类型的。

6. 计算下列表达式，注意观察运算符优先级规则。若有表达式是非法表达式，则指出不合法之处且进行解释。

(1) 4+5 == 6*2 (2) (4=5)/6 (3) 9%2*7/3>17 (4) (4+5)<=6/3 (5) 4+5%3!=7-2 (6) 4+5/6>=10%2 参考答案：表达式(2)为不合法表达式，只能将值赋值给一个变量，因此其中（4=5）

将5赋值给4是不合法的。

7. 下列（）是合法的Java标识符。

(1) Counter1 (2) $index, (3) name-7 (4) _byte (5) larray (6) 2i (7) try (8) integer

参考答案：Java标识符由数字，字母和下划线(_)，美元符号（$）组成。在Java中是区分大小写的。而且还要求首位不能是数字。最重要的是，Java关键字不能当作Java标识符。因此，(1)、(4)、(5)、(8)是合法标识符。

8. 下列各项中定义变量及赋值不正确的是（）

(1) int I = 32; (2) float f = 45.0; (3) double d = 45.0;

参考答案：(2)不正确，选项(2)定义 float 类型时必须在数据后面加上“F”或“f”。

9. Java语言中，整型常数123占用的存储字节数是（）

(1) 1 (2) 2 (3) 4 (4) 8

参考答案：正确选项是(3)， Java语言中，默认整型数占用4个字节数。

10. 以下代码的编译运行结果是

public class Test{

public static void main(String[] args){ int age;

age = age + 1;

System.out.println(“the age is “ + age); } }

(1) 编译通过，运行无输出

(2) 编译通过，运行结果为 “the age is 1” (3) 编译通过但运行时出错 (4) 不能通过编译

参考答案：(4)为正确选项。Java 在使用变量前应该先初始化。

11. 写出下列表达式的运行结果

(1) 6+3<2+7 (2) 4%2+4*3/2 (3) (1+3)*2+12/3 (4) 8>3&&6==6&&12<4 (5)7+12<4&&12-4<8 (6) 23>>2

参考答案：(1) false；(2) 6；(3) 12； (4) fale；(5) false；(6) 5；

第3章

1. 编码验证i++和++i的区别。

参考答案：++i 和 i++在单独使用时， 就是 i=i+1。而 a = ++i， 相当于 i=i+1; a = i; （先 i = i + 1,再使用 i 的值），而 a = i++，相当于 a = i; i=i+1; （先使用 i 的值，再 i = i + 1）。

2. 写出下面表达式的结果

（1）5/3 （2）5/3.0 （3）5%3 （4）5%-3 参考答案： （1）1

（2）1.6666666666666667 （3）2 （4）2

3. 考虑如下的Test.java，并指出错误原因。

程序清单：Test.java class Test {

public static void main(String[] args) { byte b = 5; b = (b – 2);

System.out.println(b); } }

参考答案：b=(b-2);错误，在进行b-2时，运算结果类自动提升为int，而b是byte类型，编译的时候会报错，因为存在高类型数据向低类型数据转化的风险。而byte b=5;是正确的，因为在编译的时候就能够确定5在byte允许的范围内，虚拟机在编译时做了一定的优化处理。

4. 考虑一下对于if……else……语句，还有没有更简洁的写法。

例如：if( x > 0 ) { y = x; } else { y = -x; }

可以简写成什么？ 参考答案：y=x>0?x:-x;

5. 给定N，编程实现打印N*N的乘法表。 参考答案：

public static void main(String[] args)??{

int a = 0, b = 0, c = 0;??

for(int i=0; i<9; i++)?? { ??

a=i+1;??

for(int j=0;j

b = j+1;?? c = a*b;??

System.out.print(a + \ }??

System.out.println(\ } ?? }??

6. 将下列语句转换成Java代码：

（1）如果b1为真，打印“one”，否则打印“two”。

（2）如果b1为假并且b2为真，打印“one”，否则打印“two”。 （3）如果b1为假，并且如果b2为真则打印“one”，如果b2为假则打印“two”；否则打印“three”。

参考答案:（1） if(b1=true) {

System.out.print(\} else {

System.out.print(\}

（2）if(b1=false && b2 =true) {

System.out.print(\} else {

System.out.print(\

}

（3）if(b1=false && b2 =true) {

System.out.print(\} else if (b1=false && b2 =false){

System.out.print(\

} else {

System.out.print(\

}

7. 找出如下各项中的语法错误：

（1）

for(int k=0;k<100;k++)

System.out.println(k)

（2）

for(int k=0;k<100;k++);

System.out.println(k);

（3）

int k=0

while k<100 {

System.out.println(k);k++ }; （4）

int k=0; do{

System.out.println(k); k++;

} while k<100;

参考答案：

（1）for(int k=0;k<100;k++) {

System.out.println(k); }

（2）for(int k=0;k<100;k++) {

System.out.println(k); }

（3）int k=0；

while (k<100 ){

System.out.println(k); k++； }

（4）int k=0;

do{

System.out.println(k); k++;

} while (k<100);

8. 写出三个不同的循环―for、while和do-while循环，打印出从0（包括0）开始直到1000的所有10的倍数。 参考答案： (1) int n=0;??

while(n<=1000 && n==0)?? {??

System.out.print(n); n++;?? }?? (2)

int n=0?? do??{

if(n==0){

System.out.print(n); } n++;

}??while(n<1000);?? (3)

for(int n=0;n<=1000;n++)??{

if(n==0) {

system.out.print(n); }

9. 给定N，编程实现打印行数为N的菱形。 参考答案：

public static void main(String[] args) { Scanner read = new Scanner(System.in); int n; while (true) { System.out.println(\输入一个整数(>=0)\ if (read.hasNextInt()) { n = read.nextInt(); if (n < 0) continue; break; } else { read.next();

}

} for (int i = 0; i < n; i++) { for (int j = 1; j < n - i; j++) System.out.print(\ for (int j = 0; j < i * 2 + 1; j++) System.out.print(\ for (int j = 1; j < n - i; j++) System.out.print(\ System.out.println(); } for (int i = n - 2; i >= 0; i--) { for (int j = 1; j < n - i; j++) System.out.print(\ for (int j = 0; j < i * 2 + 1; j++) System.out.print(\ for (int j = 1; j < n - i; j++) System.out.print(\ System.out.println(); } }

10. 写出下面程序的输出结果：

public class TestWhile { public static void main(String[] args) { int a=0; while(++a<=100) if ((a%9)==0) System.out.print(a+\ System.out.println(); }

}

参考答案：9 18 27 36 45 54 63 72 81 90 99

第4章

1. 比较String和StringBuffer的区别，并说明什么时候适合使用StringBuffer。 参考答案：

在Java中，String被完全当成一个对象，一个String对象是组成这个字符串的字符序列，加上用来操作字符串的方法。字符串一旦被创建，就不能改变它的值。StringBuffer类同样能够表示一串字符。但是，与String类不同，一个StringBuffer类能够被修改，StringBuffer类维护的是一个字符缓冲区，在必要时它的长度能够增长和缩短。对任何涉及修改字符串的任务，应该用StringBuffer代替String。

2. 说明==和equals的区别，并举例。 参考答案：

==操作比较的是两个变量的值是否相等，对于引用型变量表示的是两个变量在堆中存储的地址是否相同，即栈中的内容是否相同。equals 操作表示的是两个变量是否是对同一个对象的引用，即堆中的内容是否相同。==比较的是两个对象的地址，而equals比较的是两个对象的内容。

3. 假定s是字符串字面值“exercise”，找出下列表达式有语法错误的并改正： （1）s.charAt(\ （2）s.indexOf(\ （3）s.substring(5)

（4）s.lastIndexOf(er) （5）s.length() 参考答案：

其中(1)和(4)表达式有语法错误。(1) charAt(int) 参数是int 类型的；(4)lastIndexOf() 中的参数应该为int 或者 String ，这里的er 既不是int 也不是String。

4. 给定一个句子，统计单词中字母的出现次数（字母不区分大小写，全部按照小写计算）。

参考答案：参考代码 import java.util.Scanner;

public class countChar {

public static void main(String[] args) { //输入需要检测的字符串 System.out.print(\：\ Scanner str0 = new Scanner(System.in); String s = str0.next(); System.out.println(\ s = s.toLowerCase(); //将字符串转换为小写 //输入需要统计的字符 System.out.print(\：\ Scanner str1 = new Scanner(System.in); String s1 = str1.next(); char c = s1.charAt(0); System.out.println(\：\ int count = 0; //统计出现次数变量 for (int i = 0; i < s.length(); i++) { char ch = s.charAt(i); if (ch == c) { count++; } } System.out.println(\ } }

5. 执行String s = new String(\这一语句，共创建几个String对象？

参考答案：两个。\本身是一个字符串对象，而new String()也会创造一个字符串对象。

6. 对于语句String s = \下面那个表达式是合法的？

（1）s += 5;

（2）char c = s[1] （3）int len = s.length;

（4）String t = s.toLowCase; 参考答案：（1）为合法的。

7. String和StringBuffer中的哪个方法能改变调用该方法的对象自身的值？

（1）String的charAt() （2）String的replace()

（3）String的toUpperCase() （4）StringBuffer的reverse()

参考答案：（4）StringBuffer的reverse()可以改变对象自身的值。

8. 假定s是字符串字面值“exercise”，计算下面每个表达式的值：

（1）s.charAt(5) （2）s.indexOf(\（3）s.substring(5) （4）s.lastIndexOf(?e?) （5）s.length() 参考答案： （1）i； （2）2； （3）ise； （4）0； （5）8；

9. 写出下面程序的输出结果：

public class StringExample {

public static void main(String[] args) { String str = new String(\ String str1 = \

String str2 = new String(\ System.out.println(str == str1); System.out.println(str == str2); System.out.println(str1 == str2); System.out.println(str.equals(str1)); System.out.println(str.equals(str2)); System.out.println(str1.equals(str2)); System.out.println(str == str.intern()); System.out.println(str1 == str1.intern());

System.out.println(str.intern() == str2.intern()); String hello = \ String hel = \ String lo = \

System.out.println(hello == \ System.out.println(hello == \ } }

参考答案：

false false false true true true false true

true true false

10. 编写程序，将字符串“aabbcdefg”中每个字符作加2操作，最后结果为“ccddefghi”。

参考答案：参考代码 public class Char {

public static void main(String[] args) { String s = \ char[] ch = s.toCharArray(); for (int i = 0; i < ch.length; i++) { ch[i] = (char) (ch[i] + 2); } ch.toString(); System.out.println(ch); } }

第5章

1. 编写一个程序，计算出前10个平方数（例如1，4，9，16），并将这10个数保存到一个整型数组中，将数组中的所有元素输出到控制台，验证程序是否正确。要确保数组有10个元素，并且元素值的范围是1~100. 参考答案：

public static void main(String[] args) { int b[] = new int[10]; for (int i=1; i < 11; i++) { b[i] = i * i;

}

for (int i = 0; i < 10; i++) { System.out.println(a[i]); } }

2. 声明一个数组，其中的元素为37，47，23，-5，19，56，然后创建一个新数组，将前一个数组的内容复制到后一个数组中。 参考答案：

public static void main(String[] args) { int a[] = {37,47,23,-5,19,56}; int b[] = new int[a.length]; for(int i = 0; i < a.length; i++){ b[i] = a[i]; }

for(int j = 0; j < b.length; j++){ System.out.print(b[j]+\ } }

3. 从命令行输入5个整数到数组a中，分别输入33、55、22、66及77。求偶数的个数及其和。

参考答案：示例代码：

public static void main(String[] args) { int a[] = new int[5]; int count = 0; int sum = 0; for (int i = 0; i < a.length; i++) { System.out.print(\请输入数组中的元素：\ Scanner read = new Scanner(System.in); a[i] = read.nextInt(); if (i % 2 != 0) { count++; sum = sum + a[i]; } } System.out.println(\偶数个数是： \ System.out.println(\偶数的和是： \ }

4. 从命令行输入一个字符串“JavaServlet”，将每个字符存入a数组。

（1）大写字母有几个？分别是那几个？ （2）小写字母有几个？分别是那几个？

（3）将小写字母转换成大写字母，大写字母转换成小写字母。 参考答案：

public static void main(String[] args) { if(args[0] != \ String inputString = args[0]; int countLower = 0; int countUpper = 0; String strLower = \ String strUpper = \ for (int i = 0; i < inputString.length(); i++){ char c = inputString.charAt(i); if (Character.isUpperCase(c)) { countUpper++; strUpper += c + \ } else if (Character.isLowerCase(c)) { countLower++;

strLower += c + \ } } System.out.println(\大写字母有\+ countUpper + \个，分别是：\+ strUpper); System.out.println(\小写字母有\+ countUpper + \个，分别是：\+ strLower); } }

5. 阅读下面代码：

int[] ages = new int[10]; System.out.println(ages[9]);

下面关于上面两行代码的说法哪一个正确的？ （1）编译时发生错误

（2）编译通过，运行时发生错误，因为局部变量在没有初始化情况下，不能使用

（3）编译通过，执行之后向控制台输出结果为0 （4）编译通过，执行时提示发生数组越界的错误 参考答案：（3）为正确选项。

6. 阅读下面代码：

public class AClass {

public static void main(String[] args) {

String[] msg = {\ if(args.length==0) {

System.out.println(\

} else {

System.out.println(msg[args.length]+\} } }

下面哪个选项的说法是正确的？ （1）该代码无法编译通过

（2）不带任何参数运行该程序时，会抛出NullPointerException异常

（3）分别带0个参数、3个参数运行该程序时，会打印No arguments和two arguments

（4）分别带0个参数、3个参数运行该程序时，会打印No arguments和four arguments

参考答案：（4）为正确选项。

6. 从命令行输入八个参数，并以气泡法排序后保存在a数组中，然后再输入一个查找键值Key，按顺序查找判断该键值是否存在与a数组中。 参考答案：参考代码：

public static void main(String[] args) { int i, j, t, temp; int array[] = new int[8]; System.out.println(\输入8个整数:\输入8个整数 */ for (i = 0; i < array.length; i++) { System.out.print(\请输入：\ Scanner read = new Scanner(System.in); array[i] = read.nextInt(); } /* 冒泡排序 */ for (i = 0; i < array.length; i++) { for (j = array.length - 1; j > i; j--) if (array[j] > array[j - 1]) { t = array[j]; array[j] = array[j - 1]; array[j - 1] = t; } } /* 输出排序后的数组元素 */ for (i = 0; i < array.length; i++) { System.out.print(array[i] + \ } System.out.println(\输入一个整数作为键值Key： \ Scanner read = new Scanner(System.in); temp = read.nextInt(); for (i = 0; i < array.length && temp <= array[i]; i++) /* 在排序后的数组中查找 */ { if (temp == array[i]) { System.out.printf(\是您所找的数.\\n\在数组中有可能有相等的元素 */ } else if (temp != array[i - 1]) { System.out.printf(\数组中没有您想找的数.\数组中没有所输入的数 */ } }

}

8. 现有一个长度为49的整型数组a[49]，不重复的将1-50之中49个数依次赋值给该数组，编写程序找出没有放进该数组的是哪个数？

参考答案：

public static int findNum(int a[]) { int numFound = 0; Arrays.sort(a); System.out.println(Arrays.toString(a)); for (int i = 0; i < 50; i++) { if (a[i] != (i + 1)) { numFound = i+1; break; } } return numFound; }

第6章

1. 指出下面声明中的语法错误（如果有）。记住，域声明的某些部分是可选的。

（1）public boolean isEven; （2）private boolean isEven; （3）private boolean is Odd; （4）public boolean is Odd; （5）string S;

（6）private boolean even = 0; （7）private String s = helloWorld; 参考答案：

（3）和（4）均存在变量名命名错误； （5）string并不是一个类型，应为String。

（6）布尔类型变量的值应该为“true”或者“false”，不应该为整型。 （7）helloWorld不是一个字符串，必须用双引号，如：”helloWorld”。

2. 写出下列实例变量的声明：

（1）名为bool的私有boolean型变量，初始值为真。 （2）名为str的公共string型变量，初始值为“hello”。 （3）名为nEmployees的私有int型变量，没有初始值。 参考答案：

（1）private Boolean bool = true; （2）public String str = “hello”; （3）private int nEmployees;

3. 创建如下类：

Circle类（圆形），Square类（正方形）和Point类（点）。Point根据(x，y)坐标定位。Cricle除了一个(x，y)坐标之外，还有半径属性。正方形除了一个(x，y)坐标之外，还有边长。请问这些类中那些是超类，那些是子类？

参考答案：

Point类（点）为超类，而Circle类（圆形）和Square类（正方形）为子类。

4. 关键字组合问题：

（1）abstract方法能否是final类型的？ （2）abstract方法能否是static类型的？

（3）能否定义一个私有静态（private static）方法？ 参考答案：

（1）abstract不能用final 修饰符修饰； （2）abstract方法不能是static类型的； （3）不能定义一个私有静态方法。

5. 阅读下面代码：

1. public class Test{ 2. void test(short s) {

3. System.out.println(\ 4. }

5. void test(byte b) {

6. System.out.println(\ 7. } 8.

9. public static void main(String args[]) { 10. Test t=new Test(); 11. char ch='y'; 12. t.test(ch); 13. } 14. }

下面对于上述代码的描述哪个是正确的？

（1）第5行无法编译，因为void方法不能被重载（overridden）

（2）第12行无法编译，因为没有定义可以接受char类型参数的方法 （3）代码可以编译，但执行时在12行会抛出异常

（4）代码可以编译，并且执行之后的输出结果为：I am an int 参考答案：（2）为正确参考答案。

6. 阅读下面代码，请确定a、b、c、d中的哪一个说法是正确的？ class A { int value1; } class B extends A { int value2; }

（2）类A扩展了类B （2）类B是类A的父类 （3）类B是类A的子类

（4）类A的对象实例中，存在一个名字为value2的成员变量 参考答案：（3）为正确参考答案。

7. 在如下源代码文件Test.java中, 哪个是正确的类定义？

（1）public class test {

public int x = 0; public test(int x) { this.x = x; } }

（2）public class Test{

public int x=0; public Test(int x) {

this.x = x; } }

（3）public class Test extends T1, T2 {

public int x = 0; public Test (int x) {

this.x = x; } }

（4）protected class Test extends T2{

public int x=0; public Test(int x){

this.x=x; } }

参考答案：（2）为正确参考答案。

8. 描述静态代码块、非静态代码块与构造函数的执行顺序。 参考答案：（静态代码块?非静态代码块?构造方法）。

9. 请用代码实现一个计算方法calc()，该方法接受两个参数，返回值为两个参数的和，并且返回值类型与传入的参数类型一致，例如：calc(3, 5)返回8，calc(3.0, 5.3)返回8.3。 参考答案：

（这里不考虑类型判断和溢出等问题，使用方法重载或者泛型实现） （1）public int calc(int num1, int num2) {

return num1+num2; }

public double calc(double num1, double num2) { return num1+num2; }

（2）public T calc(T num1, T num2) { return num1+num2; }

10. 简述Java中this和super的用法。 参考答案：

在Java中有两个非常特殊的变量：this和 super，这两个变量在使用前都是不需要声明的。this变量使用在成员函数的内部，指向当前对象。super变量直接指向超类的构造函数，用来引用超类中的变量和方法。this指代当前类的构造方法，super指代父类的构造方法。

第7章

1. \的返回结果是：

（1）\ （2）true

（3）false （4）String

参考答案：（2）为正确项。

2. 阅读下面代码：

public class Foo {

public static void main (String [] args) {

int i = 0;

addTow(i++);

System.out.println(i); }

static void addTow(int i) {

i += 2; }

}

上述代码的执行结果是：

（1）0 （2）1 （3）2 （4）3

参考答案：（2）为正确项。

3. 阅读下面代码

public class ThisUse {

int plane; static int car;

public void doSomething() {

int i;

//插入语句 }

}

下面哪个选项中的内容不能添加到//插入语句处（添加后导致编译错误）

（1）i=this.plane; （2）i=this.car; （3）this.car=plane; （4）this.i=4;

参考答案：（4）不能添加到//插入语句处。

4. 下列选项中哪一个说法是错误的？

（1）实例方法可以直接访问静态变量和静态方法 （2）静态方法可以直接访问静态变量和静态方法 （3）静态方法可以直接访问实例变量和实例方法 （4）静态方法中不能使用this和super 参考答案：（3）选项说法是错误。

5. 关于静态变量的创建，哪一个选项的说法是正确的？

（1）一旦一个静态变量被分配，它就不允许改变

（2）一个静态变量在一个方法中被创建，它在被调用的时候值保持不变 （3）通常情况下、在任意多个类的实例中，一个静态变量的实例只存在一个

（4）一个静态标识符只能被应用于原始类型变量 参考答案：（3）正确选项。

6. 下列哪一种叙述是正确的？

（1）abstract修饰符可修饰字段、方法和类

（2）抽象方法的body部分必须用一对大括号{ }包住 （3）声明抽象方法，大括号可有可无 （4）声明抽象方法不可写出大括号

参考答案：（4）为正确项。解析：抽象方法的定义：只有方法的声明，没有方法的实现，即没有方法体。

7. 阅读下面代码：

1: interface Foo { 2: int k = 0; 3: } 4:

5: public class Test implements Foo { 6: public static void main(String args[]) { 7: int i; 8: Test test = new Test(); 9: i= test.k;

10: i= Test.k; 11: i= Foo.k; 12: } 13: }

下面关于执行结果的说法哪一个是正确的？ （1）第2行编译失败 （2）第9行编译失败 （3）第10行编译失败 （4）编译成功

参考答案：（4）为正确项。

8. 阅读下面代码：

class A{

void test1(){

hi(); }

private void hi(){

System.out.println(\} }

class AA extends A{

void hi(){

System.out.println(\} }

public class test{

public static void main(String b[]) throws Exception{

A a = new AA(); a.test1(); } }

下面关于上述代码的说法哪一个是正确的？ （1）编译失败 （2）编译通过，执行结果是：say hi,a （3）编译通过，执行结果是：say hi,aa （4）编译通过，运行时发生错误 参考答案：（2）为正确项。

10. 简述Java中有几种内部类？（根据自己的理解，简答即可）

参考答案：

（1）静态嵌套类：是个封闭式顶层类或接口的static（静态）成员。这样的类在Java中作为顶层类。

（2）成员内部类：是一种非静态内部类，它不是顶层类。作为包含它的类的全部成员，成员类可以访问包含它的类的属性和方法，甚至private修饰的变

量和方法。正如类的其他实例变量和方法一样，一个成员内部类的所有实例都与包含它的类的一个实例相关。

（3）方法和作用域中的内部类（局部类）：是一个内部类，定义在一个Java代码块内，比如说定义在一个方法或循环主体内。局部类具有局部作用域，仅使用在定义它的代码块内。局部类可以访问包含它的类的方法和变量。

（4）匿名内部类：是一种其定义和使用被组合到单一表达式中的方法和作用域中的内部类。其定义和使用都在一个表达式中完成，而不是在一条语句中定义，在另一条语句中使用。匿名内部类只使用一次，故不包含构造方法。

11. Java中包装类的作用是什么？

参考答案：在Java中不能定义基本类型的类，为了能将基本类型视为对象来处理，并能操作相关的方法，Java为每个基本类型都提供了包装类。这样，便可以把这些基本类型转化为对象来处理了。

12. Java中final修饰的类、方法、变量各有什么特点？ 参考答案： （1）final类

final类不能被继承，因此final类的成员方法没有机会被覆盖，默认都是final的。在设计类时候，如果这个类不需要有子类，类的实现细节不允许改变，并且确信这个类不会载被扩展，那么就设计为final类。 （2）final方法

如果一个类不允许其子类覆盖某个方法，则可以把这个方法声明为final方法。

使用final方法的原因有二：

第一、把方法锁定，防止任何继承类修改它的意义和实现。

第二、高效。编译器在遇到调用final方法时候会转入内嵌机制，大大提高执行效率。

（3）final变量（常量）

用final修饰的成员变量表示常量，值一旦给定就无法改变！

final修饰的变量有三种：静态变量、实例变量和局部变量，分别表示三种类型的常量。

13. 简述Java中反射的作用。

参考答案：Java反射机制主要提供了以下功能： 在运行时判断任意一个对象所属的类；在运行时构造任意一个类的对象；在运行时判断任意一个类所具有的成员变量和方法；在运行时调用任意一个对象的方法；生成动态代理。

14. 简述Java接口的特点，和抽象类的区别。 参考答案：

接口的特点：

（1）所有属性都是用public、static、final修饰。

（2）所有方法都是用public修饰，方法没有方法体。 （3）不允许有静态方法。 （4）接口可以继承多个接口。 和抽象类的区别：

（1）抽象类中可以有普通成员变量，接口中没有普通成员变量。

（2）抽象类有非抽象的方法和构造方法，并且修饰符可以是私有的，接口只能是抽象的方法，并且修饰符是public。

（3）抽象类中可以包含静态方法，接口中不能包含静态方法。 （4）类只能继承一个抽象类，但能实现多个接口。

15. Java中instanceof关键字的作用是什么？

参考答案：instanceof是Java中的一个二元操作符，也是Java中的保留关键字。它的作用是测试它左边的对象是否是它右边类的实例，返回boolean类型的值。

15. 阅读下面的代码 class A{

public static void prt() { System.out.println(\ }

public A() {

System.out.println(\ } }

public class B extends A { public static void prt() { System.out.println(\ }

public B() {

System.out.println(\ }

public static void main(String[] args) { A a = new B(); a = new A(); } }

请写出输出结果。 参考答案： A B A

第8章

1. 下面哪个类是异常类的基类？ （1）String （2）Error

（3）Throwable （4）RuntimeException 参考答案：（3）为正确选项。Java把异常当作对象来处理，并定义一个基类java.lang.Throwable作为所有异常的超类，因此Throwable在异常类层次结构的顶层。在Java API中已经定义了许多异常类，这些异常类分为两大类归属于Throwable：错误（Error）和异常（Exception）。

2. 下面哪个选项中的异常类不是运行时异常？ （1）NullPointerException （2）ClassCastException

（3）ArrayIndexOutOfBoundsException （4）SQLException

参考答案：（4）不是运行时异常。

3. 阅读下面代码： try {

int x = 0; int y = 5 / x;

} catch (Exception e) {

System.out.println (\} catch (ArithmeticException ae) {

System.out.println (\}

System.out.println (\ 以下哪一个选项的说明是正确的？

（1）执行结果为：finished （2）执行结果为：Exception （3）编译失败 （4）执行结果为：ArithmeticException

参考答案：（3）编译失败。因为ArithmeticException是Exception的子类，在使用其之前已经捕获了Exception。

4. 以下关于异常（Exception）的说法，哪一项是正确的？

（1）类的方法中发生的异常，可以通过try – catch 语句进行捕捉。

（2）JAVA中所有异常都必须被捕捉并处理，否则在编译时将提示编译错误。

（3）try-catch-finally语句来说，finally部分的代码，只在发生异常时执行。 （4）try-catch-finally语句来说，finally部分的代码，只在未发生异常时执行。

参考答案：（1）为正确项。

5. 以下关于异常（Exception）的说法，哪一项是正确的？

（1）Error类型的异常必须被捕捉处理，否则会提示编译错误 （2）SQLExcpetion属于RuntimeException

（3）在对异常进行捕捉处理时，finally部分必须存在

（4）在对异常进行捕捉处理时，catch部分可以对多个异常进行捕捉 参考答案：（4）为正确项。

6. 试说明Java中异常处理的方式。（根据自己的理解，简答即可） 参考答案：

（1）Java默认处理程序，程序终止，输出异常信息。

（2）程序处理，使用try-catch的语法，只有在知道如何处理的情况下才捕获异常！一旦程序中出现不可恢复的错误，程序应当尽快终止，不要尝试处理异常。 （3）回避异常，使用throws方法抛出。

（4）异常转换，异常捕获后后进行再次throw

7. 简述使用try-catch-finally时的注意事项。（根据自己的理解，简答即可） 参考答案：

（1）try块中的代码要少，最好只包含可能抛出异常的语句。

（2）catch异常时需要进行正确的处理，避免出现不处理的情况。 （3）多catch子句中子类异常一定要在父类异常之前。

（4）将资源释放的工作放在finally块中，这样保证资源被释放。

8. 简述子类覆盖父类方法时，如果父类方法声明处抛出异常，那么子类覆盖方法该如何处理异常？ 参考答案：

Java继承中，子类可以覆盖父类的方法，如果父类方法会抛出异常，那么子类方法覆盖父类方法时需要注意：

（1）子类方法可以声明抛出和父类相同的异常。 （2）子类方法可以声明抛出父类方法异常的子类。 （3）子类方法可以不抛出任何异常。 （4）子类方法不能抛出其他预期异常。

9. 阅读下面代码：

int M = someValue; try {

System.out.println(\ if (M > 100)

throw new Exception(M + \ System.out.println(\} catch (Exception e) {

System.out.println(\}

如果someValue等于1000，写出上面代码段的输出结果。

参考答案：

Entering try block

ERROR: 1000 is too large

10. try{}块中有一个return语句，那么紧跟在这个try块后的finally块中的代码会不会被执行，什么时候被执行，在return之前还是之后？请举例说明。

参考答案：如果try块中没有异常产生，最后一条语句使用“return”直接返回或者catch块中使用“return”直接返回，finally代码块也会执行。例如：

public class FinallyBeforeReturn { public static void main(String[] args) { try { int division = 2; int result = 1 / division; //try块中的return语句，此处在异常产生之后，不会执行 return; } catch (ArithmeticException e) {

System.out.println(\进入catch块\

e.printStackTrace(); //catch块中的return，异常产生时就会执行 return; } finally { System.out.println(\使用return之后，finally仍然会执行\ } } }

程序在执行过程中，没有异常产生（当除数为0时会产生ArithmeticException异常，输出“进入catch块”信息），不会进入catch块执行输出语句。在try块中结束位置使用了“return;”语句直接从方法返回，此时是在try块中，所以在方法返回前一定会进入finally中执行代码，结果就是输出信息“使用return之后，finally仍然会执行”。

11. 请简述Java中error和exception的区别。

参考答案：二者的区别：Error类定义了在通常环境下不希望被程序捕获的异常，表示系统错误比较严重无法恢复的情况。Error类对象是由Java虚拟机生成并抛出，例如内存不足、堆栈溢出等情况，这种异常一旦出现意味着虚拟机内部出现严重问题，它们通常是致命性的错误，不是程序可以控制的，程序不应该捕获并尝试恢复。

Exception类定义了由应用程序抛出的异常，这些异常是可以被用户程序捕获的。Exception异常分为：运行时异常（RuntimeException）和预期异常（Checked Exception）。

12. 请简述final和finally的区别。

参考答案：

final是Java中的关键字，具有“无法改变”或者“终态的”含义，它可以修饰非抽象类、非抽象类成员变量和方法。用final修饰的类不能被继承；用final修饰的方法不能

被覆盖；用final修饰的成员变量表示常量，值一旦给定就无法改变；final修饰的对象引用表示该引用不能在指向其它的对象，但是对象本身的成员变量的值是可以改变的。

finally用于异常处理，finally语句块是在同一个try/catch语句组中必须执行的部分。

13. 请写出下面程序的输出结果：

public class Exp {

public static void main(String[]args) { Exp exp = new Exp();

System.out.println(exp.test()); }

public int test() { try{

return m1(); } finally {

return m2(); }

}

public int m1() {

System.out.println(\ return 1; }

public int m2() {

System.out.println(\ return 2; }

}

参考答案：

m1 m2 2

本文来源：https://www.bwwdw.com/article/n4jv.html