《Java语言程序设计与数据结构（基础篇）》第11版复习题答案
1.2.1答案：硬件是指计算机中可见的物理部分，而软件提供不可见的指令。
1.2.2答案：中央处理器（CPU）、内存、存储设备、输入设备和输出设备、通信设备。
1.2.3答案：Central Processing Unit
1.2.4答案：Hz（赫兹）、MHz（兆赫兹）、GHz（吉赫兹）
1.2.5答案：比特就是二进制数字系统中的数，计算机中字节是最小的存储单元
1.2.6答案：计算机的内存由一个有序的字节序列组成，用于存储程序及程序需要的数据。RAM代表随机访问存储器。每个字节都有唯一的地址，使用这个地址确定字节的位置，以便于存储和获取数据，因为可以按任意顺序存取字节，所以内存也被称为
：字节
1.2.8答案：B、KB、MB、GB随机访问存储器（RAM）。
1.2.7答案
1.2.9答案：内存和永久存储设备的不同是计算机的内存是一种易失的数据保存形式：断电时存储在内存中的信息就会丢失。程序和数据被永久的存放在存储设备上，当计算机确实要用他们时再移入内存，因为从内存读取比从存储设备读取要快得多。
1.3.1答案：机器语言
1.3.2答案：汇编语言（assembly language）就是使用短的描述性单词（助记符）来表示每一条机器语言指令。由于计算机不理解汇编语言，所以需要使用一种称为汇编器的程序将汇编语言程序转换为机器代码。
1.3.3答案：高级编程语言类似于英语，易于学习和使用，高级语言中的指令称为语句。源程序就是用高级编程语言编写的程序。
1.3.4答案：解释器和编译器就是可以将源程序翻译成可执行的机器代码的编程工具。
1.3.5答案：解释器和编译器的区别就是：解释器是从源代码中读取一条语句，将其翻译成为机器代码或者虚拟机器代码，然后立刻运行，编译器就是将整个源代码翻译成为机器代码文件，然后执行该机器代码文件。
1.4.1答案：操作系统（Operaing System OS）是运行在计算机上的重要的程序，他可以管理和控制计算机的活动。流行的操作系统有Microsoft Windows、Mac OS以及Linux。
1.4.2答案：操作系统的主要任务有控制和监视系统活动、分配和调配系统资源、调度操作。
1.4.3答案：多道程序设计允许多个程序（比如Microsoft Word、E-mail以及Web浏览器）通过共享同一个CPU同时运行。多线程允许单个程序同时执行多个任务。多处理类似于多线程，但区别在于多处理是采用多个处理器来并行运行多个程序。
1.5.1答案：Java是由James Gosling在Sun公司领导的小组开发的。Oracle现在拥有Java。
1.5.2答案：能在Web浏览器中运行的Java程序称为Java applet。
1.5.3答案：Java
1.6.1答案：Java语言规范（Java language specification）是对Java承认那个需设计语言的语法和语义的技术定义。
1.6.2答案：JDK代表有一组独立数据构成，每个程序都是从命令调用的，用于编译、运行和测试Java程序。JRE代表运行Java的程序。
1.6.3答案：IDE是集成开发环境。
1.6.4答案：NetBeans和Eclipse既不是编程语言，也不是方言，也不是Java的扩展。他们是Java的开发工具
1.7.1答案：关键字对编译器具有特定的意义，不能用于程序中的其他目的。关键字的例子有class、static、void。
1.7.2答案：Java源代码是区分大小写的，大小写敏感。Java的关键字总是小写的。
1.7.3答案：注释是记录程序是干什么的，以及他是如何构建的，注释帮助程序进行相互沟通以及理解程序。编译器编译程序时是忽略注释的。在Java中，在单行上用两个斜杠（//）引导注释，称为行注释，在一行或者多行用/*和*/括住注释，称为块注释，表示一段注释。
1.7.4答案：System.out.println(string);
1.7.5答案：3.5 * 4 / 2 -2.5 is
4.5
1.8.1答案：.Java .class
1.8.2答案：输入是Java源代码文件，输出是Java类文件
1.8.3答案：javac
1.8.4答案：java
1.8.5答案：JVM是运行Java程序的Java虚拟机
1.8.6答案：可以。可以在任何一个装有JVM的平台上运行字节码
1.8.7答案：运行一个不存在的类文件。Java解释器找不到.class。要确保将文件放在正确位置，并使用适当的包名调用Java命令
1.8.8答案：执行的类文件没有main方法或者敲错了main方法
1.9.1答案：
public class Test{
//Main method
public static void main(String[ ] args){
/** Display output */
Systen.out.println(“Welcome to Java”);
}
}
1.10.1答案：在编译过程中由编译器检测出来的错误称为语法错误。运行错误是引起程序非正常终止的错误。当程序没有按预期的方式执行时就会发生逻辑错误。
1.10.2答案：语法错误例如：拼错关键字，忽略了一些必要的标点符号，或者左花括号是由创建代码时的错误引起的。
运行时错误例如：输入错误是典型的运行时错误。当程序等待用户输入一个值，而用户输入了一个程序不能处理的值时，就会发生输入错误。
逻辑错误例如：整数相除是返回除法的整数部分，而小数会被截掉，因此会导致数值的 不准确，从而发生逻辑错误。
1.10.3答案：语法错误
1.10.4答案：运行时错误
1.10.5答案：逻辑错误
1.10.6答案：将Main改成main
缺少static，在public后加static
Welcome to Java应该用双引号引起来
最后一行的）改为}
2.2.1答案：函数里没有static，string[ ]里的s没有大写，
应改为public static void main（String[ ] args）
第七行里不可以换行，应该改为System.out.println(“j is ”+ j + “and”
+“k is” + k);
2.3.1答案：
import java.unit.Scanner;
public class Review2-2{
public static void main(String[ ] args){
Scanner input =newScanner(System.in);
Double number = input.nextDouble();
System.out.println(number);
}
}
如果执行下面的代码，输入的是5a，系统将会报错无法运行。
2.3.2答案：在性能上，二者没有什么区别
2.4.1答案：miles，Test，$4，apps，x，y，radius是合法的标识符
class,public,int是Java的关键字
2.5.1答案：局部变量k没有进行声明以及赋值，就直接使用
可以将这一句修改为int k=1；int i=k+2；
2.6.1答案：局部变量j，k没有进行声明。
可以将这句修改为int i,j,k; i=j=k=2;
2.7.1答案：使用常量的优势有（1）不必重复输入同一个值（2）如果必须修改常量值，只需要在源代码中的一个地方做变动（3）给常量赋名字可以使程序更加易读
final int SIZE=20;
2.8.1答案：类名的命名习惯是每个单词中的首写字母大写
方法名和变量名的命名习惯是如果是一个单词就小写，如果一个命名包含多个单词，就将它们连在一起，第一个单词的字母小写，而后面每个单词的首字母大写。
常量的命名习惯是所有的字母大写，两个单词间用下划线连接
MAX_VALUE可以作为常量的名字，Test可以作为类名的名字，read和readDouble可以作为方法名和变量名的名字
2.8.2答案：
public class Review{
public static void main(String[ ] args){
double miles =100;
double KILOMETERS_PER_MILE=1.609;
double kilometers=miles* KILOMETERS_PER_MILE;
System.out.println(“kilometers 为：”+ kilometers)；
}
}
2.9.1答案：byte 最大127 最小 -128
Short 最大2^15-1 最小 -2^15
Int 最大2^31-1 最小 -2^31
long 最大2^63-1 最小 -2^63
float 最大3.4028235E+38 最小 -3.4028235E+38
double 最大1.7976931348623157E+308 最小-1.7976931348623157E+308
byte的内存最小
2.9.2答案：2 2 -4 -4 0 1
2.9.3答案：（100+2）%7=4,所以100天之后是星期四
2.9.4答案：结果为6
如果希望得到浮点数，应该写成25.0/4或者25.0/4.0
2.9.5答案：
8
10
4
5
2.9.6答案 :25 / 4 is 6
25 / 4 .0is 6.25
3*2 / 4 is 1
3.0*2/ 4 is 1.5
2.9.7答案：System.out.println(“结果是” + Math.pow(2,3.5));
2.9.8答案：double result = m*r*r或者1.0*m*r*r
2.10.1答案：float型变量保存了7-8位精确位
double型变量保存了15-17位精确位
2.10.2答案：12.3 -334.4 20.5 39F 40D
2.10.3答案：5.2534e+1 0.52534e+2 525.34e-1
2.10.4答案：5_2534e+1 5_2
2.11.1答案：4/（3*（r+34））-9*(a+b*c)+(3+d(2+a))/(a+b*d);
5.5*Math.pow(r+2.5,2.5+t);
2.12.1答案：当前的秒数等于总的秒数对60取余
当前的分钟数等于总分钟数对60取余
当前的小时数等于总小时数对24取余
2.13.1答案：14.0
3.0
2.14.1答案：a,b,c说法为真
2.14.2答案：
7
6
7
7
2.15.1答案：可以
2.15.2答案：double转化为int型时，double型数据的小数部分被截去，类型转换不改变被类型转换的变量
2.15.3答案：f is 12.5
i is 12
2.15.4答案：Sales tax is $11
2.15.5答案：2.5
2
2.15.6答案：(int) Math.round(d)//对d四舍五入
2.16.1答案：(-b+Math.pow(b*b-4*a*c,0.5))/(2*a)
2.17.1答案：
Your amount 1.99 consists of
1 dollars
3 quarters
2 dimes
0 nickels
4 pennines
2.18.1答案：在同一个作用域之内是可以的，但是如果在同一个定义域之内是不可以进行重复定义的，不能重复定义名字相同字的变量
2.18.2答案：数字以有限的位数存储。当一个变量被赋予一个过大（以存储大小而言）的值，以至于无法储存该值，称为溢出。如果一个浮点数过小（即非常接近于0），将导致下溢。
2.18.3答案：Java不会给出有关于溢出的警告或者错误。
2.18.4答案：舍入错误是指将计算得到的数字的近似之和确切的数学值之间的差异。整数不会发生舍入错误，浮点数会发生舍入错误。
3.2.1答案：< <= > >= == !=
3.2.2答案：true
false
true
true
false
3.2.3答案：不合法
Java:不兼容的类型：boolean无法转化为int
Java:不兼容的类型：int无法转化为boolean
3.3.1答案：
import java.util.Scanner;
public class Review3_3_1 {
public static void main(String[] args){
Scanner input = new Scanner(System.in);
System.out.println("Enter the y : ");
int y = input.nextInt();
int x =0 ;
if(y>0)
x=1;
System.out.println("x is "+ x);
}
}
3.3.2答案：
import java.util.Scanner;
public class Review3_3_2 {
public static void main(String[] args){
Scanner input = new Scanner(System.in);
System.out.println("Enter your score: ");
double score = input.nextDouble();
if(score > 90)
score = score + score * 0.03;
System.out.println("the cost is: "+score);
}
}
3.3.3答案：if中的语句应该用括号括起来，第一行应改为if(radius >= 0)
3.4.1答案：
import java.util.Scanner;
public class Review3_4_1 {
public static void main(String[] args){
Scanner input = new Scanner(System.in);
System.out.println("Enter your score: ");
double score = input.nextDouble();
if(score > 90)
score = score + score * 0.03;
else
score = score + score * 0.01;
System.out.println("the cost is: "+score);
}
}
3.4.2答案：
number 是30 的时候
(a)30 is even.
30 is odd.
(b)30 is even.
number 是35 的时候
(a)30 is odd.
(b)30 is odd.
3.5.1答案：第一个：代码无输出
第二个：z is 7
第三个：x is 2
3.5.2答案：第一个：代码无输出
第二个：x is 3
第三个：z is 6
3.5.3答案：score在60分以上的结果输出都是D
3.6.1答案：a，c，d是等价的
b，c是合理缩进的
3.6.2答案：boolean newLine = count % 10 == 0;
3.6.3答案:正确，b更好
3.6.4答案：
number为14时：(a)14 is even
(b)14 is even
number为15时：(a)15 is multiple of 5
(b) 15 is multiple of 5
number为30时：(a) 30 is even
30is multiple of 5
(b) 30 is even
3.7.1答案：0.5 0.0 0.234
3.7.2答案：int i = (int)(Math.random()*20)
int i = (int) (10+Math.random()*10)
int i = (int)(Math.random()*51)
int i = (int)(Math.random()+0.5)
3.9.1答案：等价
3.10.1答案：
false
false
true
true
true
true
3.10.2答案：
(a)if((num>=1)&&(num<=100)){
System.out.println(“true”);}
(b)if((num>=1)&&(num<=100)||(num<0)){
System.out.println(“true”);}
3.10.3答案：
(a) x>0.5&&x<9.5
(b)x<0.5||x>9.5
3.10.4答案：x/=y
3.10.5答案：等同，6是2和3的最小公倍数
3.10.6答案：
x=45时，表达式的值为false
x=67时，表达式的值为true
x=101时，表达式的值为false
3.10.7答案：
(x<y&&y<z) is true
(x<y||y<z) is true
!(x<y) is false
(x+y<z) is true
(x+y>z) is false
3.10.8答案：
if(age>13&&age<18)
System.out.println(“true”);
3.10.9答案：
if((weight>50)||(height>60))
System.out.println(“true”);
3.10.10答案：
if((weight>50)&&(height>60))
System.out.println(“true”);
3.10.11答案：
if((weight>50)^(height>60))
System.out.println(“true”);
3.11.1答案：闰年的二月有29天，2000和2016是闰年
3.12.1答案：输入05时，如果与随机产生的彩票数数字且顺序完全一致，
则输出“Exact math : you win $10,000”
输入05时，如果与随机产生的彩票数数字匹配但顺序不一致，
则输出“Exact math : you win $3,000”
输入05时，如果与随机产生的彩票数数字只有一个匹配，
则输出“Exact math : you win $1,000”
输入05时，如果与随机产生的彩票数数字且顺序完全一致，
则输出“Sorry,no match”
3.13.1答案：char，byte，short，int，string
一旦匹配其中一个case，就从匹配的case处开始执行，直到遇见break语句活着到达switch语句的结束
可以把switch语句转换成等价的if语句
但不一定能将if语句转换为等价的switch语句
使用switch语句的优点：程序逻辑结构清晰，语句简单
3.13.2答案：执行后，y=2,（因为没有使用break跳出，所以当case 6满足条件时，y=1，没有跳出，y继续加1，y=2）
将其改成if-else后为
public class XiTi3_13 {
public static void main(String[] args){
int x = 3,y = 3;
if((x+3) == 6){
y=1;
}
else
y=y+1;
System.out.println(y);
}
}
3.13.3答案：x是17
使用switch后，代码为
int x = 1,a = 3;
switch(a){
case 1: x+=5;break;
case 2: x+=10;break;
case 3: x+=16;break;
case 4: x+=34;break;
}
3.13.4答案：
switch(day){
case 0：System.out.println(“Sunday”);break;
case 1：System.out.println(“Monday”);break;
case 2：System.out.println(“Tuesday”);break;
case 3：System.out.println(“Wednesday”);break;
case 4：System.out.println(“Thursday”);break;
case 5：System.out.println(“Friday”);break;
case 6：System.out.println(“Saturday”);break;
3.13.5答案：
import java.util.Scanner;
public class ChineseZodiac {
public static void main(String[] args){
Scanner input = new Scanner(System.in);
System.out.println("Enter the years : ");
int year = input.nextInt();
if(year % 12 == 0)
System.out.println("monkey");
else if(year % 12 == 1)
System.out.println("rooster");
else if(year % 12 == 2)
System.out.println("dog");
else if(year % 12 == 3)
System.out.println("pig");
else if(year % 12 == 4)
System.out.println("rat");
else if(year % 12 == 5)
System.out.println("ox");
else if(year % 12 == 6)
System.out.println("tiger");
else if(year % 12 == 7)
System.out.println("rabbit");
else if(year % 12 == 8)
System.out.println("dragon");
else if(year % 12 == 9)
System.out.println("snake");
else if(year % 12 == 10)
System.out.println("horse");
else if(year % 12 == 11)
System.out.println("sheep");
}
}
3.14.1答案：sorted
3.14.2答案：
ticketPrice = (ages >= 16) ? 20 :10;
3.14.3答案：
(a)
If(x > 10)
score = 3 * scale;
else
score = 4 * scale;
(b)
if(income > 10000)
tax = income * 0.2;
else
tax = income * 0.17 + 1000;
(c)
if(number % 3 == 0)
System.out.println(i);
else
System.out.println(j);
3.14.4答案：
import java.util.Scanner;
public class XiTi3_14_4 {
public static void main(String[] args){
System.out.println("Enter a digit: ");
Scanner input= new Scanner(System.in);
double a = input.nextDouble();
int b = (a>5.0) ? 1: -1;
System.out.println(b);
}
}
3.15.1答案：布尔操作符由高级向低级的顺序为! && ||
计算结果为: true true
3.15.2答案：这个说法是假的
3.15.3答案：false
false
3.15.4答案：一样 一样 一样
4.2.1答案：a: 2.0 b: 0.0 c: 1.0 d: 4.0 e: 1.0 f: 2.718281828459045 g: 3 h: -2.0
i: -2.0 j: -3.0 k: -2 l: -2 m: 2.0 n: 3.0 o: 2.0 p: 3 q: 3 r: 3
4.2.2答案：不正确
sin() cos() tan() 参数是一个弧度值，结果是一个三角函数，asin() acos() atan()参数是正切值或者是斜率，他们的返回值是一个弧度值。
4.2.3答案：double x = Math.toRadians(47);
4.2.4答案：double x =Math.toDegrees(Math.PI);
4.2.5答案：
System.out.println((int)(34+Math.random()*12));//34~55
System.out.println((int)(Math.random()*1000));//0~999
System.out.println((float)(5.5+Math.random()*51));//5.5~55.5
4.2.6答案：因为Math类在java.lang中,java.lang包的内容是都不需要导入，其他的都需要导入；java中底层加载的时候就用java.lang，省资源
4.2.7答案: 5.5
5.5
0.5235987755982988
0.5235987755982988
4.3.1答案：
System.out.println("1的ASCII码是"+(int)'1');
System.out.println("A的ASCII码是"+(int)'A');
System.out.println("B的ASCII码是"+(int)'B');
System.out.println("a的ASCII码是"+(int)'a');
System.out.println("b的ASCII码是"+(int)'b');
System.out.println("40代表的字符是"+(char)(40));
System.out.println("59代表的字符是"+(char)(59));
System.out.println("79代表的字符是"+(char)(79));
System.out.println("85代表的字符是"+(char)(85));
System.out.println("90代表的字符是"+(char)(90));
System.out.println("16进制数40代表的字符是"+(char)(0x40));
System.out.println("16进制数5A代表的字符是"+(char)(0x5A));
System.out.println("16进制数71代表的字符是"+(char)(0x71));
System.out.println("16进制数72代表的字符是"+(char)(0x72));
System.out.println("16进制数7A代表的字符是"+(char)(0x7A));
4.3.2答案：
‘1’ ‘\u3fFa’ ‘\b’ ‘\t’
4.3.3答案：显示字符\的方式是：\;
显示字符”的方式是：\”
4.3.4答案：49 100 97 z
4.3.5答案：合法，结果为i=65
合法，结果为i=1000；
合法，结果为i=1000；
合法，结果为c=a；
4.3.6答案：
b
c
-2
4.3.7答案：
public class XiTi4_3_7 {
public static void main(String[] args){
int p = 'a' + (int)(Math.random()*26);
System.out.println((char)p);
}
}
4.3.8答案：
true
false
false
true
true
true
4.4.1答案：
a :false b:false c:false d:false e:-25 f:25 g:0 h:w i:-1 j:8 k:14 l:9 m:15
n:me to Java o:me to p:true q:true s:Welcome to Java
t:Welcome to JavaProgramming is fun u:false v:Wel
4.4.2答案：
String s3 = s1-s2;
s1 >= s2;
char c = s1(0);
char c =s1.charAT(s1,length());
4.4.3答案：
11
50
111
12
51
4.4.4答案：
System.out.println(1+"welcome"+1+1);//1welcome11
System.out.println(1+"welcome"+(1+1));//1welcome2
System.out.println(1+"welcome"+(‘\u0001’+1);//1welcome2
System.out.println(1+"welcome"+’a’+1);//1welcomea1
4.4.5答案：
boolean isEqual = s1.equals(s2);
boolean isEqual = s1.equalsIgnoreCase(s2);
int x = s1.compareTo(s2);
int x =s1.compareToIgnoreCase(s2);
boolean b = s1.startsWith("AAA");
boolean b = s1.endsWith("AAA");
int x = s1.length();
char x = s1.charAt(0);
String s3 = s1 + s2;
String s4 = s1.substring(1);
String s5 = s1.substring(1,5);
String s3 = s1.toLowerCase();
String s3 = s1.toUpperCase();
String s3 = s1.trim();
int x = s1.indexOf('e');
int x = s1.lastIndexOf("abc");
4.4.6答案：
int x = (i+"").length();
4.4.7答案：
int x = (d+"").length() - 1;
4.6.1答案：
布尔值：%b
字符：%c
十进制整数：%d
浮点数：%f
字符串：%s
4.6.2答案：
（a）条目与标识符的数量，类型和次序上必须是匹配的，在这一题，有三个数字，只有两个标识符
（b）有两个标识符，但是只有一个数字
（c）条目与格式标识符必须在类型上严格把控。%f对应浮点数，int型变量不能匹配%f
（d）.2f不清楚一共有多少位。0.3f表示包括小数点后的三位一共有零位，不正确
（e）
4.2.3答案：
amount is 32.320000 3.232000e+01
032.32% 3.2320e+01
false
java
false java
falsejava
，31234,315562.9
32 32.3
5.2.1答案：pointA、B、C处总为false
5.2.2答案：
（a）不输出，重复无数次
（b）不输出，重复无数次
（c）重复九次，输出3579
5.2.3答案：（2^31）-1，也就是2147483647
因为int型数的范围是-2^31到（2^31）-1，所以x最大为2147483647
5.3.1答案：guess的值为零，0可能也是要猜到的数，这样会导致while无法执行，无法输出
5.5.1答案：
max is 5
number 0
5.6.1答案：
max is 5
number 0
5.6.2答案：while先判断后执行，而do-while先执行后判断
Scanner input = new Scanner(System.in);
int sum =0;
System.out.println(“Enter the integer ”+"(the input ends if it is 0)");
int number = input.nextInt();
do{
sum += number;
System.out.println(“Enter the integer ”+"(the input ends if it is 0)");
number = input.nextInt();
}while(number != 0);
5.7.1答案：具有相同的值
5.7.2答案：
初始操作；循环继续条件；每次迭代后的操作
for(i = 1;i<=100;i++){
System.out.print(i);
}
5.7.3答案：
sum is 14
count is 5
5.7.4答案：循环体无限循环下去
5.7.5答案：不可以
5.7.6答案：
while：
long sum = 0;
int i = 0;
while(i<1000){
sum = sum+i;
i++;
}
do-while：
long sum = 0;
int i = 0;
do{
sum = sum+i;
i++;
}while(i<1000);
5.7.7答案：
（a）n次
（b）n+1次
（c）n-5次
（d）（n-6/3）次
5.8.1答案：可以
For循环更加简洁，相比其他两种循环更容易避免出错
5.8.2答案：
int i = 1;
int sum = 0;
for(sum = 0;sum<10000;) {
sum = sum + i;
i++;
}
5.8.3答案：
public void 中间没有static，应改为public void static
if（i<j）；不应该有分号，应该将分号删去
while（j<10）；不应该有分号，应该将分号删去
for（int i=0；i<10;i++）；不应该有分号，应该将分号删去
do-while循环中的while语句后面应该有分号，将分号添上
5.8.4答案：while（j<10）；不应该有分号，应该将分号删去
5.8.5答案：for（int i=0；i<10;i++）；不应该有分号，应该将分号删去
5.9.1答案：println语句应该不执行，因为后面缺少分号
5.9.2答案：
（a）0010120123
（b）
****
****
2****
32****
432****
（c）
1xxx2xxx4xxx8xxx16xxx
1xxx2xxx4xxx8xxx
1xxx2xxx4xxx
1xxx2xxx
1xxx
（d）
IG
1G3G
1G3G5G
1G3G5G7G
1G3G5G7G9G
5.11.1答案：会
5.11.2答案：char与int型数据做运算，会自动转化为int型，而hexValue是char型的
5.11.3答案：对于245执行2次，对3245执行3次
5.11.4答案：F 10
5.11.5答案：System.out.println("The hex number is "+'0'+hex);
5.12.1答案：当程序遇见continue时，它会结束当前的迭代，程序控制转向改循环体的末尾，换句话说，continue只是跳出了一次迭代，而关键字break跳出了整个循环
（a）能结束，balance is 1
（b）不能结束
5.12.3答案：
第一个：
public class TestBreak {
public static void main(String[] args){
int sum = 0;
int number = 0;
for(sum = 0,number = 0;sum<100;){
number++;
sum +=number;
}
System.out.println("The number is "+number);
System.out.println("The sum is "+sum);
}
}
第二个：
public class TestContinue {
public static void main(String[] args){
int sum = 0;
int number =0;
do{
number++;
if(number == 10|| number == 11){
sum = sum;
}
else
sum += number;
}while(number < 20);
System.out.println("The sum is "+sum);
}
}
5.12.4答案：
（a）System.out.println(i)；
（b）j++
5.14.1答案：System.out.print((count % NOPPL == 0) ? (number + "\n") : (number + " "));
6.4.1答案：可以重复利用代码，降低代码的复杂度，易于维护
6.4.2答案：
定义方法的语法如下所示：
修饰符 返回值类型 方法名（参数列表）{
//方法体;
}
方法的调用是指执行方法中的代码，调用方法有两种途径：
如果方法返回一个值，对方法的调用通常就当做一个值处理
如果方法返回void，对方法的调用必须是一条语句
6.4.3答案： return(num1>num2)?num1:num2;
6.4.4答案：错误
对返回类型为void的方法的调用始终是一条语句，对值返回的方法的调用总是表达式的一个组件
6.4.5答案：void
6.4.6答案：会发生语法错误
可以在返回值类型为void类型的方法中有return语句，该句只是退出该方法
会导致错误，void中可以有return语句，但不能返回一个值，eg：return x+y；
6.4.7答案：定义在方法头中的变量称为形式参数，简称为形参
当调用方法时，就给参数传递一个值，这个值称为实际参数，简称为实参
方法名和参数列表一起构成方法签名
6.4.8答案：
(a)public static double getCommissionRate(double saleAmount,double commissionRate)
(b)public static void print(int month,int year)
(c)public static double sqrt(double number)
(d)public static boolean exam(int number)
(e)public static void print(String message,int times)
(f)public static double mPayment(double loan,int years,int yearRate)
(g)public static char getUpperCase(charb letter)
6.4.9答案：
变量缺少类型说明，应该改为(int n;int m);
public static 后应该有类型名 ，应该改为public static void
类型名使用有误，应改为public static int method(double n)
缺少main函数
删去if(n < 0)
6.4.10答案：
public class Test{
public static double method(double i,double j){
while(i < j){
j--;
}
return j;
}
}
6.5.1答案：
通过传值的方法将实参传给形参
可以
6.5.2答案：参数没有按照正确的顺序排序
应该写成你Println（”Welcome to java”,5）;
6.5.3答案：
当调用带参数的方法时，实参的值传递给形参，这个过程称为按值传参
（a）0
（b）2
2 4
2 4 8
2 4 8 16
2 4 8 16 32
2 4 8 16 32 64
（c）
Before the call, variable time is 3
n = 3
Welcome to Java!
n = 2
Welcome to Java!
n = 1
Welcome to Java!
After the call, variable time is 3
（d）
1
2 1
2 1
4 2 1
i is 5
6.5.4答案：
6.6.1答案：2
6.6.2答案：false
6.7.1答案：11
6.7.2答案：7
6.7.3答案：169
6.8.1答案：在一个类中有两个方法，他们具有相同的名字，但有不同的参数列表。Java编译器根据方法签名来决定使用哪个方法，这称为方法重载
可以定义两个同名但参数类型不同的方法
不能，被重载的方法必须具有不同的参数列表，不能基于不同修饰符或返回值类型来重载方法
6.8.2答案：被重载的方法必须具有不同的参数列表，不能基于不同修饰符或返回值类型来重载方法
6.8.3答案：
（a）public static double m(int x,double y);
（b）public static double m(int x,double y);
（c）public static double m(double x,double y);
6.9.1答案：在方法中定义的变量称为局部变量
6.9.2答案：变量的作用域(scope of a variable)是指变量可以在程序中被引用的范围局部变量的作用域是从变量声明的地方开始，直到包含该变量的块结束为止
7.2.1答案：
声明变量的语法：
elementType[] arrayRefVar;或elementType arrayRefVar[];
创建数组的方法
arrayRefVar = new elementType[arraySize];
7.2.2答案：在创建数组时为数组分配内存
7.2.3答案：
x is 60
The size of number is 30
7.2.4答案：
True
False
True
False
7.2.5答案：b，e合法
7.2.6答案：通过数组的下标来访问数组元素
7.2.7答案：int型 0 a[2]
7.2.8答案：
（a）double[] array = new double[10];
（b）array[array.length-1] = 5.5;
（c）System.out.println(array[0]+array[1]);
（d）
int sum = 0;
for(int i =0;i <array.length;i++){
sum = sum+array[i];
}
（e）
int min = array[0];
for(int i =0;i <array.length;i++){
if(array[i] < min)
min = array[i];
}
（f）System.out.println(array[(int)(Math.random() * array.length)]);
（g）double[] array = {3.5,5.5,4.52,5.6};
7.2.9答案：会出现运行时错误
7.2.10答案：
double[100] r;错误，应该改为double[] r;
i<length.();错误，应该改为i<r.length;
r(i)应该改为r[i]
Math.random*100错误，应该改为Math.random()*100
7.2.11答案：1 1 1 1 1 1
7.4.1答案：不会，可能有相同的牌不止一次被抽到
7.5.1答案：System.arraycopy(score,0,t,0,score.length);
7.5.2答案：是，因为创建了一个新数组，所以重设了数组的大小
7.7.1答案：因为这样的程序就对两个相对的数据交换了两次，相当于没有交换。
修改后的程序如下：
int[i] list = {1,2,3,5,4};
for(int i = 0,j = list.length;i < list.length;i++,j--){
int temp = list[i];
list[i] = list[j];
list[j] = temp;
}
7.8.1答案：是假的，因为当数组传递给方法时，数组的引用值将被传递。没有创建新的数组，实参和形参都指向同一个数组。
7.8.2答案：
（a）number is 0 and number[0] is 3
（b）1 2 3 4 5
7.8.3答案：
数组保存在栈中
7.9.1答案：
a错在了只能给方法中指定一个可变长参数
b错在了同时该参数必须是最后一个参数，任何常规参数必须是最后一个参数
c错在了方法返回类型不可以是可变长参数列表
7.9.2答案：a和b可以，c不可以，因为数据类型不相同
7.10.1答案：（hight - low）/2 +low
7.10.2答案：
7.10.3答案：不在该列表中
（-low-1）=4，low = 3，所以应该插入下标为3的位置
7.11.1答案：
7.11.2答案：public class SelectionSort {
public static void selectionSort(double[] list){
for(int i =0;i<list.length-1;i++){
double currentMax = list[i];
int currentMaxIndex = i;
for(int j = i+1;j<list.length;j++){
if(currentMax < list[j]){
currentMax = list[j];
currentMaxIndex = j;
}
}
if(currentMaxIndex != i){
list[currentMaxIndex] = list[i];
list[i] =currentMax;
}
}
}
}
7.12.1答案：
除了boolean类型之外的都可以
这个sort方法返回值为void类型，所以不会创建一个新的数组
7.12.2答案：必须按升序排好
7.12.3答案：
[7,7,7,7]
[2,4,7,10]
False
7.13.1答案：可以替换成a，b，c
7.13.2答案：
第一小题：
Number of string is 4
I
have
a
dream
第二小题：
Number of string is 1
1 2 3
第三小题：
Number of string is 0
8.2.1答案：int[][] array = new int[4][5];
8.2.2答案：可以
8.2.3答案：array[0][1] is 2
8.2.4答案：合法的有
int[][] y = new int[3][];
int[][] z ={{1,2}};
int[][] z ={{1,2},{2,3}};
8.3.1答案：
6 5
4 3
2 1
8.3.2答案：9
8.4.1答案：
2
4
8.5.1答案：
public class GradeExam8_2 {
public static void main(String[] args) {
// Students' answers to the questions
char[][] answers = {
{'A', 'B', 'A', 'C', 'C', 'D', 'E', 'E', 'A', 'D'},
{'D', 'B', 'A', 'B', 'C', 'A', 'E', 'E', 'A', 'D'},
{'E', 'D', 'D', 'A', 'C', 'B', 'E', 'E', 'A', 'D'},
{'C', 'B', 'A', 'E', 'D', 'C', 'E', 'E', 'A', 'D'},
{'A', 'B', 'D', 'C', 'C', 'D', 'E', 'E', 'A', 'D'},
{'B', 'B', 'E', 'C', 'C', 'D', 'E', 'E', 'A', 'D'},
{'B', 'B', 'A', 'C', 'C', 'D', 'E', 'E', 'A', 'D'},
{'E', 'B', 'E', 'C', 'C', 'D', 'E', 'E', 'A', 'D'}};
// Key to the questions
char[] keys = {'D', 'B', 'D', 'C', 'C', 'D', 'A', 'E', 'A', 'D'};
int[] count = new int[8];
int max = 0;
int m = 0;
int i = 0;
// Grade all answers
for ( i = 0; i < answers.length; i++) {
// Grade one student
for (int j = 0; j < answers[i].length; j++) {
if (answers[i][j] == keys[j])
count[i]++;
if(count[i] > max){
max = count[i];
m = i;
}
}
System.out.println("Student " + i + "'s correct count is " +
count[i]);
}
System.out.println("The higest student is : "+m+" and the sore is :"+max);
}
}
8.7.1答案：结果为：Valid Solution
8.8.1答案：int[][][] array = new int[4][5][6];
8.8.2答案：120个元素
x.length = 12
x[2].lngth = 5
x[0][0].length = 2
8.8.3答案：
1
8
9.3.1答案：类为对象定义属性和行为，而对象从类中创建
9.3.2答案：
public class ClassName {
}
9.3.3答案：ClassName objectRefVar;
9.3.4答案：new ClassName();
9.4.1答案：构造方法是一种特殊的方法。构造方法必须和所在类名字相同，构造方法没有返回值，甚至连void也没有，构造方法是在创建一个对象时由new操作符调用的，构造方法的作用是初始化对象
9.4.2答案：当且仅当类中没有明确定义任何构造方法时才会自动提供默认构造方法
9.5.1答案：操作符（.）用于访问对象的数据域或者调用对象的方法
9.5.2答案：匿名对象是指对象在创建后并不需要引用的对象。是指可以创建一个对象，而并不将它明确地赋予一个变量
9.5.3答案：NullPointException是一种常见的运行时错误，当调用值为null的引用变量上的方法时会发生此类异常。再通过引用变量调用一个方法之前，确保先将对象引用赋值给这个变量
9.5.4答案：在java中，数组被看做对象。数组可以包含对象类型的元素。在数组中，数值类型数据域的默认值是0，boolean类型数据域的默认值是false，char类型数据域的默认值是‘\u0000’，对象元素类型数据域的默认值是nulll
9.5.5答案：
（a）第三行把ShowErrors t = new ShowErrors(5);改成ShowErrors t = new ShowErrors();
（b）x() 不是ShowErrors类中的方法
（c）程序可以编译，但运行时错误。因为在执行println语句时c的数据域没有任何引用对象，这个数据域有一个特殊的引用值null
（d）有编译错误，因为c类没有带参数的构造方法
9.5.6答案：程序有编译错误，因为在main方法中使用了新的A(),但是A类没有默认的构造方法
9.5.7答案：false
9.6.1答案：可以使用Data类中的无参构造方法为当前的日期和时间创建一个实例，他的getTime（）方法返回自GMT时间1970年1月1日算起至今流逝的时间
9.6.2答案：使用它的构造函数Point2D（x，y）在（x，y）处创建Point2D对象，使用P1.distance（P2）获得p1和p2之间的距离。使用p1.midpoint（p2）获得p1和p2之间的中点。
9.6.3答案：Data和Random在java.util包中，Point2D在javafx.geometry包中，System和Math在java.lang包中
9.7.1答案：
System.out.println（f.i）；
System.out.println（f.s）；
f.imethod；
f.smethod；
System.out.println（F.s）
F.smethod（）；是正确的
9.7.2答案：void main之前和int factorIcal之前可以添加static
因为这两个方法不需要引用任何实例对象或调用Test类中任何实例方法
9.7.3答案：不可以从静态方法中调用或引用一个实例变量，可以从实例方法中调用静态方法或引用一个静态变量
下面代码错误在method2是一个静态方法，c是一个实例变量，不可以从静态方法中调用或引用一个实例变量
9.9.1答案：私有数据域不能被对象从定义该私有域的类外访问。但是经常会有客户端需要存取，修改数据域。为了访问私有数据域，可以提供一个获取（getter）方法返回数据域的值。为了更新数据域，可以提供一个设置（setter）方法给数据域设置新值。获取方法也称为访问器（accessor），而设置方法称为修改器（mutator）。访问器方法用于检索私有数据值，访问器方法用于更改私有数据值。
访问器方法的命名习惯是：非布尔型： getPropertyName（）；
布尔型为：isPropertyName（）；
修改器的命名习惯是：setPropertyName（dataType propertyValue）；
9.9.2答案：防止数据被篡改，使类更易于维护
9.9.3答案：不会有问题
私有数据可以在定义它们的类中被访问
9.10.1答案：
Count is 101
times is 0
9.10.2答案：
circle1 = 1 circle2 = 2
circle1 = 2 circle2 = 1
9.10.3答案：
（a）a[0] = 1 a[1] = 2
（b）a[0] = 2 a[1] = 21
（c）e1 = 2 e2 = 1
（d）
t1’s i = 2 t1’s j = 1
t1’s i = 2 t1’s j = 1
9.10.4答案：
（a）null
（b）1234567
（c）7654321
（d）1234567
9.11.1答案：dates[0]为null，所以第五行的代码将导致NullPointerException错误，因为null调用了toString方法。当调用值为null的引用变量上的方法时会发生NullPointerException错误
9.12.1答案：如果类中仅包含私有数据域并且没有设置 set 方法，该类没有不可变，它还必须有没有返回一个指向可变数据域的引用的访问器方法
9.12.2答案：如果类中的所有数据域是私有的基本数据类型，并且类中没有包含任何设置方法，该类不会改变
9.12.3答案：可以改变
因为值是数组，数组是引用类型，所以下面的类可以改变
9.13.1答案：
i + j is 23
k is 2
j is 0
9.14.1答案：关键字this是一个对象可以用来引用自身的引用名
9.14.2答案：第四行和第五行交换，因为java要求，在构造方法中语句this（arg-list）应在任何其他可执行语句之前出现
第十行和第十四行都将p = p改为this.p = p
9.14.3答案：Test.id = 45错了
因为id是实例变量，不是静态变量，不可以从类中访问
第十章
10.1:没有，Loan类具有返回loanDate的getLoanDate（）方法。LoanDate是Date类的对象。由于日期是可变的，所以是可以更改LoanDate的内容。
10.2: 程序清单10-4中的 BMI 类是不可变的。
10.3:类之间常用的关系是关联，聚合，组合和继承关系
10.4:关联是描述两个类之间活动的一般二进制关系。聚合是一种特殊的关联形式，它表示两个对象之间的所以权关系。一个对象可以由其他几个集合对象拥有，则该对象与其聚合对象之间的关系称为组合。
10.5: 在 UML 中，附加在聚集类上的实心菱形表示它和被聚集类之间具有组合关系；而附加在聚集类上的空心菱形表示它与被聚集类之间具有聚集关系
10.6:由于聚合和组合关系是以同样的方式使用类来表示，所以我们不会区分它们，并且为了简单而调用这两种组合。
10.8:
a. Integer i = new Integer(“23”);成功
b. Integer i = new Integer(23); 成功
c. Integer i = Integer.valueOf(“23”);成功
d. Integer i = Integer.parselnt(“23”, 8); 成功
e. Double d = new Double（）; 不成功
f. Double d = Double.value0f(“23.45”);成功
g. int i =(Integer.valueOf(“23”)).intValue();成功
h. double d «(Double.valueOf(“23.4”)).doubleValue（）;成功
i. int i =(Double.valueOf(“23.4”)).intValueO; 成功
j. String s =(Double.valueOf(“23.4”)).toString（）; 成功
10.9:使用Integer（int）.toString（）将整数转换为字符串，如果要将数字字符串转换成整数，可以使用Integer.parselnt（S）。使用Double(Double).toString()将Double转换成String。
10.10:输出结果为：
3
-1
10.11:输出结果为：
10
10
16
11
11
17
10.12:
a. Integer x = 3 + new Integer(S); 正确
b. Integer x = 3; 正确
c. Double x = 3; 错误
d. Double x = 3.0; 正确
e. int x = new Integer(3); 正确
f. int x = new Integer(3) + new Integer(4); 正确
10.13:输出结果为：
3
-1
10.14:输出结果为：
X is 3
Y is 7
Z is 10
10.15:输出结果为：
True
False
True
True
True
Welcome to HTML
WelcTme tT Java
Welctme tT Java
Welctme to Java
W, e, l, c, o, m, e,t,o,J,a,v,a
10.16:String s = “Welcome to Java”更好，因为字符串是一个不可变的类，String类中的任何方法都不能更改字符串的内容。
10.17:输出结果为：
Welcome to Java
Welcabcme tabc Java
10.18:
String s2 = s1.replace(‘e’,’E’);
String tokens = “Welcome to Java and HTML”.split(‘’);
S1 = tokens[0];
S2 = tokens[1];
10.19:String类中没有可以改变字符串内容的方法。
10.20:s是用new String（）创建的，那么s.length（）是等于0.
10.21：在String类中使用重载的静态值方法。
10.22：在第二行声明为成员变量，在第五行重新声明为局部变量。局部变量传递给构造函数的字符串是，成员变量认为NULL。在第十行的test.Text为NULL，这将在调用toLowerCase（）时导致NullPointerException。
10.23：构造函数错误，应去掉void
10.24：输出结果为：
False
True
A,B;C
A#B#C
A B C
10.25：输出结果为:3
10.26：JDK中引入的StringBuilder类与StringBuffer类似，只是StringBuffer中的更新方法是同步的。
10.27：使用StringBuilder的构造函数为字符串创建字符串缓冲区，并使用StringBuilder类中的toString方法从StringBuilder返回字符串。
10.28：StringBuilder sb = new StringBulider(s);
sb.reverse();
s = sb.
10.29：StringBuilder sb = new StringBulider(s);
sb.delete(4,10);
s = sb.toString();
10.30：字符串和字符串缓冲区都是使用数组来保存字符。创建字符串后，字符串中的数组是固定的。如果缓冲区容量发生变化，则字符串缓冲区中的数组可能会发生变化，为了适应改变，将创建一个新的数组。
10.31：输出结果为：
a)Java is fun
b)JavaHTML
c)Jais funva
d)JHTMLava
e) v
f) 4
g) Jav
h) Ja
i) avaJ
j) JComputera
k) av
l) va
10.32：输出结果为：
Java
Java and HTML
第十一章
11.1：一个子类是父类的子集，说法是false
11.2：extend
11.3：某些程序设计语言是允许从几个类派生出一个子类的。这种能力称为多重继承
( multiple inheritance)。但是在 Java 中是不允许多重继承的。一个 Java 类只可能直接继承自一个父类。这种限制称为单一继承（ single inheritance)。
11.4：a）中类的输出结果为：A’s no-arg constructor is invoked ; 创建B类的对象时，首先会构造B类的函数，在该程序内，是构造B类的无参构造函数，但在构造B类前，会首先构造父类A类的无参构造函数，因为A类显式的定义了构造方法，所以没有无参构造方法。
11.5：利用super关键字调用父类的构造方法，super（）或者super（argument）。
11.6：false，如果父类的显式的定义了构造方法，那么在子类构造无参方法前，无法调用父类的无参构造方法。
11.7：false，只能重写父类的可访问的方法
11.8：false，只能重写父类的可访问的方法
11.9：利用super（）或者super（arguments），而且super语句必须写在第一行。
11.10：利用super.method()或者super.method(args).
11.11：第5行：this.radius = radius;
第21行：super(radius);
第22行：this.length = length;
第27行：super.getArea() * length;
11.12：重栽意味着使用同样的名字但是不同的签名来定义多个方法。重写意味着在子
类中提供一个对方法的新的实现。方法重写发生在通过继承而相关的不同类中；方法重载可以发生在同一个类中，也可以发生在由于继承而相关的不同类中。方法重写具有同样的签名和返回值类型；方法重载具有同样的名字，但是不同的参数列表.
11.13：方法重写
11.14：这将是一个语法错误。
11.15：方法重载。
11.16：它强制编译器检查重写方法的签名，以确保正确定义该方法。
11.17：多态意味着父类的变量可以指向子类对象。方法可以在沿着继承链的多个类中实现。JVM 决定运行时调用哪个方法，这就是动态绑定。
11.18：匹配方法的签名和绑定方法的实现是两个不同的问题。引用变虽的声明类型决定了编译时匹配哪个方法。在编译时，编译器会根据参数类型、参数个数和参数顺序找到匹配的方法。一个方法可能在沿着继承链的多个类中实现dava 虚拟机在运行时动态绑定方法的实现，这是由变量的实际类型决定的。
11.19：new int[50]不能赋值给Object[]类型的变量，但是new Integer[50],new String[50]或者new Object[50]可以赋值给Object[].
11.20：第8行错误，因为int[]不能赋值给Object[].
11.21：输出结果为：
（1）Person Person
Student Person
11.22：输出结果为：B’s constructor is invoked A’s constructor is invoked
在调用new A（3）时，将调用对象的默认构造函数，在执行B的构造函数中的任何语句前调用对象的构造函数。
11.23：输出结果为：
I from A is 40
I from A is 60;
I from B is 60;
11.24：True :总可以将子类实例转换为父类；
False ：父类的实例不一定都可以转换成子类。
11.25：
(circle instanceof GeometricObject) true
(object instanceof GeometricObject) true
(circle instanceof Circle) true
(object instanceof Circle) false
b. 下面的语句能够成功编译吗？
Circle circle = new Circle(5); 可以成功编译
GeometricObject object = circle;
c. 下面的语句能够成功编译吗？ 不能成功编译
GeometricObject object = new GeometricObjectO;
Circle circle = (Circle)object;
11.26：
A）true
B）false
C）true
D）true
E）false
F）true
G）true
H）false
I）可以 ； 不可以
J）可以 ； 不可以
K）不合法
L）不合法
M）合法
11.27：语句Object apple = (Apple)fruit;会导致ClassCastingException错误。
11.28：是的，每一个对象都有toString方法和equals方法，因为他们来自Object类，并且他们也是java类所可以访问的，重写这些方法合适。
11.29：输出结果为：a）False b）True
11.30：
A) ArrayList list = new ArrayList ();
B) list.add(object);
C) list.add(0, object);
D) list.size();
E) list.remove(object);
F) list.remove(list.size() - 1);
G) list.contains(object);
H) list.get(index)
11.31：list.add(new java.util.DateO);错误，因为你创建的是字符串数组，而不是Date类型的数组；list.set(3,“Dallas”)；System.out println(list.get(3)); 语句错误，因为无法找到下标为3的数组元素。
11.32：调用一次list.remove(“Dallas”)后的列表为{“Dallas”，“Houston”，“Dallas”}，
修改列表，使得删除所有具有值“Dallas”。
for (int I = 0; I < list.size(); i++){
if (list.remove(“Dallas”))
i–;
}
11.33：因为ArrayList类有两种重载方法，分别是remove（index）和remove（object），所以list.remove(1)表示去除下标为1的元素，所以结果为[2, 3]
11.34：是double型的数据，所有改为list.add(1.0);
11.35：改为：
ArrayList array = {3, 5, 95, 4, 15, 34, 3, 6, 5};
ArrayList list = new ArrayList<> (Arrays.asList(array));
11.36：改为：
ArrayList array = {3, 5, 95, 4, 15, 34, 3, 6, 5};
11.37：default修饰符
11.38:protected修饰符
11.39:可以； 不可以； 可以
11.40:不可以； 不可以； 可以
11.41:使用final关键字。
11.42:
a)true
b)false
c)true
d)true
e)false
f)false
第十二章
12.1：它能使方法抛出一个异常给它的调用者，并由调用者处理该异常。如果没有这个能力，那么被调用的方法就必须自己处理异常或者终止该程序。被调用的方法通常不知道在出错的情况下该做些什么，这是库方法的一般情况。库方法可以检测出错误，但是只有调用者才知道出现错误时需要做些什么。异常处理最根本的优势就是将检测错误（由被调用的方法完成）从处理错误（由调用方法完成）中分离出来。
12.2：第一条语句：System.out.println(1 / 0)；会抛出异常。
12.3：将Long.MAX_VALUE加上1会超出long值的范围，但是当前的java没有把这种情况报告为例外。
12.4：出现异常时，JVM会抛出异常，如果需要捕获异常，可以编写try-catch语句。
12.5：如果value = 30，则输出结果为：
Value is too small
Continue after the catch block
如果value = 50，则输出结果为：
Continue after the catch block
12.6：输出结果为：
a)0 1
b)0
12.7：Throwable 类是所有异常类的根。所有的 Java 异常类都直接或者间接地继承自
Throwable。这些异常类可以分为三种主要类型：系统错误、异常和运行时异常。
12.8：将抛出异常名为：
a）ArithmeticException
b）IndexOutOfBoundsException
c）IndexOutOfBoundsException
d）ClassCastException
e）NullPointerException
f）No exception
12.9：声明异常的目的是告诉java运行时系统可能会出现的异常情况，可以在方法声明中使用抛出关键字声明异常，可以声明多个异常，用逗号隔开。
12.10：由于这个方法抛出 RuntimeException (免检异常）子类 rilegalArgumentException的一个实例，所以，如果不使用 try语句，这个测试程序也能编译。如果方法抛出 RuntimeException和 Error 之外的异常（即必检异常），那么此方法就必须在 try-catch 块内调用。
12.11：使用方法中抛出语句抛出异常，即throw（exceptionName），不可以在throw语句中抛出多个异常。
12.12：关键字throw是抛出异常的关键字，关键字throws是声明异常的关键字。
12.13：
1）不会执行statement3.
2）不会执行statement4，因为try语句执行完后程序就结束了。
3）会执行statement4.
12.14：显示：RuntimeException
12.15：显示：ArithmeticException
12.16：显示：RuntimeException in method()
After the method call
12.17：getMessage()在Throwable类中被定义，以返回描述异常的字符串。
12.18：若要向控制台显示跟踪信息，可以执行的操作。
12.19：没有异常发生时，try-catch 块的存在不会引起额外的系统开销。
12.20：代码修改为：
public void m(int value) throws Exception{
if(value < 40)
throw new Exception(“value is too small”);
}
12.21：
1)如果没有异常发生，会执行statement4，也会执行statement5.
2如果异常类型是 Exceptionl, 会执行 statement4，也会执行 statements5.
3如果异常不是类型 Exceptionl,会执行 statement，不会执行 statements5.
12.22：该方法是正确的，但是有一点，不要把异常处理用作简单的逻辑测试。
public static Boolean isNumeric(String token) {
for (int I = 0; I < token.length(); i++) {
if (!(token.chatAt(i) >= ‘0’&& token.chatAt(i) <= ‘9’)) {
return false;
}
}
return true;
}
12.23：
如果没有异常发生，会执行语句 statement4,也会执行语句 statement5。
如果异常类型是 Exceptionl，会执行 statement4，也会执行 statement5.
如果异常类型是 Exception2，会执行 statement4 ，不会执行 statement5。
如果异常类型不是 Exceptionl以及 Exception2 类型的，那么会执行 statement4 ，不会执行 statement5 。
12.24：输出结果为：
java.lang.Exception: New info from methodl
at ChainedExceptionDemo.methodlfChainedExceptionDemo.java:16)
at ChainedExceptionDemo.main(ChainedExceptionDemo.java:4)
12.26：输出结果为：
Exception in method（）
Exception in main
12.27：在 Windows 中目录的分隔符是反斜杠（)。但是在 Java 中，反斜杠是一个特殊的
字符，应该写成 \的形式，故改为：new File（“c：\book\test.dat”）;
12.28:创建一个file对象，利用file.exists()表示文件是否存在,file.delete()表示删除文件,file.renameTo(File)表示重命名文件名，使用file.length()表示获得文件的大小。
12.29:不能使用File类进行输入/输出，File类可用于获取文件的属性和操作文件；不是创建一个 File 对象就是在磁盘上创建一个文件。
12.30:创建对象 PrintWriter output = new PrintWriter(FileName);以向文件写数据。此语句可能引发异常，java迫使你编写代码来处理异常，处理它的一种方法是在方法声明中声明抛出异常。如果不调用close（）方法，则可能无法正确保存数据。
12.31:输出结果为：
Amount is 32.320000 3.232000e+01
Amount is 32.3200 3.2320e+01
False
Java
12.32:
public class Test {
public static void main (String[] args) throws Exception {
try(java.io.PrintWriter output = new java.io.PrintWriter(“temp.txt”)) {
output.printf(“amount is %f %e\r\n”, 32.32, 32.32);
output.pr1ntf(“amount 1s %5.4f %5.4e\r\n, 32.32,32.32);
output.printf(”%6b\r\n",(1 > 2));
output.printf(“%6s\r\n”,“java”);
output.close();
}
}
12.33:Scanner input = new Scanner(FileName);从文件读取数据。Main方法中的语句可能会引发异常，java你迫使编写代码来处理异常，处理异常的一种方法就是在方法声明中声明抛出异常。如果不调用close（）方法，则可能无法正确保存数据。
12.34如果试图对一个不存在的文件创建 Scanner，程序将会出现异常；如果试图对一个已经存在的文件创建 PrintWriter，则现有的文件内容将消失。
12.35:不同平台上的行分隔符不同，windows平台上的行分隔符是\n.
12.36:intValue = 45; doubleValue = 57.8; line = ‘’‘7’‘8’‘9’。
12.37: intValue = 45; doubleValue = 57.8; line = ‘’
12.38:创建一个URL对象，并使用行动Scanner（url.openStream()）创建一个Scanner对象，用于读取URL流中的数据。
12.39:有可能包含重复的URL。假设链接1不在listOfTraverseURL中，但它可能在一个页面中出现不止一次。这样的重复链接1将添加到listOfPendingURL中。
第十三章
13.1：e和f是合法的抽象类。
13.2：其好处是适用于通用编程，GeometricObject类型的变量在编译时使用getArea（）和getPerimeter（）方法。
13.3：输出结果为：
True
True
False
False
True
13.4：在运行时，java虚拟机将尝试将numberRef转换为Double对象，但是numberRef是Integer的一个实例，而不是Double。
13.5：数组numberArray是Integer对象的数组，而非Double对象的数组
13.6：输出结果：3 3.0.
13.7：会出现语法错误，x没有compareTo方法。
13.8：会出现语法错误，因为成员操作符在对象转换操作符之前完成。
13.9：不能，Calendar是一个抽象类。
13.10：Calendar方法中的add方法是抽象的。
13.11：使用GregorianCalendar类的构造函数来创建Calendar对象。
13.12：
c.get(Calendar.YEAR)
c.get(Calendar.MONTH)
c.get(Calendar.DAY_OF_MONTH)
c.get(Calendar.HOUR)
c.get(Calendar.MINUTE)
c.get(Calendar.SECOND)
13.13：不能
13.14：可以
13.15：d是正确的接口。
13.16：所以定义在接口的方法必须为public的，当类实现接口时，方法必须声明为public，能见度不能降低，故在void m1（）前加上public。
13.17：true
13.18：第一个：public int compareTo （String o）
13.19：不能，因为n1是Integer对象，其compareTo方法需要Integer参数，但n2被声明为Object对象，编译器将引发错误。
13.20：通过实现可比较的接口，可以将类的对象传递给需要比较类型的方法。
13.21：Person类没有实现Comparable接口，所以Person对象无法通过sort方法比较。
13.22：如果一个对象的类没有实现 java.lang.Cloneable , 不可以调用 clone() 方法来克隆这个对象；Date类实现了Cloneable接口。
13.24：输出结果为：
True
False
True
13.25：输出结果为：
True
False
List is 【New York, Atlanta】
List1 is [New York, Atlanta]
List2.get(0) is New York
List2.size() is 1
13.26：语法错误，因为clone（）在对象中受到保护，要启用clone（）可以执行两件事：（1）为要克隆的对象覆盖类中的clone（）；（2）为类实现java.lang.Cloneable。
13.29：结果为：
True
False
True
False
True
13.30：输出结果为：
-1
3
0
0.333333333333
13.31：Object类型的r2没有compareTo方法。
13.32：Rational.compareTo(Rational)方法在Ration类的参数中需要一个Ration类型的对象。
13.33：return(this.subtract((Rational)(other))).getNumberator() == 0;
13.34：0 / 4。
