第 1 章 Java語言概述
Java語言有哪些特點？
簡單易學、面向對象、平臺無關性、可靠性、安全性、支持多線程、支持網絡編程、編譯與解釋並存什麼是Java的虛擬機？
任何一種可以運行Java字節碼的軟件均可看成是Java的虛擬機什麼是字節碼？採用字節碼的最大好處是什麼？
字節碼是Java虛擬機的指令組，和CPU上的微指令很相似 。字節碼最大的好處是可跨平臺運行什麼是平臺無關性？Java語言是怎樣實現平臺無關性的？
編寫的應用程序不用修改就可以在不同的軟硬件平臺上運行。Java語言是靠JVM在目標代碼級實現平臺無關性的，可以說JVM是Java平臺無關的基礎Java語言程序有幾種？他們包含哪幾個方面？
Application應用程序和Applet小程序什麼是Java程序的主類？
Java應用程序的主類必須包含一個定義爲`public static void main(String[] args)`；Java小程序的主類必須是一個繼承自系統JApplet或Applet的子類，且該類必須是public類。
第 3 章 Java語言基礎
Java語言定義了哪幾種基本數據類型？
8種基本數據類型。byte, short, int, long, float, double, char表示整數類型數據的關鍵字有哪幾個？他們各佔用幾個字節？
byte, short, int, long分別佔 1, 2, 4, 8個字節單精度浮點float和雙精度浮點double的區別是什麼？
單精度浮點數的數據位是32位，雙精度浮點數的數據位是64位，double的精度是float的兩倍字符型常量與字符串常量的主要區別是什麼？
字符型常量是用一對單引號括起來的單個字符，字符串常量是用雙引號括起來的一串若干個字符（可以是0個）簡述Java語言對定義標識符的規定有哪些。
標識符可以由字母、數字和下劃線、美元符號等組合而成，標識符必須以字母、下劃線或美元符號開頭，不能以數字開頭Java語言採用何種編碼方案？有何特點？
Unicode字符集編碼方案，便於西文字符和中文字符的處理什麼是強制類型轉換？在什麼情況下需要強制類型轉換？
強制類型轉換就是將長數據轉換爲短數據。如果要將較長的數據轉換成較短的數據時，就要進行強制類型轉換。自動類型轉換得前提是什麼？轉換是從”短”到”長”的優先級順序是怎樣的？
轉換前的數據類型與轉換後的類型兼容，轉換後的數據類型的表示範圍比轉換前的類型大。byte→short→char→int→long→float→double數字字符串轉換爲數值型數據時，所使用的方法有哪些？
| 轉換的方法 | 功能說明 |
|---|---|
| Byte.parseByte(String s) | 將數字字符串轉換爲字節型數據 |
| Short.parseShort(String s) | 將數字字符串轉換爲短整型數據 |
| Integer.parseInteger(String s) | 將數字字符串轉換爲整型數據 |
| Long.parseLong(String s) | 將數字字符串轉換爲長整型數據 |
| Float.parseFloat(String s) | 將數字字符串轉換爲浮點型數據 |
| Double.parseDouble(String s) | 將數字字符串轉讓爲雙精度型數據 |
| Boolean.parseBoolean(String s) | 將字符串轉換爲布爾型數據 |
寫出由鍵盤輸入數據的兩種基本格式。
在1.5版本之前，Java用BufferedReader來讀取輸入數據，在1.5版本之後，Java用Scanner來讀取輸入數據
import java.io.*;
public class Buffer {
public static void main(String[] args) throws IOException {
String str;
BufferedReader buf = new BufferedReader(new InputStreamReader(System.in));
str = buf.readLine();
}
}import java.io.*;
import java.util.*;
public class Scan {
public static void main(String[] args) throws IOException {
Scanner sc = new Scanner(System.in);
double num = sc.nextDouble();
}
}編寫程序，從鍵盤上輸入一個浮點數，然後將該浮點數的整數部分輸出。
浮點數的輸入用double或者float，第一種方法用BufferedReader來讀，第二種方法用Scanner來讀
import java.io.*;
public class Exercise {
public static void main(String[] args) throws NumberFormatException, IOException {
BufferedReader buff = new BufferedReader(new InputStreamReader(System.in));
double num = Double.parseDouble(buff.readLine());
int i = (int) num;
System.out.println(i);
}
}import java.util.*;
public class Exercise {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
double t = in.nextDouble();
int num = (int) t;
System.out.println(num);
}
}- 編寫程序，從鍵盤上輸入兩個整數，然後計算他們相除後得到的結果並輸出。
import java.util.*;
public class Exercise {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int a = in.nextInt();
int b = in.nextInt();
System.out.println(a / b);
}
}編寫程序，從鍵盤上輸入圓柱體的底半徑r和高h，然後計算其體積並輸出。
這裏要用到Math.PI，假設題目給出的半徑r和高h都是整形數值
import java.util.*;
public class Exercise {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int r = in.nextInt();
int h = in.nextInt();
System.out.println(Math.PI * r * r * h);
}
}Java語言有哪些基本的運算符？
算術運行符包括 +、-、*、/、%、++、-- 關係運算符包括 >、<、>=、<=、==、!= 邏輯運算符包括 !、&&、||、&、| 位運算符包括 >>、<<、>>>、&、|、^、~ 賦值運算符包括 = 條件運算符 ?: 分量運算符 . 下標運算符 [] 實例運算符 instanceof 內存分配運算符 new 強制類型轉換運算符 (類型) 方法調用運算符 ()邏輯運算符中“邏輯與、邏輯或”和“簡潔與、簡潔或”的區別是什麼？
非簡潔運算在必須計算完左右兩個表達式之後，才取結果值；而簡潔運算可能只計算左邊的表達式而不計算右邊的表達式，即對於 &&，只要左邊的表達式爲 false，就不計算右邊的表達式，則整個表達式爲 false；對於 ||，只要左邊表達式爲 true，就不計算右邊表達式，則整個表達式爲 true。邏輯運算符與位運算符的區別是什麼？
位運算符的操作數只能爲整型或字符型數據，雖然有的位運算符號（如 &、|、^）與邏輯運算符的寫法相同，但邏輯運算符的操作數爲boolean型的量什麼是運算符的優先級和結合性？
運算符的優先級決定了表達式中不同運算執行的先後順序，運算符的結合性決定了並列的多個同級運算符的先後執行順序寫出下列表達式的值，設x=3, y = 17, yn = true。
(1) x + y * x-- 3 + 17 * 3； 54 (2) -x * y + y -3 * 17 + 17； -34 (3) x < y && yn 3 < 17 && true; true (4) x > y || !yn 3 > 17 || false; false (5) y != ++x ? x : y 17 != 4 ? 4 : 17; 4 (6) y++ / --x 17 / 2; 8 (7) --y >>> 3 16 >>> 3; 2
第 4 章 流程控制
- 將學生的學習成績按不同的分數段分爲優、良、中、及格和不合格五個等級，從鍵盤上輸入一個0~100之間的成績，輸出相應的等級。要求用switch語句實現。
import java.util.*;
public class Exercise {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int score = in.nextInt();
switch (score / 10) {
case 10:
case 9:
System.out.println("優");
break;
case 8:
System.out.println("良");
break;
case 7:
System.out.println("中");
break;
case 6:
System.out.println("及格");
break;
default:
System.out.println("不合格");
break;
}
}
}- 設學生的學習成績按如下的分數評定爲四個等級：85~100爲A，70~84爲B，60~69爲C，0~59爲D。從鍵盤上輸入一個0~100之間的成績，要求用switch語句根據成績，評定並輸出相應的等級。
import java.util.*;
public class Exercise {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int score = in.nextInt();
switch (score / 10) {
case 10:
case 9:
System.out.println("A");
break;
case 8:
if (score % 10 >= 5)
System.out.println("A");
else
System.out.println("B");
break;
case 7:
case 6:
System.out.println("C");
break;
default:
System.out.println("D");
break;
}
}
}
- 編寫一個Java應用程序，輸入1~100之間所有既可以被3整除，又可被7整除的數。
public class Exercise {
public static void main(String[] args) {
for (int i = 1; i <= 100; i++) {
if (i % 3 == 0 && i % 7 == 0)
System.out.println(i);
}
}
}- 編寫一個Java應用程序，在鍵盤上輸入數n，計算並輸出1!+2!+…+n!的結果
import java.util.*;
public class Exercise {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int n = in.nextInt();
long sum = 0, temp = 1;
for (int i = 1; i <= n; i++) {
temp *= i;
sum += temp;
}
System.out.println(sum);
}
}- 在鍵盤上輸入數n，編程計算sum = 1 – (1 / 2!) + (1 / 3!) - … + ((-1)^(n - 1))*(1 / n!)。
import java.util.*;
public class Exercise {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int n = in.nextInt();
double sum = 0;
int sign = 1, temp = 1;
for (int i = 1; i <= n; i++) {
temp *= i;
sum += sign * (1.0 / temp);
sign = -sign;
}
System.out.println(sum);
}
}- 水仙花數是指其個位、十位和百位三個數字的立方和等於這個三位數本身，求出所有的水仙花數。
public class Exercise {
public static void main(String[] args) {
for (int i = 100; i <= 999; i++) {
int temp = i, sum = 0;
while (temp != 0) {
sum += Math.pow(temp % 10, 3);
temp /= 10;
}
if (sum == i)
System.out.println(i);
}
}
}- 從鍵盤輸入一個整數，判斷該數是否是完全數。完全數是指其所有因數（包括1但不包括其本身）的和等於該數自身的數。例如，28 = 1 + 2 + 4 + 7 + 14 就是一個完全數。
import java.util.*;
public class Exercise {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int num = in.nextInt();
int sum = 0;
for (int i = 1; i < num; i++) {
if (num % i == 0)
sum += i;
}
System.out.println(sum == num);
}
}- 計算並輸出一個整數各位數字之和。如，5423 的各位數字之和爲 5 + 4 + 2 + 3。
import java.util.*;
public class Exercise {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int num = in.nextInt();
int sum = 0;
while (num != 0) {
sum += num % 10;
num /= 10;
}
System.out.println(sum);
}
}- 從鍵盤上輸入一個浮點型數，然後將該浮點數的整數部分和小數部分分別輸出。
import java.util.*;
public class Exercise {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
double num = in.nextDouble();
int digital = (int) num;
System.out.println(digital + " " + (num - digital));
}
}- 設有一長爲 3000m 的繩子，每天減去一半，問需幾天時間，繩子的長度會短於 5m。
public class Exercise {
public static void main(String[] args) {
int day = 0;
double len = 3000;
while (len >= 5) {
len /= 2;
day++;
}
System.out.println(day);
}
}- 編程輸出如下的數字圖案：
1 3 6 10 15
2 5 9 14
4 8 13
7 12
11
public class Exercise {
public static void main(String[] args) {
int[][] matrix = new int[5][5];
int k = 1;
for (int i = 0; i < 5; i++) {
for (int j = 0; j <= i; j++)
matrix[i - j][j] = k++;
}
for (int i = 0; i < 5; i++) {
for (int j = 0; j < 5 - i; j++)
System.out.print(matrix[i][j] + " ");
System.out.println();
}
}
}第 5 章 數組與字符串
簡述 Java 內存分配的機制。
Java 語言把內存分爲兩種：棧內存和堆內存。 在方法中定義的一些基本類型的變量和對象的引用變量都在方法的棧內存中分配，當在一段代碼塊中定義一個變量時，Java 就在棧內存中爲這個變量分配內存空間，當超出變量的的作用域後，Java 會自動釋放掉爲該變量分配的內存空間。 堆內存用來存放由 new 運算符創建的對象和數組，在堆中分配的的內存，由 Java 虛擬機的自動垃圾回收器來管理。在堆中創建了一個數組或對象後，同時還在棧中定義一個特殊的變量，讓棧中的這個變量的取值等於數組或對象在堆內存中的首地址，棧中的這個變量就成了數組或對象的引用變量，引用變量實際上保存的是數組或對象在堆內存中的地址（也稱爲對象的句柄），以後就可以在程序中使用棧的引用變量來訪問堆中的數組或對象。數組的主要特點：
- 數組是相同數據類型的元素的集合。 - 數組中的各元素是有先後順序的，它們在內存中按照這個先後順序連續存放在一起。 - 數組元素用整個數組的名字和它自己在數組中的順序位置來表示。例如 a[0] 表示名字爲 a 的數組中的第一個元素。String 類的常用方法
| 方法 | 說明 |
|---|---|
public int length() |
返回字符串的長度 |
public boolean equals(Object anObject) |
將給定字符串與當前字符串相比較，若兩字符串相等，則返回 true，否則返回 false |
public String substring(int beginIndex) |
返回字符串中從 beginIndex 開始的子串 |
public String substring(int beginIndex, int endIndex) |
返回從 beginIndex 開始到 endIndex 的子串 |
public char charAt(int index) |
返回 index 指定位置的字符 |
public int indexOf(String str) |
返回 str 在字符串中第一次出現的位置 |
public String toLowerCase() |
將字符串中所有的字符都轉換爲小寫字符 |
public String toUpperCase() |
將字符串中所有的字符都轉換爲大寫字符 |
- 從鍵盤輸入 n 個數，輸出這些數中大於其平均值的數。
import java.util.*;
public class Exercise {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int n = in.nextInt();
int[] num = new int[n];
double aver = 0;
for (int i = 0; i < n; i++) {
num[i] = in.nextInt();
aver += num[i] * 1.0 / n;
}
for (int i = 0; i < n; i++) {
if (num[i] >= aver)
System.out.println(num[i]);
}
}
}- 從鍵盤輸入 n 個數，求這 n 個數中最大數與最小數並輸出。
import java.util.*;
public class Exercise {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int n = in.nextInt();
int max = Integer.MIN_VALUE;
int min = Integer.MAX_VALUE;
for (int i = 0; i < n; i++) {
int temp = in.nextInt();
if (temp > max)
max = temp;
if (temp < min)
min = temp;
}
System.out.println("Max: " + max + "\n" + "Min: " + min);
}
}- 求一個 3 階方陣的對角線上各元素之和。
int[][] matrix = new int[3][3];
int sum = 0;
for (int i = 0; i < 3; i++) {
sum += matrix[i][i];
sum += matrix[2 - i][i];
}- 找出 4 × 5 矩陣中值最小和最大元素，並輸出其值及所在行號和列號。
public class Exercise {
public static void main(String[] args) {
int[][] matrix;
matrix = new int[][]{{12,23,34,15,7},{23,14,61,45,78},{3,12,43,54,65},{34,56,87,54,23}};
int minRow = 0, minCol = 0, maxRow = 0, maxCol = 0;
for (int i = 0; i < 4; i++) {
for (int j = 0; j < 5; j++) {
if (matrix[minRow][minCol] > matrix[i][j]) {
minRow = i;
minCol = j;
}
if (matrix[maxRow][maxCol] < matrix[i][j]) {
maxRow = i;
maxCol = j;
}
}
}
System.out.println("min: " + matrix[minRow][minCol] + "\n" + minRow + " " + minCol + "\n\n" + "max: " + matrix[maxRow][maxCol] + "\n" + maxRow + " " + maxCol);
}
}- 產生 0 ～ 100 之間的 8 個隨機整數，並用冒泡排序將其升序排序後輸出（冒泡排序算法：每次進行相鄰兩數的比較，若次序不對，則交換兩數的次序）。
import java.util.*;
public class Exercise {
public static void main(String[] args) {
int[] num = new int[8];
Random random = new Random();
for (int i = 0; i < 8; i++) {
num[i] = random.nextInt() % 100;
}
for (int i = 0; i < 7; i++) {
for (int j = 0; j < 7 - i; j++) {
if (num[j] > num[j + 1]) {
int temp = num[j];
num[j] = num[j + 1];
num[j + 1] = temp;
}
}
}
for (int i = 0; i < 8; i++) {
System.out.print(num[i] + " ");
}
}
}- 15 個紅球和 15 個綠球排成一圈，從第一個球開始數，當數到第 13 個球時就拿出此球，然後再從下一個球開始數，當再數到第 13 個球時又取出此球，如此循環進行，直到僅剩 15 個球爲止，問怎樣排法才能使每次取出的球都是紅球。
public class Exercise {
public static void main(String[] args) {
int[] ball = new int[30];
for (int j = 0, temp = 0; temp <= 15; temp++) {
int count = 1, i = j;
while (count < 13 || ball[i] == 1) {
if (ball[i] != 1)
count++;
i++;
if (i == 30)
i = 0;
}
ball[i] = 1;
j = i + 1;
if (j == 30)
j = 0;
}
for (int i = 0; i < 30; i++) {
System.out.print(ball[i] + " ");
}
}
}- 編寫 Java 應用程序，比較命令行中給出的兩個字符串是否相等，並輸出比較結果。
public class Exercise {
public static void main(String[] args) {
System.out.println(args[0].equals(args[1]));
}
}- 從鍵盤上輸入一個字符串和子串開始位置與長度，截取該字符串的子串並輸出。
import java.util.*;
public class Exercise {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
String s = in.next();
int start = in.nextInt(), len = in.nextInt();
System.out.println(s.substring(start, start + len));
}
}- 從鍵盤上輸入一個字符串和一個字符，從該字符串中刪除給定的字符。
import java.util.*;
public class Exercise {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
String s = in.next();
char c = in.next().charAt(0);
for (int i = 0; i < s.length(); i++) {
if (s.charAt(i) != c)
System.out.print(s.charAt(i));
}
}
}- 編程統計用戶從鍵盤輸入的字符串中所包含的字母，數字和其它字符的個數。
import java.util.*;
public class Exercise {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
String s = in.nextLine();
int ch = 0, digital = 0, other = 0;
for (int i = 0; i < s.length(); i++) {
char c = s.charAt(i);
if ((c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z'))
ch++;
else if (c >= '0' && c <= '9')
digital++;
else
other++;
}
System.out.println(ch + " " + digital + " " + other);
}
}- 將用戶從鍵盤輸入的每行數據都顯示輸出，直到輸入字符串“exit”，程序運行結束。
import java.util.*;
public class Exercise {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
String data = "";
do {
data = in.nextLine();
if ("exit".equals(data))
break;
System.out.println(data);
} while (true);
}
}第 6 章 類與對象
類與對象的區別是什麼？
類是對某一類事物的描述，是抽象的、概念上的定義；對象則是實際存在的屬該類事物的具體的個體，對象是類的實例化，因而也稱爲實例（instance）。如何定義一個類？類的結構是怎樣的？
定義類實際上就是定義類的屬性與方法。
// 類的一般結構如下：
[類修飾符] class 類名稱
{
[修飾符] 數據類型 成員變量名稱;
[修飾符] 返回值的數據類型 方法名(參數1, 參數2, ......)
{
語句序列;
return [表達式];
}
}定義一個類時所使用的修飾符有哪幾個？每個修飾符的作用是什麼？是否可以混用？
定義一個類時所使用的修飾符有 4 個，一個類可以有多個修飾符，且無先後順序之分，但 abstract 和 final 相互獨立，所以不能同時應用在一個類的定義中，每個修飾符的作用如下：
| 修飾符 | 含義 |
|---|---|
public |
將一個類聲明爲公共類，它可以被任何對象訪問 |
abstract |
將一個類聲明爲抽象類，沒有實現方法，需要子類提供方法的實現，所以不能創建該類的實例 |
final |
將一個類聲明爲最終類即非繼承類，表示它不能被其他類所繼承 |
缺省 |
缺省修飾符時，則表示只有在相同包中的對象才能使用這樣的類 |
成員變量量的修飾符有哪些？各修飾符的功能是什麼？是否可以混用？
成員變量的修飾符有 8 個，除了訪問控制修飾符有多個外，其他的修飾符都只有一個，每個修飾符的功能如下：
| 修飾符 | 含義 |
|---|---|
public |
公共訪問控制符。指定該變量爲公共的。它可以被任何對象的方法訪問 |
private |
私有訪問控制符。指定該變量只允許自己類的方法訪問，其他任何類（包括子類）中的方法均不能訪問此變量 |
protected |
保護訪問控制符。指定該變量只可以被它自己的類及其子類或同一包中的其它類訪問，在子類中可以覆蓋此變量 |
缺省 |
缺省訪問控制符。表示在同一個包中的其他類可以訪問此成員變量，其他包中的類不能訪問該成員變量 |
final |
最終修飾符。指定此變量的值不能改變 |
static |
靜態修飾符。指定該變量被所有對象共享，即所有實例都可以使用該變量 |
transient |
過度修飾符。指定該變量是一個系統保留，暫無特別作用的臨時性變量 |
volatile |
易失修飾符。指定該變量可以同時被幾個線程控制和修改 |
成員方法的修飾符有哪些？各修飾符的功能是什麼？是否可以混用？
成員方法的修飾符有 9 個，成員方法與成員變量同樣有多個控制修飾符，當用兩個以上的修飾符來修飾一個方法時，需要注意，有的修飾符之間是互斥的，所以不能同時使用。
| 修飾符 | 含義 |
|---|---|
public |
公共訪問控制符。指定該方法爲公共的，它可以被任何對象的方法訪問 |
private |
私有訪問控制符。指定該方法只允許自己類的方法訪問，其他任何類（包括子類）中的方法均不能訪問此方法 |
protected |
保護訪問控制符。指定該方法只可以被它的類及其子類或同一包中的其他類訪問 |
缺省 |
缺省訪問控制符。表示在同一個包中的其他類可以訪問此成員方法，其他包中的類不能訪問該成員方法 |
final |
最終修飾符。指定該方法不能被重載 |
static |
靜態修飾符。指定不需要實例化一個對象就可以激活的方法 |
abstract |
抽象修飾符。指定該方法只聲明方法頭，而沒有方法體，抽象方法需在子類中被實現 |
synchronized |
同步修飾符。在多線程程序中，該修飾符用於在運行前，對它所屬的方法加鎖，以防止其他線程訪問，運行結束後解鎖 |
native |
本地修飾符。指定此方法的方法體是用其他語言（如 C）在程序外部編寫的 |
成員變量與局部變量的區別有哪些？
由類和方法的定義可知，在類和方法中均可定義屬於自己的變量。類中定義的變量是成員變量，而方法中定義的變量是局部變量。 1. 從語法形式上看，成員變量是屬於類的，而局部變量是在方法中定義的或是方法的參數；成員變量可以被 public、private、static 等修飾符所修飾，而局部變量則不能被訪問控制符及 static 所修飾；成員變量和局部變量都可以被 final 修飾。 2. 從變量在內存中的存儲方式上看，成員變量是對象的一部分，而對象是存在與堆內存中的，而局部變量是存在與棧內存中的。 3. 從變量在內存中的生存時間上看，成員變量是對象的一部分，它隨着對象的創建而存在，而局部變量隨着方法的調用而產生，隨着方法調用的結束而自動消失。 4. 成員變量如果沒有被賦初值，則會自動以類型的默認值賦值（有一種情況例外，被 final 修飾但沒有被 static 修飾的成員變量必須顯式的賦值）；而局部變量則不會自動賦值，必須顯式地賦值後才能使用。創建一個對象使用什麼運算符？對象實體與對象的引用有何不同？
創建一個對象使用 new 運算符；對象實體是實在存在於堆內存中的，而對象的引用是管理對象實體的句柄存在於棧內存中。對象的成員如何表示？
對象的成員通過對象名.對象成員來訪問。在成員變量或成員方法前加上關鍵字 this 表示什麼含義？
this.成員名 表示 對象本身的成員。this 代表調用此成員的對象。什麼是方法的返回值？返回值在類的方法裏面的作用是什麼？
方法的返回值是指我們獲取到的某個方法體中的代碼執行後產生的結果！（前提是該方法可能產生結果）。返回值的作用:接收產生的結果，使得它可以用於其他的操作。在方法調用中，使用對象作爲參數進行傳遞時，是“傳值”還是“傳址”？對象作參數起到什麼作用？
當參數是基本類型數據時，則是傳值方式調用，而當參數是引用型的變量時，則是傳址方式調用。什麼叫匿名對象？一般在什麼情況下使用匿名對象？
當一個對象被創建之後，在調用該對象的方法時，也可以不定義對象的引用變量，而直接調用對象的方法，這樣的對象叫做匿名對象。 使用匿名對象通常有如下兩種情況： 1. 如果對一個對象只需要進行一次方法調用，那麼就可以使用匿名對象。 2. 將匿名對象作爲實參傳遞給一個方法調用。定義一個 Student 類，包含的內容如下：
成員變量：學號，姓名，性別，班幹部否，數學，語文，外語 成員方法：輸入，總分，平均分 編程實現這個類，並調用相應的方法輸入數據，計算總分和平均分。
import java.util.*;
public class Student {
private String id;
private String name;
private String gender;
private String isLeader;
private int math;
private int chinese;
private int english;
public void input() {
Scanner in = new Scanner(System.in);
id = in.next();
name = in.next();
gender = in.next();
isLeader = in.next();
math = in.nextInt();
chinese = in.nextInt();
english = in.nextInt();
in.close();
}
public int total() {
return math + chinese + english;
}
public double aver() {
return total() / 3.0;
}
}- 以 m 行 n 列二維數組爲參數進行方法調用，分別計算二維數組各列元素之和，返回並輸出所計算的結果。
public void exercise(int[][] matrix, int m, int n) {
int[] sum = new int[n];
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
sum[i] += matrix[j][i];
}
System.out.println(sum[i]);
}
}第 7 章 Java 語言類的特性
一個類的公共成員與私有成員有何區別？
私有成員無法從該類的外部訪問到該類內部的成員，而只能被該類自身訪問和修改，而不能被任何其他類包括該類的子類來獲取或引用；公共成員則可以被其他的類訪問。什麼是方法的重載？
重載是指在同一個類內具有相同名稱的多個方法，這多個同名方法如果參數個數不同，或者是參數個數相同，但類型不同，則這些同名的方法就具有不同的功能。 方法的重載是實現“多態”的一種方法。一個類的構造方法的作用是什麼？若一個類沒有聲明構造方法，該程序能正確執行嗎？爲什麼？
構造方法的作用是在對象被創建時初始化對象的成員的方法；如果一個類沒有聲明構造方法，該類也可以被正確實例化，Java 編譯器會自動爲該類生成一個默認的構造方法。構造方法有哪些特性？
1. 構造方法的方法名與類名相同 2. 構造方法沒有返回值，但不能加 void 3. 構造方法的主要作用是完成對類對象的初始化工作 4. 構造方法一般不能由編程人員顯式地直接調用，而是用 new 來調用 5. 在創建一個類的對象的同時，系統會自動調用該類的構造方法爲對象初始化在一個構造方法內可以調用另一個構造方法嗎？如果可以，如何調用？
可以；Java 語言允許在類內從某一構造方法內調用另一個構造方法；在某一構造方法內調用另一個構造方法時，必須使用 this 關鍵字來調用，否則編譯時將出現錯誤，而且 this 關鍵字必須寫在構造方法內的第一行的位置。
被 static 修飾的成員被稱爲靜態成員，也稱爲類成員，而不用 static 修飾的成員稱爲實例成員。
靜態變量與實例變量有哪些不同？
用 static 修飾符修飾的成員變量稱爲“靜態變量”，靜態變量也稱類變量。靜態變量是隸屬於類的變量，而不是屬於任何一個類的具體變量，靜態變量不需要實例化就可以使用。 實例變量是隸屬於對象的變量，是屬於具體的一個對象的，是需要把類實例化爲對象纔可以使用的。靜態方法與實例方法有哪些不同？
用 static 修飾符修飾的方法是屬於類的靜態方法，又稱爲類方法。 靜態方法實質是屬於整個類的方法，而不加 static 修飾符的方法，是屬於具體對象的方法。在一個靜態方法內調用一個非靜態成員爲什麼是非法的？
靜態方法是屬於整個類的，所以它不能操縱和處理屬於某個對象的成員，而只能處理屬於整個類的成員，即靜態方法只能訪問靜態成員變量或靜態成員方法。對象的相等與指向它們的引用相等，兩者有什麼不同？
對象的相等指的是對象的內容相等； 指向它們的引用相等指的是引用變量指向的地址相同； == 操作符專門用來比較兩個變量的值是否相等； equals 方法是用於比較兩個獨立對象的內容是否相同。什麼是靜態初始化器，其作用是什麼？靜態初始化器由誰在何時執行？它與構造方法有何不同？
靜態初始化器是由關鍵字 static 修飾的一對大括號“{}”括起來的語句組。它是用來完成初始化工作的；靜態初始化器有 Java 虛擬機在類初始化的時候一次執行； 靜態初始化器與構造方法有以下幾點不同： 1. 構造方法是對每個新創建的對象初始化，而靜態初始化器是對類自身進行初始化。 2. 構造方法是在用 new 運算符創建新對象時由系統自動執行，而靜態初始化器一般不能由程序來調用，它是在所屬的類被加載入內存時由系統調用執行的。 3. 用 new 運算符創建多少個新對象，構造方法就被調用多少次，但靜態初始化器則在類被加載入內存時只執行一次，與創建多少個對象無關。 4. 不同於構造方法，靜態初始化器不是方法，因而沒有方法名，返回值和參數。
第 8 章 繼承抽象類和接口
子類將繼承父類的所有成員嗎？爲什麼？
不是；子類可以從父類那裏繼承所有非 private 的成員作爲自己的成員。在子類中可以調用父類的構造方法嗎？若可以，如何調用？
可以；在子類的的構造方法中通過 super() 來調用父類特定的構造方法中。在調用子類的構造方法之前，會先自動調用父類中沒有參數的構造方法，其目的是什麼？
目的是爲了幫助繼承自父類的成員做初始化操作。在子類中可以訪問父類的成員嗎？若可以，用什麼方式訪問？
可以；在子類中使用 super 不但可以訪問父類的構造方法，還可以訪問父類的成員變量和成員方法，但 super 不能訪問在子類中添加的成員。用父類對象變量可以訪問子類的成員嗎？若可以，則只限於什麼情況？
可以；通過父類的對象訪問子類的成員，只限於“覆蓋”的情況發生時。也就是說，父類與子類的方法名稱、參數個數與類型必須是完全相同，纔可以通過父類的對象調用子類的方法。什麼是“多態”機制？Java 語言中是如何實現多態的？
多態是指“一種定義，多種實現”，多態有兩種表現形式：重載和覆蓋；多態是由方法重載，方法重寫，繼承，自動轉型等引起的一系列特性。方法的“覆蓋”與方法的“重載”有何不同？
重載是指在同一個類，內定義多個名稱相同，但參數個數或類型不同的方法，從而，Java 系統便可根據參數的個數或類型，調用相對應的方法； 覆蓋是指在子類中，定義名稱、參數個數與類型均與父類完全相同的方法，用來重寫父類中同名方法的操作。this 和 super 分別有什麼特殊含義？
super 是從子類調用調用父類的成員，包括構造方法、成員變量和成員方法。 this 是用來調用同一類內的成員，包括構造方法、成員變量和成員方法。什麼是最終類與最終方法？它們的作用是什麼？
在默認情況下，所有的成員變量和成員方法都可以被覆蓋，如果父類的成員不希望被子類的成員所覆蓋就可以將它們聲明爲 final。如果用 final 修飾成員變量，則成員變量是最終變量，即常量；如果用 final 修飾成員方法，則該方法爲最終方法；如果一個類被 final 修飾符所修飾，則說明這個類不能被其他類所繼承，即該類不可能有子類，這種類被稱爲最終類。什麼是抽象類與抽象方法？使用時應注意哪些問題？
抽象類是以修飾符 abstract 修飾的類，抽象方法是以 abstract 關鍵字開頭的方法，此方法只聲明返回值的數據類型、方法名稱與所需要的參數，但沒有方法體。 需要注意的是： 1. 由於抽象類是需要被繼承的，所以 abstract 類不能用 final 來修飾。也就是說，一個類不能既是最終類，又是抽象類，即關鍵字 abstract 與 final 不能合用。 2. abstract 不能與 private、static、final 或 native 並列修飾同一方法。什麼是接口？爲什麼要定義接口？
Java接口是一系列方法的聲明，是一些方法特徵的集合，一個接口只有方法的特徵沒有方法的實現，因此這些方法可以在不同的地方被不同的類實現，而這些實現可以具有不同的行爲（功能）; 接口實現和類繼承的規則不同，爲了數據的安全，繼承時一個類只有一個直接父類，也就是單繼承，但是一個類可以實現多個接口，接口彌補了類的不能多繼承缺點，繼承和接口的雙重設計既保持了類的數據安全也變相實現了多繼承。如何定義接口？接口與抽象類有哪些異同？
接口與抽象類有以下不同： 1. 接口的數據成員都是靜態的，並且必須初始化。 2. 接口中的方法必須全部都聲明爲 abstract 的，也就是說，接口不能像抽象類一樣擁有一般的方法，而必須全部是抽象方法。 接口定義的語法格式如下：
[public] interface 接口名稱 [extends 父接口列表]
{
[public] [static] [final] 數據類型 成員變量名 = 常量；
[public] [abstract] 返回值的數據類型 方法名(參數表)；
}內部類的類型有幾種？分別在什麼情況下使用？它們所起的作用有哪些？
內部類分爲： 成員內部類、局部內部類、靜態嵌套類、匿名內部類 ；內部類的主要作用是將邏輯上相關的類放到一起；而匿名類是一種特殊的內部類，它沒有類名，在定義類的同時，就生成該類的一個實例，由於不會在其他地方用到該類，所以不用取名字，因而又被稱爲匿名內部類。內部類與外部類的使用有何不同？
內部類不能與外部類同名，否則編譯器無法區分內部類與外部類。如果內部類還有內部類，則內部類的內部類不能與它的任何一層外部類同名。在封裝它的類的內部使用內部類，與普通類的使用方式相同，但在外部引用外部類時，則必須在內部類名前冠以其所屬外部類的名字才能使用。在用 new 運算符創建內部類時，也要在 new 前面冠以對象變量。怎樣使用匿名內部類對象？
匿名內部類是指可以利用內部類創建沒有名稱的對象，它一步完成了聲明內部類和創建該類的一個對象，並利用該對象訪問到類中的成員。匿名內部類的定義與創建該類的一個實例同時進行，即類的定義前面有一個 new 運算符，而不是使用關鍵字 class， 同時帶上圓括號 “()” 表示創建對象。 創建匿名內部類的用意主要是用來彌補內部類中沒有定義到的方法，並可有效地簡化程序代碼。 使用方法：
( // 創建匿名內部類，並執行所定義的方法
new 類名() // 括號 “()” 內不允許有參數
{
方法名(參數表)
{
方法體語句；
}
}
).方法名(參數表)；什麼是包？它的作用是什麼？如何創建包？如何引用包中的類？
包是 Java 語言提供的一種區別類名空間的機制，是類的組織方式，每個包對應一個文件夾，包中還可以在有包，稱爲包等級。創建一個包需要使用 package 語句，格式爲：`package 包名 1[.包名 2[.包名 3]]；`利用 import 語句引用 Java 定義的包及包中的類。Java 語言中怎樣清除對象？能否控制 Java系統中垃圾的回收時間？
當一個對象不被任何引用類型的變量使用時，它的內存就會被 Java 垃圾回收器回收清楚對象；Java 語言不允許通過程序強迫垃圾回收器立即執行。
第 9 章 異常處理
什麼是異常？簡述 Java 語言的異常處理機制。
異常是指在程序運行中由代碼產生的一種錯誤； Java 語言的異常處理機制： 1. 發現異常：程序在運行過程中發生由與算法考慮不周或軟件設計錯誤等導致的程序異常事件。 2. 拋出異常：程序在運行過程中，如果發生了異常事件，則產生代表該異常的一個“異常對象”，並把它交給運行系統，再由運行系統尋找相應的代碼來處理這一異常。生成異常對象並把它提交給運行系統的過程稱爲拋出異常。 3. 捕獲異常：拋出異常後，運行系統從生成異常對象的代碼開始，沿方法的調用棧逐層回溯查找，直到找到包含相應異常處理的方法，並把異常對象提交給該方法爲止，這個過程稱爲捕獲異常。Throwable 類的兩個直接子類 Error 和 Exception 的功能各是什麼？用戶可以捕獲到的異常是哪個類的異常？
Error 類及其子類的對象，代表了程序運行時 Java 系統內部的錯誤。即 Error 類及其子類的對象是由 Java 虛擬機生成並拋出給系統，這種錯誤有內存溢出錯、棧溢出錯、動態鏈接錯等。通常 Java 程序不對這種錯誤進行直接處理，必須交由操作系統處理； Exception 子類則是供應用程序使用的，它是用戶程序能夠捕捉到的異常情況； 用戶可以捕捉的異常是 Exception 異常。Exception 類有何作用？每個 Exception 類的對象代表什麼？
Exception 類對象是 Java 程序拋出和處理的對象，它有各種不同的子類分別對應各種不同類型的異常。什麼是運行時異常？什麼是非運行時異常？
Exception 類中的一個子類 RuntimeException 代表運行時異常，它是程序運行時自動地對某些錯誤做出反應而產生的； 除 RuntimeException 之外，其它則是非運行時異常，這種異常經常是在程序運行過程中由環境原因造成的異常。拋出異常有哪兩種方式？
1. 系統自動拋出的異常。
2. 指定方法拋出異常。拋出異常時，爲什麼要在 catch() 括號內有一個變量 e ？
拋出異常時，throw 關鍵字所拋出的是由異常類所產生的對象，因此 throw 語句必須使用 new 運算符來產生對象，catch() 語句中的變量 e 是用來接收由 throw 關鍵字所拋出的由異常類所產生的對象。在異常處理機制中，用 catch() 括號內的變量 e 接受異常類對象的步驟有哪些？
1. try 程序塊若是有異常發生時，程序的運行便中斷，並拋出“異常類所產生的對象”。 2. 拋出的對象如果屬於 catch()括號內欲捕獲的異常類，則 catch 會捕捉此異常，然後進到 catch 的塊裏繼續運行。 3. 無論 try 程序塊是否有捕捉到異常，或者捕捉到的異常是否與 catch()括號裏的異常相同，最後一定會運行 finally 塊裏的程序代碼。finally 的程序代碼塊運行結束後，程序再回到 try-catch-finally 塊之後繼續執行。在什麼情況下，方法的頭部必須列出可能拋出的異常？
在方法內沒有使用 try-catch 語句捕獲異常，且方法內可能會產生異常時，則必須在聲明方法的頭部列出可能拋出的異常。若 try 語句結構中有多個 catch() 子句，這些子句的排列順序與程序執行效果是否有關？爲什麼？
有關；由於異常對象與 catch 塊的匹配是按照 catch 塊的先後排列順序進行的。若將子類異常的 catch 語句塊放在父類異常 catch 語句塊的後面，則編譯不能通過。什麼是拋出異常？系統定義的異常如何拋出？用戶自定義的異常又如何拋出？
程序在運行過程中，如果發生了異常事件，則產生代表該異常的一個“異常對象”，並把它交給運行系統，再由運行系統尋找相應的代碼來處理這一異常。生成異常對象並把它提交給運行系統的過程稱爲拋出異常； 所有系統定義的運行時異常都可以由系統自動拋出； 用戶自定義的異常不能由系統自動拋出，因而必須藉助於 throw 語句來定義何種情況算是產生了此種異常對應的錯誤，並應該拋出這個異常類的對象。系統定義的異常與用戶自定義的異常有何不同？如何使用這兩類異常？
系統定義的異常類主要用來處理系統可以預見的較常見的運行時錯誤，對於某個應用程序所持有的運行時異常錯誤，則需要編程人員根據程序的特殊邏輯關係在用戶程序裏自己創建用戶自己定義異常類和異常對象。用戶自定義異常類主要用來處理用戶程序中可能產生的邏輯錯誤，使得這種錯誤能夠被系統及時識別並處理，而不致於擴散產生更大的影響，從而使用戶程序有更好的容錯性能，並使整個系統更加穩定。