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。