第 1 章 Java語言概述

1. Java語言有哪些特點？

   簡單易學、面向物件、平臺無關性、可靠性、安全性、支援多執行緒、支援網路程式設計、編譯與解釋並存
   

2. 什麼是Java的虛擬機器？

   任何一種可以執行Java位元組碼的軟體均可看成是Java的虛擬機器 
   

3. 什麼是位元組碼？採用位元組碼的最大好處是什麼？

   位元組碼是Java虛擬機器的指令組，和CPU上的微指令很相似 。位元組碼最大的好處是可跨平臺執行
   

4. 什麼是平臺無關性？Java語言是怎樣實現平臺無關性的？

   編寫的應用程式不用修改就可以在不同的軟硬體平臺上執行。Java語言是靠JVM在目的碼級實現平臺無關性的，可以說JVM是Java平臺無關的基礎
    
   

5. Java語言程式有幾種？他們包含哪幾個方面？

   Application應用程式和Applet小程式
   

6. 什麼是Java程式的主類？

   Java應用程式的主類必須包含一個定義為`public static void main(String[] args)`；Java小程式的主類必須是一個繼承自系統JApplet或Applet的子類，且該類必須是public類。 
   

第 3 章 Java語言基礎

1. Java語言定義了哪幾種基本資料型別？

   8種基本資料型別。byte, short, int, long, float, double, char 
   

2. 表示整數型別資料的關鍵字有哪幾個？他們各佔用幾個位元組？

   byte, short, int, long分別佔 1, 2, 4, 8個位元組 
   

3. 單精度浮點float和雙精度浮點double的區別是什麼？

   單精度浮點數的資料位是32位，雙精度浮點數的資料位是64位，double的精度是float的兩倍 
   

4. 字元型常量與字串常量的主要區別是什麼？

   字元型常量是用一對單引號括起來的單個字元，字串常量是用雙引號括起來的一串若干個字元（可以是0個） 
   

5. 簡述Java語言對定義識別符號的規定有哪些。

   識別符號可以由字母、數字和下劃線、美元符號等組合而成，識別符號必須以字母、下劃線或美元符號開頭，不能以數字開頭 
   

6. Java語言採用何種編碼方案？有何特點？

   Unicode字符集編碼方案，便於西文字元和中文字元的處理 
   

7. 什麼是強制型別轉換？在什麼情況下需要強制型別轉換？

   強制型別轉換就是將長資料轉換為短資料。如果要將較長的資料轉換成較短的資料時，就要進行強制型別轉換。
   

8. 自動型別轉換得前提是什麼？轉換是從”短”到”長”的優先順序順序是怎樣的？

   轉換前的資料型別與轉換後的型別相容，轉換後的資料型別的表示範圍比轉換前的型別大。byte→short→char→int→long→float→double 
   

9. 數字字串轉換為數值型資料時，所使用的方法有哪些？

• 寫出由鍵盤輸入資料的兩種基本格式。

  在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);
    }
}

1. Java語言有哪些基本的運算子？

   算術執行符包括 +、-、*、/、%、++、--
   關係運算符包括 >、<、>=、<=、==、!= 
   邏輯運算子包括 !、&&、||、&、| 
   位運算子包括 >>、<<、>>>、&、|、^、~ 
   賦值運算子包括 =
   條件運算子 ?:
   分量運算子 . 
   下標運算子 []
   例項運算子 instanceof
   記憶體分配運算子 new
   強制型別轉換運算子 (型別)
   方法呼叫運算子 ()
   

2. 邏輯運算子中“邏輯與、邏輯或”和“簡潔與、簡潔或”的區別是什麼？

   非簡潔運算在必須計算完左右兩個表示式之後，才取結果值；而簡潔運算可能只計算左邊的表示式而不計算右邊的表示式，即對於 &&，只要左邊的表示式為 false，就不計算右邊的表示式，則整個表示式為 false；對於 ||，只要左邊表示式為 true，就不計算右邊表示式，則整個表示式為 true。
   

3. 邏輯運算子與位運算子的區別是什麼？

   位運算子的運算元只能為整型或字元型資料，雖然有的位運算子號（如 &、|、^）與邏輯運算子的寫法相同，但邏輯運算子的運算元為boolean型的量 
   

4. 什麼是運算子的優先順序和結合性？

   運算子的優先順序決定了表示式中不同運算執行的先後順序，運算子的結合性決定了並列的多個同級運算子的先後執行順序 
   

5. 寫出下列表達式的值，設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 章 陣列與字串

1. 簡述 Java 記憶體分配的機制。

   Java 語言把記憶體分為兩種：棧記憶體和堆記憶體。
   在方法中定義的一些基本型別的變數和物件的引用變數都在方法的棧記憶體中分配，當在一段程式碼塊中定義一個變數時，Java 就在棧記憶體中為這個變數分配記憶體空間，當超出變數的的作用域後，Java 會自動釋放掉為該變數分配的記憶體空間。
   
   堆記憶體用來存放由 new 運算子建立的物件和陣列，在堆中分配的的記憶體，由 Java 虛擬機器的自動垃圾回收器來管理。在堆中建立了一個數組或物件後，同時還在棧中定義一個特殊的變數，讓棧中的這個變數的取值等於陣列或物件在堆記憶體中的首地址，棧中的這個變數就成了陣列或物件的引用變數，引用變數實際上儲存的是陣列或物件在堆記憶體中的地址（也稱為物件的控制代碼），以後就可以在程式中使用棧的引用變數來訪問堆中的陣列或物件。
   

2. 陣列的主要特點：

   - 陣列是相同資料型別的元素的集合。
   - 陣列中的各元素是有先後順序的，它們在記憶體中按照這個先後順序連續存放在一起。
   - 陣列元素用整個陣列的名字和它自己在陣列中的順序位置來表示。例如 a[0] 表示名字為 a 的陣列中的第一個元素。
   

3. String 類的常用方法

• 從鍵盤輸入 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 章 類與物件

1. 類與物件的區別是什麼？

   類是對某一類事物的描述，是抽象的、概念上的定義；物件則是實際存在的屬該類事物的具體的個體，物件是類的例項化，因而也稱為例項（instance）。
   

2. 如何定義一個類？類的結構是怎樣的？

   定義類實際上就是定義類的屬性與方法。
   

// 類的一般結構如下：
[類修飾符] class 類名稱
{
    [修飾符] 資料型別 成員變數名稱;

    [修飾符] 返回值的資料型別 方法名(引數1, 引數2, ......)
    {
        語句序列;
        return [表示式];
    }
}

• 定義一個類時所使用的修飾符有哪幾個？每個修飾符的作用是什麼？是否可以混用？

  定義一個類時所使用的修飾符有 4 個，一個類可以有多個修飾符，且無先後順序之分，但 abstract 和 final 相互獨立，所以不能同時應用在一個類的定義中，每個修飾符的作用如下：
  

• 成員變數量的修飾符有哪些？各修飾符的功能是什麼？是否可以混用？

  成員變數的修飾符有 8 個，除了訪問控制修飾符有多個外，其他的修飾符都只有一個，每個修飾符的功能如下：
  

• 成員方法的修飾符有哪些？各修飾符的功能是什麼？是否可以混用？

  成員方法的修飾符有 9 個，成員方法與成員變數同樣有多個控制修飾符，當用兩個以上的修飾符來修飾一個方法時，需要注意，有的修飾符之間是互斥的，所以不能同時使用。
  

1. 成員變數與區域性變數的區別有哪些？

   由類和方法的定義可知，在類和方法中均可定義屬於自己的變數。類中定義的變數是成員變數，而方法中定義的變數是區域性變數。
   
   1. 從語法形式上看，成員變數是屬於類的，而區域性變數是在方法中定義的或是方法的引數；成員變數可以被 public、private、static 等修飾符所修飾，而區域性變數則不能被訪問控制符及 static 所修飾；成員變數和區域性變數都可以被 final 修飾。
   2. 從變數在記憶體中的儲存方式上看，成員變數是物件的一部分，而物件是存在與堆記憶體中的，而區域性變數是存在與棧記憶體中的。
   3. 從變數在記憶體中的生存時間上看，成員變數是物件的一部分，它隨著物件的建立而存在，而區域性變數隨著方法的呼叫而產生，隨著方法呼叫的結束而自動消失。
   4. 成員變數如果沒有被賦初值，則會自動以型別的預設值賦值（有一種情況例外，被 final 修飾但沒有被 static 修飾的成員變數必須顯式的賦值）；而區域性變數則不會自動賦值，必須顯式地賦值後才能使用。
   

2. 建立一個物件使用什麼運算子？物件實體與物件的引用有何不同？

   建立一個物件使用 new 運算子；物件實體是實在存在於堆記憶體中的，而物件的引用是管理物件實體的控制代碼存在於棧記憶體中。
   

3. 物件的成員如何表示？

   物件的成員通過物件名.物件成員來訪問。
   

4. 在成員變數或成員方法前加上關鍵字 this 表示什麼含義？

   this.成員名 表示 物件本身的成員。this 代表呼叫此成員的物件。
   

5. 什麼是方法的返回值？返回值在類的方法裡面的作用是什麼？

   方法的返回值是指我們獲取到的某個方法體中的程式碼執行後產生的結果！（前提是該方法可能產生結果）。返回值的作用:接收產生的結果，使得它可以用於其他的操作。
   

6. 在方法呼叫中，使用物件作為引數進行傳遞時，是“傳值”還是“傳址”？物件作引數起到什麼作用？

   當引數是基本型別資料時，則是傳值方式呼叫，而當引數是引用型的變數時，則是傳址方式呼叫。
   

7. 什麼叫匿名物件？一般在什麼情況下使用匿名物件？

   當一個物件被建立之後，在呼叫該物件的方法時，也可以不定義物件的引用變數，而直接呼叫物件的方法，這樣的物件叫做匿名物件。
   使用匿名物件通常有如下兩種情況：
   1. 如果對一個物件只需要進行一次方法呼叫，那麼就可以使用匿名物件。
   2. 將匿名物件作為實參傳遞給一個方法呼叫。
   

8. 定義一個 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 語言類的特性

1. 一個類的公共成員與私有成員有何區別？

    私有成員無法從該類的外部訪問到該類內部的成員，而只能被該類自身訪問和修改，而不能被任何其他類包括該類的子類來獲取或引用；公共成員則可以被其他的類訪問。
   

2. 什麼是方法的過載？

   過載是指在同一個類內具有相同名稱的多個方法，這多個同名方法如果引數個數不同，或者是引數個數相同，但型別不同，則這些同名的方法就具有不同的功能。
   
   方法的過載是實現“多型”的一種方法。
   

3. 一個類的構造方法的作用是什麼？若一個類沒有宣告構造方法，該程式能正確執行嗎？為什麼？

   構造方法的作用是在物件被建立時初始化物件的成員的方法；如果一個類沒有宣告構造方法，該類也可以被正確例項化，Java 編譯器會自動為該類生成一個預設的構造方法。
   

4. 構造方法有哪些特性？

   1. 構造方法的方法名與類名相同
   2. 構造方法沒有返回值，但不能加 void
   3. 構造方法的主要作用是完成對類物件的初始化工作
   4. 構造方法一般不能由程式設計人員顯式地直接呼叫，而是用 new 來呼叫
   5. 在建立一個類的物件的同時，系統會自動呼叫該類的構造方法為物件初始化
   

5. 在一個構造方法內可以呼叫另一個構造方法嗎？如果可以，如何呼叫？

   可以；Java 語言允許在類內從某一構造方法內呼叫另一個構造方法；在某一構造方法內呼叫另一個構造方法時，必須使用 this 關鍵字來呼叫，否則編譯時將出現錯誤，而且 this 關鍵字必須寫在構造方法內的第一行的位置。
   

被 static 修飾的成員被稱為靜態成員，也稱為類成員，而不用 static 修飾的成員稱為例項成員。

1. 靜態變數與例項變數有哪些不同？

   用 static 修飾符修飾的成員變數稱為“靜態變數”，靜態變數也稱類變數。靜態變數是隸屬於類的變數，而不是屬於任何一個類的具體變數，靜態變數不需要例項化就可以使用。
   
   例項變數是隸屬於物件的變數，是屬於具體的一個物件的，是需要把類例項化為物件才可以使用的。
   

2. 靜態方法與例項方法有哪些不同？

   用 static 修飾符修飾的方法是屬於類的靜態方法，又稱為類方法。
   靜態方法實質是屬於整個類的方法，而不加 static 修飾符的方法，是屬於具體物件的方法。
   

3. 在一個靜態方法內呼叫一個非靜態成員為什麼是非法的？

   靜態方法是屬於整個類的，所以它不能操縱和處理屬於某個物件的成員，而只能處理屬於整個類的成員，即靜態方法只能訪問靜態成員變數或靜態成員方法。
   

4. 物件的相等與指向它們的引用相等，兩者有什麼不同？

   物件的相等指的是物件的內容相等；
   指向它們的引用相等指的是引用變數指向的地址相同；
   == 操作符專門用來比較兩個變數的值是否相等；
   equals 方法是用於比較兩個獨立物件的內容是否相同。
   

5. 什麼是靜態初始化器，其作用是什麼？靜態初始化器由誰在何時執行？它與構造方法有何不同？

   靜態初始化器是由關鍵字 static 修飾的一對大括號“{}”括起來的語句組。它是用來完成初始化工作的；靜態初始化器有 Java 虛擬機器在類初始化的時候一次執行；
   
   靜態初始化器與構造方法有以下幾點不同：
   1. 構造方法是對每個新建立的物件初始化，而靜態初始化器是對類自身進行初始化。
   2. 構造方法是在用 new 運算子建立新物件時由系統自動執行，而靜態初始化器一般不能由程式來呼叫，它是在所屬的類被載入入記憶體時由系統呼叫執行的。
   3. 用 new 運算子建立多少個新物件，構造方法就被呼叫多少次，但靜態初始化器則在類被載入入記憶體時只執行一次，與建立多少個物件無關。
   4. 不同於構造方法，靜態初始化器不是方法，因而沒有方法名，返回值和引數。
   

第 8 章 繼承抽象類和介面

1. 子類將繼承父類的所有成員嗎？為什麼？

   不是；子類可以從父類那裡繼承所有非 private 的成員作為自己的成員。
   

2. 在子類中可以呼叫父類的構造方法嗎？若可以，如何呼叫？

   可以；在子類的的構造方法中通過 super() 來呼叫父類特定的構造方法中。
   

3. 在呼叫子類的構造方法之前，會先自動呼叫父類中沒有引數的構造方法，其目的是什麼？

   目的是為了幫助繼承自父類的成員做初始化操作。
   

4. 在子類中可以訪問父類的成員嗎？若可以，用什麼方式訪問？

   可以；在子類中使用 super 不但可以訪問父類的構造方法，還可以訪問父類的成員變數和成員方法，但 super 不能訪問在子類中新增的成員。
   

5. 用父類物件變數可以訪問子類的成員嗎？若可以，則只限於什麼情況？

   可以；通過父類的物件訪問子類的成員，只限於“覆蓋”的情況發生時。也就是說，父類與子類的方法名稱、引數個數與型別必須是完全相同，才可以通過父類的物件呼叫子類的方法。
   

6. 什麼是“多型”機制？Java 語言中是如何實現多型的？

   多型是指“一種定義，多種實現”，多型有兩種表現形式：過載和覆蓋；多型是由方法過載，方法重寫，繼承，自動轉型等引起的一系列特性。 
   

7. 方法的“覆蓋”與方法的“過載”有何不同？

   過載是指在同一個類，內定義多個名稱相同，但引數個數或型別不同的方法，從而，Java 系統便可根據引數的個數或型別，呼叫相對應的方法；
   
   覆蓋是指在子類中，定義名稱、引數個數與型別