本題集由尚學堂學員整理，列舉了眾多IT公司面試真題，對應聘Java程序員職位的常見考點和知識體系都進行的分類和歸納整理。

本題集適合應聘Java和JavaEE職位的程序員作為面試復習、學習和強化的資料，也適合其他程序員作為拓展讀物進行閱讀。

本題集包含了常見的算法、面試題，也包含了新的高級技術，比如：微服務架構等技術的面試題目。本題集非常全面，對于工作1-5年左右的java程序員面試有非常好的指導作用。

大家也可以訪問（直接在線觀看最新版的面試題）：www.73x9.com/javamianshiti.html

四個專業都要學，從零開始2000小時，成為高端人才，打下一生技術基礎，不再是低端碼農。

2.掃一掃，咨詢詳情：

訪問官網 www.itbaizhan.cn

Java基礎、語法：

C/C++語言都直接編譯成針對特定平臺機器碼。如果要跨平臺，需要使用相應的編譯器重新編譯。

Java源程序（.java）要先編譯成與平臺無關的字節碼文件(.class)，然后字節碼文件再解釋成機器碼運行。解釋是通過Java虛擬機來執行的。

字節碼文件不面向任何具體平臺，只面向虛擬機。

Java虛擬機是可運行Java字節碼文件的虛擬計算機。不同平臺的虛擬機是不同的，但它們都提供了相同的接口。

Java語言具有一次編譯，到處運行的特點。就是說編譯后的.class可以跨平臺運行，前提是該平臺具有相應的Java虛擬機。但是性能比C/C++要低。

Java的跨平臺原理決定了其性能沒有C/C++高

語言層次的安全性主要體現在：

Java取消了強大但又危險的指針，而代之以引用。由于指針可進行移動運算，指針可隨便指向一個內存區域，而不管這個區域是否可用，這樣做是危險的，因為原來這個內存地址可能存儲著重要數據或者是其他程序運行所占用的，并且使用指針也容易數組越界。

垃圾回收機制：不需要程序員直接控制內存回收，由垃圾回收器在后臺自動回收不再使用的內存。避免程序忘記及時回收，導致內存泄露。避免程序錯誤回收程序核心類庫的內存，導致系統崩潰。

異常處理機制：Java異常機制主要依賴于try、catch、finally、throw、throws五個關鍵字。

強制類型轉換：只有在滿足強制轉換規則的情況下才能強轉成功。

底層的安全性可以從以下方面來說明

Java在字節碼的傳輸過程中使用了公開密鑰加密機制(PKC)。

在運行環境提供了四級安全性保障機制：

字節碼校驗器 -類裝載器 -運行時內存布局 -文件訪問限制

Java2平臺包括標準版（J2SE）、企業版（J2EE）和微縮版（J2ME）三個版本：

Standard Edition(標準版) J2SE 包含那些構成Java語言核心的類。

比如：數據庫連接、接口定義、輸入/輸出、網絡編程

Enterprise Edition(企業版) J2EE 包含J2SE 中的類，并且還包含用于開發企業級應用的類。

比如servlet、JSP、XML、事務控制

Micro Edition(微縮版) J2ME 包含J2SE中一部分類，用于消費類電子產品的軟件開發。

比如：呼機、智能卡、手機、PDA、機頂盒

他們的范圍是：J2SE包含于J2EE中，J2ME包含了J2SE的核心類，但新添加了一些專有類

應用場合，API的覆蓋范圍各不相同。

JVM ：JVM是Java Virtual Machine（Java虛擬機）的縮寫，它是整個java實現跨平臺的最核心的部分，所有的java程序會首先被編譯為.class的類文件，這種類文件可以在虛擬機上執行，也就是說class并不直接與機器的操作系統相對應，而是經過虛擬機間接與操作系統交互，由虛擬機將程序解釋給本地系統執行。JVM是Java平臺的基礎，和實際的機器一樣，它也有自己的指令集，并且在運行時操作不同的內存區域。?JVM通過抽象操作系統和CPU結構，提供了一種與平臺無關的代碼執行方法，即與特殊的實現方法、主機硬件、主機操作系統無關。JVM的主要工作是解釋自己的指令集（即字節碼）到CPU的指令集或對應的系統調用，保護用戶免被惡意程序騷擾。?JVM對上層的Java源文件是不關心的，它關注的只是由源文件生成的類文件（.class文件）。

JRE：JRE是java runtime environment（java運行環境）的縮寫。光有JVM還不能讓class文件執行，因為在解釋class的時候JVM需要調用解釋所需要的類庫lib。在JDK的安裝目錄里你可以找到jre目錄，里面有兩個文件夾bin和lib,在這里可以認為bin里的就是jvm，lib中則是jvm工作所需要的類庫，而jvm和lib和起來就稱為jre。所以，在你寫完java程序編譯成.class之后，你可以把這個.class文件和jre一起打包發給朋友，這樣你的朋友就可以運行你寫程序了（jre里有運行.class的java.exe）。JRE是Sun公司發布的一個更大的系統，它里面就有一個JVM。JRE就與具體的CPU結構和操作系統有關，是運行Java程序必不可少的（除非用其他一些編譯環境編譯成.exe可執行文件……），JRE的地位就象一臺PC機一樣，我們寫好的Win32應用程序需要操作系統幫我們運行，同樣的，我們編寫的Java程序也必須要JRE才能運行。?

JDK：JDK是java development kit（java開發工具包）的縮寫。每個學java的人都會先在機器上裝一個JDK，那 讓我們看一下JDK的安裝目錄。在目錄下面有六個文件夾、一個src類庫源碼壓縮包、和其他幾個聲明文件。其中，真正在運行java時起作用的是以下四個文件夾：bin、include、lib、jre?，F在我們可以看出這樣一個關系，JDK包含JRE，而JRE包含JVM。

bin:最主要的是編譯器(javac.exe)

include:java和JVM交互用的頭文件

lib：類庫??????

jre:java運行環境?

（注意：這里的bin、lib文件夾和jre里的bin、lib是不同的）總的來說JDK是用于java程序的開發,而jre則是只能運行class而沒有編譯的功能。eclipse、idea等其他IDE有自己的編譯器而不是用JDK?bin目錄中自帶的，所以在安裝時你會發現他們只要求你選jre路徑就ok了。

JDK,JRE,JVM三者關系概括如下：

jdk是JAVA程序開發時用的開發工具包，其內部也有JRE運行環境JRE。JRE是JAVA程序運行時需要的運行環境，就是說如果你光是運行JAVA程序而不是去搞開發的話，只安裝JRE就能運行已經存在的JAVA程序了。JDk、JRE內部都包含JAVA虛擬機JVM，JAVA虛擬機內部包含許多應用程序的類的解釋器和類加載器等等。

共有單行注釋、多行注釋、文檔注釋3種注釋類型。使用如下：

單行注釋，采用“//”方式.只能注釋一行代碼。如：//類成員變量

多行注釋，采用“/*...*/”方式，可注釋多行代碼，其中不允許出現嵌套。如：

/*System.out.println("a");

System.out.println("b");

System.out.println("c");*/

文檔注釋，采用“/**...*/”方式。如：

/**

* 子類 Dog

* @author Administrator

**/

public class Dog extends Animal{}

共同點：

1、i++和++i都是變量自增1，都等價于i=i+1

2、如果i++,++i是一條單獨的語句，兩者沒有任何區別

3、i++和++i的使用僅僅針對變量。 5++和++5會報錯，因為5不是變量。

不同點：

如果i++,++i不是一條單獨的語句，他們就有區別i++ ：先運算后增1。如：

int x=5;
int y=x++;
System.out.println("x="+x+", y="+y);
    //以上代碼運行后輸出結果為：x=6, y=5

++i ： 先增1后運算。如：

int x=5;
int y=++x;
System.out.println("x="+x+", y="+y);
    //以上代碼運行后輸出結果為：x=6, y=6

&和&&的聯系(共同點)：

&和&&都可以用作邏輯與運算符，但是要看使用時的具體條件來決定。

操作數1&操作數2，操作數1&&操作數2，

表達式1&表達式2，表達式1&&表達式2，

情況1：當上述的操作數是boolean類型變量時，&和&&都可以用作邏輯與運算符。

情況2：當上述的表達式結果是boolean類型變量時，&和&&都可以用作邏輯與運算符。

表示邏輯與(and)，當運算符兩邊的表達式的結果或操作數都為true時，整個運算結果才為true，否則，只要有一方為false，結果都為false。

&和&&的區別(不同點)：

(1)、&邏輯運算符稱為邏輯與運算符，&&邏輯運算符稱為短路與運算符，也可叫邏輯與運算符。

對于&：無論任何情況，&兩邊的操作數或表達式都會參與計算。

對于&&：當&&左邊的操作數為false或左邊表達式結果為false時，&&右邊的操作數或表達式將不參與計算，此時最終結果都為false。

綜上所述，如果邏輯與運算的第一個操作數是false或第一個表達式的結果為false時，對于第二個操作數或表達式是否進行運算，對最終的結果沒有影響，結果肯定是false。推介平時多使用&&，因為它效率更高些。

、&還可以用作位運算符。當&兩邊操作數或兩邊表達式的結果不是boolean類型時，&用于按位與運算符的操作。

|和||的區別和聯系與&和&&的區別和聯系類似

使用位運算來實現效率最高。位運算符是對操作數以二進制比特位為單位進行操作和運算，操作數和結果都是整型數。對于位運算符“<<”, 是將一個數左移n位，就相當于乘以了2的n次方，那么，一個數乘以8只要將其左移3位即可，位運算cpu直接支持的，效率最高。所以，2乘以8等于幾的最效率的方法是2 << 3

基本類型轉換分為自動轉換和強制轉換。

自動轉換規則：容量小的數據類型可以自動轉換成容量大的數據類型，也可

以說低級自動向高級轉換。這兒的容量指的不是字節數，而是指類型表述的范圍。

強制轉換規則：高級變為低級需要強制轉換。

如何轉換：

（1）賦值運算符“=”右邊的轉換，先自動轉換成表達式中級別最高的數據類型，再進行運算。

（2）賦值運算符“=”兩側的轉換，若左邊級別>右邊級別，會自動轉換；若左邊級別 == 右邊級別，不用轉換；若左邊級別 < 右邊級別，需強制轉換。

(3)可以將整型常量直接賦值給byte, short, char等類型變量，而不需要進行強制類型轉換，前提是不超出其表述范圍，否則必須進行強制轉換。

相同之處：都是分支語句，多超過一種的情況進行判斷處理。

不同之處：

switch更適合用于多分支情況，就是有很多種情況需要判斷處理，判斷條件類型單一，只有一個入口，在分支執行完后（如果沒有break跳出），不加判斷地執行下去;而if—elseif---else多分枝主要適用于分支較少的分支結構，判斷類型不是單一，只要一個分支被執行后，后邊的分支不再執行。switch為等值判斷（不允許比如>= <=），而if為等值和區間都可以，if的使用范圍大。

while先判斷后執行，第一次判斷為false,循環體一次都不執行

do while先執行 后判斷，最少執行1次。

如果while循環第一次判斷為true, 則兩種循環沒有區別。

break: 結束當前循環并退出當前循環體。

break還可以退出switch語句

continue: 循環體中后續的語句不執行，但是循環沒有結束，繼續進行循環條件的判斷（for循環還會i++）。continue只是結束本次循環。

package com.bjsxt;
import java.io.File;
public class $ {
public static void main(String[] args) {
        String path = "D:/301SXT";
        test(path);
    }
    private static void test(String path) {
        File f = new File(path);
        File[] fs = f.listFiles();
        if (fs == null) {
            return;
        }
        for (File file : fs) {
            if (file.isFile()) {
                System.out.println(file.getPath());
            } else {
                test(file.getPath());
            }
        }
    }

遞歸算法是一種直接或者間接地調用自身算法的過程。在計算機編寫程序中，遞歸算法對解決一大類問題是十分有效的，它往往使算法的描述簡潔而且易于理解。

遞歸算法解決問題的特點：

(1) 遞歸就是在過程或函數里調用自身。

(2) 在使用遞歸策略時，必須有一個明確的遞歸結束條件，稱為遞歸出口。

(3) 遞歸算法解題通常顯得很簡潔，但運行效率較低。所以一般不提倡用遞歸算法設計程序。

(4) 在遞歸調用的過程當中系統為每一層的返回點、局部量等開辟了棧來存儲。遞歸次數過多容易造成棧溢出等。所以一般不提倡用遞歸算法設計程序。

數組是（相同類型數據）的（有序）（集合）

數組會在內存中開辟一塊連續的空間，每個空間相當于之前的一個變量，稱為數組的元素element

元素的表示 數組名[下標或者索引] scores[7] scores[0] scores[9]

索引從0開始

每個數組元素有默認值 double 0.0 boolean false int 0

數組元素有序的，不是大小順序，是索引 的順序

數組中可以存儲基本數據類型，可以存儲引用數據類型；但是對于一個數組而言，數組的類型是固定的，只能是一個

length:數組的長度

數組的長度是固定的，一經定義，不能再發生變化（數組的擴容）

package com.bjsxt;

public class TestBubbleSort {
public static void sort(int[] a) {
int temp = 0;
// 外層循環，它決定一共走幾趟
for (int i = 0; i <a.length-1; ++i) {
//內層循環，它決定每趟走一次
for (int j = 0; j <a.length-i-1 ; ++j) {
//如果后一個大于前一個
if (a[j + 1] < a[j]) {
//換位
temp = a[j];a[j] = a[j + 1];a[j + 1] = temp;
}
}
}

public static void sort2(int[] a) {
int temp = 0;
for (int i = 0; i <a.length-1; ++i) {
//通過符號位可以減少無謂的比較，如果已經有序了，就退出循環
int flag = 0;
for (int j = 0; j <a.length-1-i ; ++j) {
if (a[j + 1] < a[j]) {
temp = a[j];
a[j] = a[j + 1];
a[j + 1] = temp;
flag = 1;
}
}
if(flag == 0){
break;
}
}
}
}

package com.bjsxt;

public class TestSelectSort {
public static void sort(int arr[]) {
int temp = 0;
for (int i = 0; i < arr.length - 1; i++) {
// 認為目前的數就是最小的, 記錄最小數的下標
int minIndex = i;
for (int j = i + 1; j < arr.length; j++) {
if (arr[minIndex] > arr[j]) {
// 修改最小值的下標
minIndex = j;
}
}
// 當退出for就找到這次的最小值
if (i != minIndex) {
temp = arr[i];
arr[i] = arr[minIndex];
arr[minIndex] = temp;
}
}
}
}

package com.bjsxt;

public class TestInsertSort {
public static void sort(int arr[]) {
int i, j;
for (i = 1; i < arr.length; i++) {
int temp = arr[i];
for (j = i; j > 0 && temp < arr[j - 1]; j--) {
arr[j] = arr[j - 1];
}
arr[j] = temp;
}
}
}

總結1：可變參數

1.可變參數的形式 ...

2.可變參數只能是方法的形參

3.可變參數對應的實參可以0,1,2.....個，也可以是一個數組

4.在可變參數的方法中，將可變參數當做數組來處理

5.可變參數最多有一個，只能是最后一個

6.可變參數好處：方便 簡單 減少重載方法的數量

7.如果定義了可變參數的方法，不允許同時定義相同類型數組參數的方法

總結2：數組做形參和可變參數做形參聯系和區別

聯系：

1.實參都可以是數組；2.方法體中，可變參數當做數組來處理

區別：

1.個數不同 可變參數只能有一個數組參數可以多個

2.位置不同 可變參數只能是最后一個 數組參數位置任意

3.實參不同 可變參數實參可以0,1,2.....個，也可以是一個數組，數組的實參只能是數組

類是對象的抽象，而對象是類的具體實例。類是抽象的，不占用內存，而對象是具體的，占用存儲空間。類是用于創建對象的藍圖，它是一個定義包括在特定類型的對象中的方法和變量的軟件模板。

類和對象好比圖紙和實物的關系，模具和鑄件的關系。

比如人類就是一個概念，人類具有身高，體重等屬性。人類可以做吃飯、說話等方法。

小明就是一個具體的人，也就是實例，他的屬性是具體的身高200cm，體重180kg，他做的方法是具體的吃了一碗白米飯，說了“12345”這樣一句話。

兩者都是軟件開發思想，先有面向過程，后有面向對象。在大型項目中，針對面向過程的不足推出了面向對象開發思想。

比喻

蔣介石和毛澤東分別是面向過程和面向對象的杰出代表，這樣充分說明，在解決復制問題時，面向對象有更大的優越性。

面向過程是蛋炒飯，面向對象是蓋澆飯。蓋澆飯的好處就是“菜”“飯”分離，從而提高了制作蓋澆飯的靈活性。飯不滿意就換飯，菜不滿意換菜。用軟件工程的專業術語就是“可維護性”比較好，“飯” 和“菜”的耦合度比較低。

區別

編程思路不同： 面向過程以實現功能的函數開發為主，而面向對象要首先抽象出類、屬性及其方法，然后通過實例化類、執行方法來完成功能。

封裝性：都具有封裝性，但是面向過程是封裝的是功能，而面向對象封裝的是數據和功能。

面向對象具有繼承性和多態性，而面向過程沒有繼承性和多態性，所以面向對象優勢是明顯。

方法重載和方法重寫（覆蓋）的區別

this是對象內部指代自身的引用,同時也是解決成員變量和局部變量同名問題；this可以調用成員變量，不能調用局部變量；this也可以調用成員方法，但是在普通方法中可以省略this，在構造方法中不允許省略，必須是構造方法的第一條語句。，而且在靜態方法當中不允許出現this關鍵字。

super代表對當前對象的直接父類對象的引用，super可以調用直接父類的成員變量（注意權限修飾符的影響，比如不能訪問private成員）

super可以調用直接父類的成員方法（注意權限修飾符的影響，比如不能訪問private成員）；super可以調用直接父類的構造方法，只限構造方法中使用，且必須是第一條語句。

static可以修飾變量、方法、代碼塊和內部類

static屬性屬于這個類所有，即由該類創建的所有對象共享同一個static屬性?？梢詫ο髣摻ê笸ㄟ^對象名.屬性名和類名.屬性名兩種方式來訪問。也可以在沒有創建任何對象之前通過類名.屬性名的方式來訪問。

static變量和非static變量的區別(都是成員變量，不是局部變量)

1.在內存中份數不同

不管有多少個對象，static變量只有1份。對于每個對象，實例變量都會有單獨的一份

static變量是屬于整個類的，也稱為類變量。而非靜態變量是屬于對象的，也稱為實例變量

2.在內存中存放的位置不同

2.在內存中存放的位置不同

3.訪問的方式不同

實例變量： 對象名.變量名 stu1.name="小明明";

靜態變量：對象名.變量名 stu1.schoolName="西二旗小學"; 不推薦如此使用

類名.變量名 Student.schoolName="東三旗小學"; 推薦使用

4.在內存中分配空間的時間不同

Student.schoolName="東三旗小學";或者Student stu1 = new Student("小明","男",20,98);

static方法也可以通過對象名.方法名和類名.方法名兩種方式來訪問

static代碼塊。當類被第一次使用時（可能是調用static屬性和方法，或者創建其對象）執行靜態代碼塊，且只被執行一次，主要作用是實現static屬性的初始化。

static內部類：屬于整個外部類，而不是屬于外部類的每個對象。不能訪問外部類的非靜態成員（變量或者方法），.可以訪問外部類的靜態成員

final和abstract是功能相反的兩個關鍵字，可以對比記憶

abstract可以用來修飾類和方法，不能用來修飾屬性和構造方法；使用abstract修飾的類是抽象類，需要被繼承，使用abstract修飾的方法是抽象方法，需要子類被重寫。

final可以用來修飾類、方法和屬性，不能修飾構造方法。使用final修飾的類不能被繼承，使用final修飾的方法不能被重寫，使用final修飾的變量的值不能被修改，所以就成了常量。

特別注意：final修飾基本類型變量，其值不能改變，由原來的變量變為常量；但是final修飾引用類型變量，棧內存中的引用不能改變，但是所指向的堆內存中的對象的屬性值仍舊可以改變。例如

package com.bjsxt;

class Test {
    public static void main(String[] args) {
        final Dog dog = new Dog("歐歐");
        dog.name = "美美";//正確
        dog = new Dog("亞亞");//錯誤
    }
}

final修飾符（關鍵字）如果一個類被聲明為final，意味著它不能再派生出新的子類，不能作為父類被繼承例如：String類、Math類等。將變量或方法聲明為final，可以保證它們在使用中不被改變。被聲明為final的變量必須在聲明時給定初值，而在以后的引用中只能讀取，不可修改。被聲明為final的方法也同樣只能使用，不能重寫，但是能夠重載。 使用final修飾的對象，對象的引用地址不能變，但是對象的值可以變！

finally在異常處理時提供 finally 塊來執行任何清除操作。如果有finally的話，則不管是否發生異常，finally語句都會被執行。一般情況下，都把關閉物理連接(IO流、數據庫連接、Socket連接)等相關操作，放入到此代碼塊中。

finalize方法名。Java 技術允許使用 finalize() 方法在垃圾收集器將對象從內存中清除出去之前做必要清理工作。finalize() 方法是在垃圾收集器刪除對象之前被調用的。它是在 Object 類中定義的，因此所有的類都繼承了它。子類覆蓋 finalize() 方法以整理系統資源或者執行其他清理工作。 一般情況下，此方法由JVM調用，程序員不要去調用！

(1)public boolean equals(java.lang.Object)

比較對象的地址值是否相等，如果子類重寫，則比較對象的內容是否相等；

(2)public native int hashCode() 獲取哈希碼

(3)public java.lang.String toString() 把數據轉變成字符串

(4)public final native java.lang.Class getClass() 獲取類結構信息

(5)protected void finalize() throws java.lang.Throwable

垃圾回收前執行的方法

(6)protected native Object clone() throws

java.lang.CloneNotSupportedException 克隆

(7)public final void wait() throws java.lang.InterruptedException

多線程中等待功能

(8)public final native void notify() 多線程中喚醒功能

(9)public final native void notifyAll() 多線程中喚醒所有等待線程的功能

類的訪問權限只有兩種

public公共的 可被同一項目中所有的類訪問。 (必須與文件名同名)

default默認的 可被同一個包中的類訪問。

成員（成員變量或成員方法）訪問權限共有四種：

public 公共的 可以被項目中所有的類訪問。(項目可見性)

protected 受保護的 可以被這個類本身訪問；同一個包中的所有其他的類訪問；被它的子類（同一個包以及不同包中的子類）訪問。（子類可見性）

default 默認的被這個類本身訪問；被同一個包中的類訪問。（包可見性）

private 私有的 只能被這個類本身訪問。（類可見性）

繼承條件下構造方法的調用規則如下：

情況1：如果子類的構造方法中沒有通過super顯式調用父類的有參構造方法，也沒有通過this顯式調用自身的其他構造方法，則系統會默認先調用父類的無參構造方法。在這種情況下，寫不寫“super();”語句，效果是一樣的。

情況2：如果子類的構造方法中通過super顯式調用父類的有參構造方法，那將執行父類相應構造方法，而不執行父類無參構造方法。

情況3：如果子類的構造方法中通過this顯式調用自身的其他構造方法，在相應構造方法中應用以上兩條規則。

特別注意的是，如果存在多級繼承關系，在創建一個子類對象時，以上規則會多次向更高一級父類應用，一直到執行頂級父類Object類的無參構造方法為止。

“==”是關系運算符，equals()是方法，同時他們的結果都返回布爾值；

“==”使用情況如下：

a) 基本類型，比較的是值

b) 引用類型，比較的是地址

c) 不能比較沒有父子關系的兩個對象

equals()方法使用如下：

a) 系統類一般已經覆蓋了equals()，比較的是內容。

b) 用戶自定義類如果沒有覆蓋equals()，將調用父類的equals （比如是Object），而Object的equals的比較是地址（return (this == obj);）

c) 用戶自定義類需要覆蓋父類的equals()

注意：Object的==和equals比較的都是地址，作用相同

實現多態的三個條件（前提條件，向上轉型、向下轉型）

1、繼承的存在；（繼承是多態的基礎，沒有繼承就沒有多態）

2、子類重寫父類的方法。（多態下會調用子類重寫后的方法）

3、父類引用變量指向子類對象。（涉及子類到父類的類型轉換）

向上轉型 Student person = new Student()

將一個父類的引用指向一個子類對象，成為向上轉型，自動進行類型轉換。此時通過父類引用變量調用的方法是子類覆蓋或繼承父類的方法，而不是父類的方法此時通過父類引用變量無法調用子類特有的方法。

向下轉型 Student stu = (Student)person;

將一個指向子類對象的引用賦給一個子類的引用，成為向下轉型，此時必須進行強制類型轉換。向下轉型必須轉換為父類引用指向的真實子類類型，，否則將出現ClassCastException，不是任意的強制轉換

向下轉型時可以結合使用instanceof運算符進行強制類型轉換，比如出現轉換異常---ClassCastException

傳統的C/C++語言，需要程序員負責回收已經分配內存。

顯式回收垃圾回收的缺點：

1）程序忘記及時回收，從而導致內存泄露，降低系統性能。

2）程序錯誤回收程序核心類庫的內存，導致系統崩潰。

Java語言不需要程序員直接控制內存回收，是由JRE在后臺自動回收不再使用的內存，稱為垃圾回收機制，簡稱GC；

1）可以提高編程效率。

2）保護程序的完整性。

3）其開銷影響性能。Java虛擬機必須跟蹤程序中有用的對象，確定哪些是無用的。

垃圾回收機制的 特點

1）垃圾回收機制回收JVM堆內存里的對象空間,不負責回收棧內存數據。

2）對其他物理連接，比如數據庫連接、輸入流輸出流、Socket連接無能為力。

3）垃圾回收發生具有不可預知性，程序無法精確控制垃圾回收機制執行。

4）可以將對象的引用變量設置為null，暗示垃圾回收機制可以回收該對象。

現在的JVM有多種垃圾回收 實現算法，表現各異。

垃圾回收機制回收任何對象之前，總會先調用它的finalize方法（如果覆蓋該方法，讓一個新的引用變量重新引用該對象，則會重新激活對象）。

程序員可以通過System.gc()或者Runtime.getRuntime().gc()來通知系統進行垃圾回收，會有一些效果，但是系統是否進行垃圾回收依然不確定。

永遠不要主動調用某個對象的finalize方法，應該交給垃圾回收機制調用。

1) 八個基本數據類型的包裝類

2)為什么為基本類型引入包裝類

2.1基本數據類型有方便之處，簡單、高效。

2.2但是Java中的基本數據類型卻是不面向對象的（沒有屬性、方法），這在實際使用時存在很多的不便（比如集合的元素只能是Object）。

為了解決這個不足，在設計類時為每個基本數據類型設計了一個對應的類進行包裝，這樣八個和基本數據類型對應的類統稱為包裝類(Wrapper Class)。

3) 包裝類和基本數據類型之間的轉換

3.1包裝類------ wrapperInstance.xxxValue() ------>基本數據類型

3.2包裝類-------new WrapperClass(primitive)

3.2包裝類-------new WrapperClass(primitive)

4) 自動裝箱和自動拆箱

JDK1.5提供了自動裝箱（autoboxing）和自動拆箱（autounboxing）功能, 從而實現了包裝類和基本數據類型之間的自動轉換

5) 包裝類還可以實現基本類型變量和字符串之間的轉換

基本類型變量--->String.valueof()--->字符串 基本類型變量<---WrapperClass.parseXxx(string)---字符串

int是java提供的8種原始數據類型之一，Java為每個原始類型提供了封裝類，Integer是java為int提供的封裝類。

int是java提供的8種原始數據類型之一，Java為每個原始類型提供了封裝類，Integer是java為int提供的封裝類。

在Hibernate中，如果將OID定義為Integer類型，那么Hibernate就可以根據其值是否為null而判斷一個對象是否是臨時的，如果將OID定義為了int類型，還需要在hbm映射文件中設置其unsaved-value屬性為0。

另外，Integer提供了多個與整數相關的操作方法，例如，將一個字符串轉換成整數，Integer中還定義了表示整數的最大值和最小值的常量。

1） java.sql.Date是java.util.Date的子類，是一個包裝了毫秒值的瘦包裝器，允許 JDBC 將毫秒值標識為 SQL DATE 值。毫秒值表示自 1970 年 1 月 1 日 00:00:00 GMT 以來經過的毫秒數。 為了與 SQL DATE 的定義一致，由 java.sql.Date 實例包裝的毫秒值必須通過將時間、分鐘、秒和毫秒設置為與該實例相關的特定時區中的零來“規范化”。 說白了，java.sql.Date就是與數據庫Date相對應的一個類型，而java.util.Date是純java的Date。

2）JAVA里提供的日期和時間類，java.sql.Date和java.sql.Time,只會從數據庫里讀取某部分值，這有時會導致丟失數據。例如一個包含2002/05/22 5:00:57 PM的字段，讀取日期時得到的是2002/05/22,而讀取時間時得到的是5:00:57 PM. 你需要了解數據庫里存儲時間的精度。有些數據庫，比如MySQL,精度為毫秒，然而另一些數據庫，包括Oracle,存儲SQL DATE類型數據時，毫秒部分的數據是不保存的。以下操作中容易出現不易被發現的BUG：獲得一個JAVA里的日期對象。 從數據庫里讀取日期 試圖比較兩個日期對象是否相等。如果毫秒部分丟失，本來認為相等的兩個日期對象用Equals方法可能返回false。.sql.Timestamp類比java.util.Date類精確度要高。這個類包了一個getTime()方法，但是它不會返回額外精度部分的數據，因此必須使用...

總之，java.util.Date 就是Java的日期對象，而java.sql.Date 是針對SQL語句使用的，只包含日期而沒有時間部分。

package com.bjsxt;
import java.io.File;
public class $ {
public static void main(String[] args) {
        String path = "D:/301SXT";
        test(path);
    }
    private static void test(String path) {
        File f = new File(path);
        File[] fs = f.listFiles();
        if (fs == null) {
            return;
        }
        for (File file : fs) {
            if (file.isFile()) {
                System.out.println(file.getPath());
            } else {
                test(file.getPath());
            }
        }
    }

class A {
public A(){
System.out.println("A");
}
}
class B extends A{
public B(){
System.out.println("B");
}
public static void main(String[] args) {
B b=new B();
}
}

答: 面向對象的三大特征：封裝、繼承、多態。

舉例：（比如設計一個游戲）我現在創建了一個對象，名叫戰士。

戰士的屬性是—性別，年齡，職業，等級，戰斗力，血量。

它的方法—戰斗，逃跑，吃飯，睡覺，死。

后來，我又建了一個對象，叫人。

屬性:性別，年齡，職業，等級，血量

方法:逃跑，吃飯，睡覺，死。

我讓人，成為戰士的父類，戰士可以直接繼承人的屬性和方法。

戰士修改成—

屬性:戰斗力。

方法:戰斗。

看上去戰士的資料變少了，實際上沒有，我們仍然可以調用方法—戰士.死。

而且我們還可以重載戰士.死的方法，簡稱重載死法。

我還建了一個對象—法師，父類也是人。

屬性:法力值

方法:施法，泡妞。

你看，用了繼承，創建對象變得更方便了。

再后來，我又建立了一個對象，叫怪物。

屬性:等級，戰力，血量。

方法:戰斗，死。

建了個對象，叫白兔怪，父類怪物，可繼承怪物所有的屬性和方法。

屬性:毛色。

方法:賣萌，吃胡蘿卜。

答：

內存溢出 out of memory，是指程序在申請內存時，沒有足夠的內存空間供其使用，出現out of memory；比如申請了一個integer,但給它存了long才能存下的數，那就是內存溢出。

內存泄露 memory leak，是指程序在申請內存后，無法釋放已申請的內存空間，一次內存泄露危害可以忽略，但內存泄露堆積后果很嚴重，無論多少內存,遲早會被占光。

memory leak會最終會導致out of memory！

答：Java中的序列化機制能夠將一個實例對象（只序列化對象的屬性值，而不會去序列化什么所謂的方法。）的狀態信息寫入到一個字節流中使其可以通過socket進行傳輸、或者持久化到存儲數據庫或文件系統中；然后在需要的時候通過字節流中的信息來重構一個相同的對象。一般而言，要使得一個類可以序列化，只需簡單實現java.io.Serializable接口即可。

對象的序列化主要有兩種用途：

1） 把對象的字節序列永久地保存到硬盤上，通常存放在一個文件中；

2） 在網絡上傳送對象的字節序列。

在很多應用中，需要對某些對象進行序列化，讓它們離開內存空間，入住物理硬盤，以便長期保存。比如最常見的是Web服務器中的Session對象，當有 10萬用戶并發訪問，就有可能出現10萬個Session對象，內存可能吃不消，于是Web容器就會把一些seesion先序列化到硬盤中，等要用了，再把保存在硬盤中的對象還原到內存中。

當兩個進程在進行遠程通信時，彼此可以發送各種類型的數據。無論是何種類型的數據，都會以二進制序列的形式在網絡上傳送。發送方需要把這個Java對象轉換為字節序列，才能在網絡上傳送；接收方則需要把字節序列再恢復為Java對象。

答：Java創建對象的幾種方式（重要）：

1、 用new語句創建對象，這是最常見的創建對象的方法。

2、 運用反射手段,調用java.lang.Class或者java.lang.reflect.Constructor類的newInstance()實例方法。

3、 調用對象的clone()方法。

4、運用反序列化手段，調用java.io.ObjectInputStream對象的 readObject()方法。

(1)和(2)都會明確的顯式的調用構造函數 ；(3)是在內存上對已有對象的影印，所以不會調用構造函數 ；(4)是從文件中還原類的對象，也不會調用構造函數。

答：匿名內部類是沒有名字的內部類,不能繼承其它類,但一個內部類可以作為一個接口,由另一個內部類實現.

1、由于匿名內部類沒有名字，所以它沒有構造函數。因為沒有構造函數，所以它必須完全借用父類的構造函數來實例化，換言之：匿名內部類完全把創建對象的任務交給了父類去完成。

2、在匿名內部類里創建新的方法沒有太大意義，但它可以通過覆蓋父類的方法達到神奇效果，如上例所示。這是多態性的體現。

3、因為匿名內部類沒有名字，所以無法進行向下的強制類型轉換，持有對一個匿名內部類對象引用的變量類型一定是它的直接或間接父類類型。

(1) 在Java中是使用泛型來約束HashMap中的key和value的類型的，即HashMap< K, V>；而泛型在Java的規定中必須是對象Object類型的，也就是說HashMap< K, V>可以理解為HashMap< Object, Object>，很顯然基本數據類型不是Object類型的，因此不能作為鍵值，只能是引用類型。雖然我們在HashMap中可以這樣添加數據：“map.put(1, “Java”)；”，但實際上是將其中的key值1進行了自動裝箱操作，變為了Integer類型。

(1) 在Java中是使用泛型來約束HashMap中的key和value的類型的，即HashMap< K, V>；而泛型在Java的規定中必須是對象Object類型的，也就是說HashMap< K, V>可以理解為HashMap< Object, Object>，很顯然基本數據類型不是Object類型的，因此不能作為鍵值，只能是引用類型。雖然我們在HashMap中可以這樣添加數據：“map.put(1, “Java”)；”，但實際上是將其中的key值1進行了自動裝箱操作，變為了Integer類型。

實現多態有三個前提條件：

1、 繼承的存在；（繼承是多態的基礎，沒有繼承就沒有多態）。

2、子類重寫父類的方法。（多態下會調用子類重寫后的方法）。

3、父類引用變量指向子類對象。（涉及子類到父類的類型轉換）。

最后使用父類的引用變量調用子類重寫的方法即可實現多態。

54.Java 中 Math.random（）/Math.random（）值為？

如果除數與被除數均為0.0的話，則運行結果為NaN（Not a Number的簡寫），計算錯誤。

不是，兩者沒有任何關聯；

Pair是單獨的類，只不過用不同類型的參數（泛型）進行了相應的實例化而已；所以，Pair< Manager>和Pair< Employee>不是子類的關系。

56.接口和抽象類的區別

抽象類和接口均包含抽象方法，類必須實現所有的抽象方法，否則是抽象類

抽象類和接口都不能實例化，他們位于繼承樹的頂端，用來被其他類繼承和實現

兩者的區別主要體現在兩方面：語法方面和設計理念方面

語法方面的區別是比較低層次的，非本質的，主要表現在：

接口中只能定義全局靜態常量，不能定義變量。抽象類中可以定義常量和變量。

接口中所有的方法都是全局抽象方法。抽象類中可以有0個、1個或多個，甚至全部都是抽象方法。

抽象類中可以有構造方法，但不能用來實例化，而在子類實例化是執行，完成屬于抽象類的初始化操作。接口中不能定義構造方法。

一個類只能有一個直接父類（可以是抽象類），但可以充實實現多個接口。一個類使用extends來繼承抽象類，使用implements來實現接口。

一個類只能有一個直接父類（可以是抽象類），但可以充實實現多個接口。一個類使用extends來繼承抽象類，使用implements來實現接口。

抽象類體現了一種繼承關系，目的是復用代碼，抽象類中定義了各個子類的相同代碼，可以認為父類是一個實現了部分功能的“中間產品”，而子類是“最終產品”。父類和子類之間必須存在“is-a”的關系，即父類和子類在概念本質上應該是相同的。

接口并不要求實現類和接口在概念本質上一致的，僅僅是實現了接口定義的約定或者能力而已。接口定義了“做什么”，而實現類負責完成“怎么做”，體現了功能（規范）和實現分離的原則。接口和實現之間可以認為是一種“has-a的關系”

相同點：

同步方法就是在方法前加關鍵字synchronized，然后被同步的方法一次只能有一個線程進入，其他線程等待。而同步代碼塊則是在方法內部使用大括號使得一個代碼塊得到同步。同步代碼塊會有一個同步的“目標”，使得同步塊更加靈活一些（同步代碼塊可以通過“目標”決定需要鎖定的對象）。

一般情況下，如果此“目標”為this，同步方法和代碼塊沒有太大的區別。

區別：

同步方法直接在方法上加synchronized實現加鎖，同步代碼塊則在方法內部加鎖。很明顯，同步方法鎖的范圍比較大，而同步代碼塊范圍要小點。一般同步的范圍越大，性能就越差。所以一般需要加鎖進行同步的時候，范圍越小越好，這樣性能更好。

靜態內部類不需要有指向外部類的引用。但非靜態內部類需要持有對外部類的引用。

靜態內部類可以有靜態成員(方法，屬性)，而非靜態內部類則不能有靜態成員(方法，屬性)。

非靜態內部類能夠訪問外部類的靜態和非靜態成員。靜態內部類不能訪問外部類的非靜態成員，只能訪問外部類的靜態成員。

實例化方式不同：

1) 靜態內部類：不依賴于外部類的實例，直接實例化內部類對象

2) 非靜態內部類：通過外部類的對象實例生成內部類對象

反射的概念：

反射，一種計算機處理方式。是程序可以訪問、檢測和修改它本身狀態或行為的一種能力。

Java反射可以于運行時加載,探知和使用編譯期間完全未知的類.

程序在運行狀態中, 可以動態加載一個只有名稱的類, 對于任意一個已經加載的類,都能夠知道這個類的所有屬性和方法; 對于任意一個對象,都能調用他的任意一個方法和屬性;

加載完類之后, 在堆內存中會產生一個Class類型的對象(一個類只有一個Class對象), 這個對象包含了完整的類的結構信息,而且這個Class對象就像一面鏡子,透過這個鏡子看到類的結構,所以被稱之為:反射.

java反射使得我們可以在程序運行時動態加載一個類，動態獲取類的基本信息和定義的方法,構造函數,域等。

除了檢閱類信息外，還可以動態創建類的實例，執行類實例的方法，獲取類實例的域值。反射使java這種靜態語言有了動態的特性。

反射的作用：

通過反射可以使程序代碼訪問裝載到JVM 中的類的內部信息

1) 獲取已裝載類的屬性信息

2) 獲取已裝載類的方法

3) 獲取已裝載類的構造方法信息

反射的優點：

增加程序的靈活性。

如struts中。請求的派發控制。

當請求來到時。struts通過查詢配置文件。找到該請求對應的action。已經方法。

然后通過反射實例化action。并調用響應method。

如果不適用反射，那么你就只能寫死到代碼里了。

所以說，一個靈活，一個不靈活。

很少情況下是非用反射不可的。大多數情況下反射是為了提高程序的靈活性。因此一般框架中使用較多。因為框架要適用更多的情況。對靈活性要求較高。

public class Test1 {
public static void main(String[] args) {
int a = 0;
int c = 0;
do{
--c;
a = a - 1;
} while (a > 0);
System.out.println(c);
}
}

78.存在使i+1< i的數么?

接口可以繼承接口，抽象類可以實現接口，抽象類可以繼承實體類。

int是java提供的8種原始數據類型之一。Java為每個原始類型提供了封裝類，Integer是java為int提供的封裝類。int的默認值為0，而Integer的默認值為null，即Integer可以區分出未賦值和值為0的區別，int則無法表達出未賦值的情況，例如，要想表達出沒有參加考試和考試成績為0的區別，則只能使用Integer。在JSP開發中，Integer的默認為null，所以用el表達式在文本框中顯示時，值為空白字符串，而int默認的默認值為0，所以用el表達式在文本框中顯示時，結果為0，所以，int不適合作為web層的表單數據的類型。

在Hibernate中，如果將OID定義為Integer類型，那么Hibernate就可以根據其值是否為null而判斷一個對象是否是臨時的，如果將OID定義為了int類型，還需要在hbm映射文件中設置其unsaved-value屬性為0。另外，Integer提供了多個與整數相關的操作方法，例如，將一個字符串轉換成整數，Integer中還定義了表示整數的最大值和最小值的常量。

SerialVersionUid，簡言之，其目的是序列化對象版本控制，有關各版本反序列化時是否兼容。如果在新版本中這個值修改了，新版本就不兼容舊版本，反序列化時會拋出InvalidClassException異常。如果修改較小，比如僅僅是增加了一個屬性，我們希望向下兼容，老版本的數據都能保留，那就不用修改；如果我們刪除了一個屬性，或者更改了類的繼承關系，必然不兼容舊數據，這時就應該手動更新版本號，即SerialVersionUid。

< a\b[^>]+\bhref="([^"]*)"[^>]*>([\s\S]*?)< /a>

< a\b[^>]+\bhref="([^"]*)"[^>]*>([\s\S]*?)< /a>

答: 110

答:Java程序中創建新的類對象，使用關鍵字new是正確的; 回收無用的類對象使用關鍵字free是錯誤的.

答:getDeclaredFields(): 可以獲取所有本類自己聲明的方法, 不能獲取繼承的方法

getFields(): 只能獲取所有public聲明的方法, 包括繼承的方法

答:不正確。

通常情況下，進行比較判斷的處理，switch 和if-else可以互相轉換來寫；if-else作用的范圍比switch-case作用范圍要大，但是當switch-case和if-else都可以用的情況下，通常推薦使用switch-case。

比如：

switch (ch) {
case 'a':
System.out.println("A");
break;
case 'b':
System.out.println("B");
break;
case 'c':
System.out.println("C");
break;
case 'd':
System.out.println("D");
break;
case 'e':
System.out.println("E");
break;
default:
System.out.println("other");
break;
}

換為if-else

if (ch == 'a') {
System.out.println("A");
} else if (ch == 'b') {
System.out.println('B');
} else if (ch == 'c') {
System.out.println("C");
} else if (ch == 'd') {
System.out.println("D");
} else if (ch == 'e') {
System.out.println("E");
} else {
System.out.println("Other");
}

&和&&的聯系(共同點)：

&和&&都可以用作邏輯與運算符，但是要看使用時的具體條件來決定。

操作數1&操作數2，操作數1&&操作數2，

操作數1&操作數2，操作數1&&操作數2，

情況1：當上述的操作數是boolean類型變量時，&和&&都可以用作邏輯與運算符。

情況2：當上述的表達式結果是boolean類型變量時，&和&&都可以用作邏輯與運算符。

表示邏輯與(and)，當運算符兩邊的表達式的結果或操作數都為true時，整個運算結果才為true，否則，只要有一方為false，結果都為false。

表示邏輯與(and)，當運算符兩邊的表達式的結果或操作數都為true時，整個運算結果才為true，否則，只要有一方為false，結果都為false。

(1)、&邏輯運算符稱為邏輯與運算符，&&邏輯運算符稱為短路與運算符，也可叫邏輯與運算符。

對于&：無論任何情況，&兩邊的操作數或表達式都會參與計算。

對于&&：當&&左邊的操作數為false或左邊表達式結果為false時，&&右邊的操作數或表達式將不參與計算，此時最終結果都為false。

綜上所述，如果邏輯與運算的第一個操作數是false或第一個表達式的結果為false時，對于第二個操作數或表達式是否進行運算，對最終的結果沒有影響，結果肯定是false。推介平時多使用&&，因為它效率更高些。

(2)、&還可以用作位運算符。當&兩邊操作數或兩邊表達式的結果不是boolean類型時，&用于按位與運算符的操作。

final修飾基本類型變量，其值不能改變。

但是final修飾引用類型變量，棧內存中的引用不能改變，但是所指向的堆內存中的對象的屬性值仍舊可以改變。

例如:

class Test {
    public static void main(String[] args) {
        final Dog dog = new Dog("歐歐");
        dog.name = "美美";//正確
        dog = new Dog("亞亞");//錯誤
    }
}

\d: 匹配一個數字字符。等價于[0-9]

\D: 匹配一個非數字字符。等價于[^0-9]

\s: 匹配任何空白字符，包括空格、制表符、換頁符等等。等價于 [ \f\n\r\t\v]

. ：匹配除換行符 \n 之外的任何單字符。要匹配 . ，請使用 \. 。

*：匹配前面的子表達式零次或多次。要匹配 * 字符，請使用 \*。

+：匹配前面的子表達式一次或多次。要匹配 + 字符，請使用 \+。

|:將兩個匹配條件進行邏輯“或”（Or）運算

[0-9]{6}:匹配連續6個0-9之間的數字

\d+：匹配至少一個0-9之間的數字

System.out.println(""+("12"=="12"&&"12".equals("12")));
(“12”==”12”&&”12”.equals(“12”))
“12”==”12”&&”12”.equals(“12”)

true

false

int  i=1；
 Int  j=i++；
 If（（j>++j）&&(i++==j)）{j+=i:}
 System.out.println(j);

package com.bjsxt;

public class smaillT{
public static void main(String args[]){
smaillT t=new smaillT();
int b = t.get();
System.out.println(b);
}

public int get()
{
try {
return 1;
}finally{
return 2;
}
}
}

輸出結果：2

int i=9;
switch (i) {
default:
System.out.println("default");
case 0:
System.out.println("zero");
break;
case 1:
System.out.println("one");
break;
case 2:
System.out.println("two");
break;
}

打印結果：

打印結果：

zero

繼承（英語：inheritance）是面向對象軟件技術當中的一個概念。如果一個類別A“繼承自”另一個類別B，就把這個A稱為“B的子類別”，而把B稱為“A的父類別”也可以稱“B是A的超類”。繼承可以使得子類別具有父類別的各種屬性和方法，而不需要再次編寫相同的代碼。在令子類別繼承父類別的同時，可以重新定義某些屬性，并重寫某些方法，即覆蓋父類別的原有屬性和方法，使其獲得與父類別不同的功能。另外，為子類別追加新的屬性和方法也是常見的做法。 一般靜態的面向對象編程語言，繼承屬于靜態的，意即在子類別的行為在編譯期就已經決定，無法在執行期擴充。

那么如何使用繼承呢？用extends關鍵字來繼承父類。

如上面A類與B類，當寫繼承語句時， class A類 extends B類{ } 其中A類是子類，B類是父類。

計算機不能直接理解高級語言，只能理解和運行機器語言，所以必須要把高級語言翻譯成機器語言，計算機才能運行高級語言所編寫的程序。翻譯的方式有兩種，一個是編譯，一個是解釋。

用編譯型語言寫的程序執行之前，需要一個專門的編譯過程，通過編譯系統把高級語言翻譯成機器語言，把源高級程序編譯成為機器語言文件，比如windows下的exe文件。以后就可以直接運行而不需要編譯了，因為翻譯只做了一次，運行時不需要翻譯，所以一般而言，編譯型語言的程序執行效率高。

解釋型語言在運行的時候才翻譯，比如VB語言，在執行的時候，專門有一個解釋器能夠將VB語言翻譯成機器語言，每個語句都是執行時才翻譯。這樣解釋型語言每執行一次就要翻譯一次，效率比較低。

編譯型與解釋型，兩者各有利弊。前者由于程序執行速度快，同等條件下對系統要求較低，因此像開發操作系統、大型應用程序、數據庫系統等時都采用它，像C/C++、Pascal/Object Pascal（Delphi）等都是編譯語言，而一些網頁腳本、服務器腳本及輔助開發接口這樣的對速度要求不高、對不同系統平臺間的兼容性有一定要求的程序則通常使用解釋性語言，如JavaScript、VBScript、Perl、Python、Ruby、MATLAB 等等。

JAVA語言是一種編譯型-解釋型語言，同時具備編譯特性和解釋特性（其實，確切的說java就是解釋型語言，其所謂的編譯過程只是將.java文件編程成平臺無關的字節碼.class文件，并不是向C一樣編譯成可執行的機器語言，在此請讀者注意Java中所謂的“編譯”和傳統的“編譯”的區別）。作為編譯型語言，JAVA程序要被統一編譯成字節碼文件——文件后綴是class。此種文件在java中又稱為類文件。java類文件不能再計算機上直接執行，它需要被java虛擬機翻譯成本地的機器碼后才能執行，而java虛擬機的翻譯過程則是解釋性的。java字節碼文件首先被加載到計算機內存中，然后讀出一條指令，翻譯一條指令，執行一條指令，該過程被稱為java語言的解釋執行，是由java虛擬機完成的。

&和&&都可以用作邏輯與運算符，但是要看使用時的具體條件來決定。

情況1：當上述的操作數是boolean類型變量時，&和&&都可以用作邏輯與運算符。

情況2：當上述的表達式結果是boolean類型變量時，&和&&都可以用作邏輯與運算符。

表示邏輯與(and)，當運算符兩邊的表達式的結果或操作數都為true時，整個運算結果才為true，否則，只要有一方為false，結果都為false。

&和&&的區別(不同點)：

(1)、&邏輯運算符稱為邏輯與運算符，&&邏輯運算符稱為短路與運算符，也可叫邏輯與運算符。

對于&：無論任何情況，&兩邊的操作數或表達式都會參與計算。

對于&&：當&&左邊的操作數為false或左邊表達式結果為false時，&&右邊的操作數或表達式將不參與計算，此時最終結果都為false。

綜上所述，如果邏輯與運算的第一個操作數是false或第一個表達式的結果為false時，對于第二個操作數或表達式是否進行運算，對最終的結果沒有影響，結果肯定是false。推介平時多使用&&，因為它效率更高些。

(2)、&還可以用作位運算符。當&兩邊操作數或兩邊表達式的結果不是boolean類型時，&用于按位與運算符的操作。

|和||的區別和聯系與&和&&的區別和聯系類似

在異常處理時提供 finally 塊來執行任何清除操作。

如果有finally的話，則不管是否發生異常，finally語句都會被執行，包括遇到return語句。

finally中語句不執行的唯一情況中執行了System.exit(0)語句。