前言
2020，是一個不平凡的一年疫情導致很多人家裡辦公，公司解體，尋找新的上家，相對往年我們會發現今年獵頭電話少了，大部分企業年終獎縮水，加薪幅度也不如往年，選擇好offer就要趁早，現在開始準備吧，刷一波Java面試題，能回答70%就去BATJTMD大膽試試~
本題集適合應聘Java和JavaEE職位的程序員作為面試複習、學習和強化的資料，也適合其他程序員作為拓展讀物進行閱讀。包含了常見的算法、面試題，也包含了新的高級技術，比如：微服務架構等技術的面試題目。本題集非常全面，對於工作1-5年左右的java程序員面試有非常好的指導作用。
1.大學生高端複合人才成長
1.JAVA專業，1000課3.大數據專業，500課2.Python專業，500課 4.人工智能專業，500課
四個專業都要學，從零開始2000小時，成為高端人才，打下一生技術基礎，不再是低端碼農。
Java基礎、語法：
1.Java跨平臺原理（字節碼文件、虛擬機）
C/C++語言都直接編譯成針對特定平臺機器碼。如果要跨平臺，需要使用相應的編譯器重新編譯。
Java源程序（.java）要先編譯成與平臺無關的字節碼文件(.class)，然後字節碼文件再解釋成機器碼運行。解釋是通過Java虛擬機來執行的。
字節碼文件不面向任何具體平臺，只面向虛擬機。
Java虛擬機是可運行Java字節碼文件的虛擬計算機。不同平臺的虛擬機是不同的，但它們都提供了相同的接口。
Java語言具有一次編譯，到處運行的特點。就是說編譯後的.class可以跨平臺運行，前提是該平臺具有相應的Java虛擬機。但是性能比C/C++要低。
Java的跨平臺原理決定了其性能沒有C/C++高
2.Java的安全性
語言層次的安全性主要體現在：
Java取消了強大但又危險的指針，而代之以引用。由於指針可進行移動運算，指針可隨便指向一個內存區域，而不管這個區域是否可用，這樣做是危險的，因為原來這個內存地址可能存儲著重要數據或者是其他程序運行所佔用的，並且使用指針也容易數組越界。
垃圾回收機制：不需要程序員直接控制內存回收，由垃圾回收器在後臺自動回收不再使用的內存。避免程序忘記及時回收，導致內存洩露。避免程序錯誤回收程序核心類庫的內存，導致系統崩潰。
異常處理機制：Java異常機制主要依賴於try、catch、finally、throw、throws五個關鍵字。
強制類型轉換：只有在滿足強制轉換規則的情況下才能強轉成功。
底層的安全性可以從以下方面來說明
Java在字節碼的傳輸過程中使用了公開密鑰加密機制(PKC)。
在運行環境提供了四級安全性保障機制：
字節碼校驗器 -類裝載器 -運行時內存佈局 -文件訪問限制
3.Java三大版本
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的覆蓋範圍各不相同。
4.什麼是JVM？什麼是JDK？ 什麼是JRE？
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。現在我們可以看出這樣一個關係，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虛擬機內部包含許多應用程序的類的解釋器和類加載器等等。
5.Java三種註釋類型
共有單行註釋、多行註釋、文檔註釋3種註釋類型。使用如下：
單行註釋，採用“//”方式.只能註釋一行代碼。如：//類成員變量
多行註釋，採用“/*...*/”方式，可註釋多行代碼，其中不允許出現嵌套。如：
/*System.out.println("a");
System.out.println("b");
System.out.println("c");*/
文檔註釋，採用“/**...*/”方式。如：
/**
* 子類 Dog
* @author Administrator
**/
public class Dog extends Animal{}
6.8種基本數據類型及其字節數
數據類型關鍵字字節數數值型整數型byte1short2int4long8浮點型float4double8布爾型boolean1（位）字符型char2
7.i++和++i的異同之處
共同點：
1、i++和++i都是變量自增1，都等價於i=i+1
2、如果i++,++i是一條單獨的語句，兩者沒有任何區別
3、i++和++i的使用僅僅針對變量。 5++和++5會報錯，因為5不是變量。
不同點：
如果i++,++i不是一條單獨的語句，他們就有區別i++ ：先運算後增1。如：
1
2
3
4
int x=5;
int y=x++;
System.out.println("x="+x+", y="+y);
//以上代碼運行後輸出結果為：x=6, y=5
++i ： 先增1後運算。如：
1
2
3
4
int x=5;
int y=++x;
System.out.println("x="+x+", y="+y);
//以上代碼運行後輸出結果為：x=6, y=6
8.&和&&的區別和聯繫，|和||的區別和聯繫
&和&&的聯繫(共同點)：
&和&&都可以用作邏輯與運算符，但是要看使用時的具體條件來決定。
操作數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類型時，&用於按位與運算符的操作。
|和||的區別和聯繫與&和&&的區別和聯繫類似
9.用最有效率的方法算出2乘以8等於多少
使用位運算來實現效率最高。位運算符是對操作數以二進制比特位為單位進行操作和運算，操作數和結果都是整型數。對於位運算符“<
10.基本數據類型的類型轉換規則
基本類型轉換分為自動轉換和強制轉換。
自動轉換規則：容量小的數據類型可以自動轉換成容量大的數據類型，也可
以說低級自動向高級轉換。這兒的容量指的不是字節數，而是指類型表述的範圍。
強制轉換規則：高級變為低級需要強制轉換。
如何轉換：
（1）賦值運算符“=”右邊的轉換，先自動轉換成表達式中級別最高的數據類型，再進行運算。
（2）賦值運算符“=”兩側的轉換，若左邊級別>右邊級別，會自動轉換；若左邊級別 == 右邊級別，不用轉換；若左邊級別 < 右邊級別，需強制轉換。
(3)可以將整型常量直接賦值給byte, short, char等類型變量，而不需要進行強制類型轉換，前提是不超出其表述範圍，否則必須進行強制轉換。
11.if多分支語句和switch多分支語句的異同之處
相同之處：都是分支語句，多超過一種的情況進行判斷處理。
不同之處：
switch更適合用於多分支情況，就是有很多種情況需要判斷處理，判斷條件類型單一，只有一個入口，在分支執行完後（如果沒有break跳出），不加判斷地執行下去;而if—elseif---else多分枝主要適用於分支較少的分支結構，判斷類型不是單一，只要一個分支被執行後，後邊的分支不再執行。switch為等值判斷（不允許比如>=
<=），而if為等值和區間都可以，if的使用範圍大。12.while和do-while循環的區別
while先判斷後執行，第一次判斷為false,循環體一次都不執行
do while先執行 後判斷，最少執行1次。
如果while循環第一次判斷為true, 則兩種循環沒有區別。
13.break和continue的作用
break: 結束當前循環並退出當前循環體。
break還可以退出switch語句
continue: 循環體中後續的語句不執行，但是循環沒有結束，繼續進行循環條件的判斷（for循環還會i++）。continue只是結束本次循環。
14.請使用遞歸算法計算n！
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
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());
}
}
}
15.遞歸的定義和優缺點
遞歸算法是一種直接或者間接地調用自身算法的過程。在計算機編寫程序中，遞歸算法對解決一大類問題是十分有效的，它往往使算法的描述簡潔而且易於理解。
遞歸算法解決問題的特點：
(1) 遞歸就是在過程或函數里調用自身。
(2) 在使用遞歸策略時，必須有一個明確的遞歸結束條件，稱為遞歸出口。
(3) 遞歸算法解題通常顯得很簡潔，但運行效率較低。所以一般不提倡用遞歸算法設計程序。
(4) 在遞歸調用的過程當中系統為每一層的返回點、局部量等開闢了棧來存儲。遞歸次數過多容易造成棧溢出等。所以一般不提倡用遞歸算法設計程序。
16.數組的特徵
數組是（相同類型數據）的（有序）（集合）
數組會在內存中開闢一塊連續的空間，每個空間相當於之前的一個變量，稱為數組的元素element
元素的表示 數組名[下標或者索引] scores[7] scores[0] scores[9]
索引從0開始
每個數組元素有默認值 double 0.0 boolean false int 0
數組元素有序的，不是大小順序，是索引 的順序
數組中可以存儲基本數據類型，可以存儲引用數據類型；但是對於一個數組而言，數組的類型是固定的，只能是一個
length:數組的長度
數組的長度是固定的，一經定義，不能再發生變化（數組的擴容）
17.請寫出冒泡排序代碼
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
package com.bjsxt;
public class TestBubbleSort {
public static void sort(int[] a) {
int temp = 0;
// 外層循環，它決定一共走幾趟
for (int i = 0; i
//內層循環，它決定每趟走一次
for (int j = 0; 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
//通過符號位可以減少無謂的比較，如果已經有序了，就退出循環
int flag = 0;
for (int j = 0; 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;
}
}
}
}
18.請寫出選擇排序的代碼
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
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;
}
}
}
}
19.請寫出插入排序的代碼
1
2
3
4
5
6
7
8
9
10
11
12
13
14
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;
}
}
}
20.可變參數的作用和特點
總結1：可變參數
1.可變參數的形式 ...
2.可變參數只能是方法的形參
3.可變參數對應的實參可以0,1,2.....個，也可以是一個數組
4.在可變參數的方法中，將可變參數當做數組來處理
5.可變參數最多有一個，只能是最後一個
6.可變參數好處：方便 簡單 減少重載方法的數量
7.如果定義了可變參數的方法，不允許同時定義相同類型數組參數的方法
總結2：數組做形參和可變參數做形參聯繫和區別
聯繫：
1.實參都可以是數組；2.方法體中，可變參數當做數組來處理
區別：
1.個數不同 可變參數只能有一個數組參數可以多個
2.位置不同 可變參數只能是最後一個 數組參數位置任意
3.實參不同 可變參數實參可以0,1,2.....個，也可以是一個數組，數組的實參只能是數組
21.類和對象的關係
類是對象的抽象，而對象是類的具體實例。類是抽象的，不佔用內存，而對象是具體的，佔用存儲空間。類是用於創建對象的藍圖，它是一個定義包括在特定類型的對象中的方法和變量的軟件模板。
類和對象好比圖紙和實物的關係，模具和鑄件的關係。
比如人類就是一個概念，人類具有身高，體重等屬性。人類可以做吃飯、說話等方法。
小明就是一個具體的人，也就是實例，他的屬性是具體的身高200cm，體重180kg，他做的方法是具體的吃了一碗白米飯，說了“12345”這樣一句話。
22.面向過程和麵向對象的區別
兩者都是軟件開發思想，先有面向過程，後有面向對象。在大型項目中，針對面向過程的不足推出了面向對象開發思想。
比喻
蔣介石和毛澤東分別是面向過程和麵向對象的傑出代表，這樣充分說明，在解決複製問題時，面向對象有更大的優越性。
面向過程是蛋炒飯，面向對象是蓋澆飯。蓋澆飯的好處就是“菜”“飯”分離，從而提高了製作蓋澆飯的靈活性。飯不滿意就換飯，菜不滿意換菜。用軟件工程的專業術語就是“可維護性”比較好，“飯” 和“菜”的耦合度比較低。
區別
編程思路不同： 面向過程以實現功能的函數開發為主，而面向對象要首先抽象出類、屬性及其方法，然後通過實例化類、執行方法來完成功能。
封裝性：都具有封裝性，但是面向過程是封裝的是功能，而面向對象封裝的是數據和功能。
面向對象具有繼承性和多態性，而面向過程沒有繼承性和多態性，所以面向對象優勢是明顯。
方法重載和方法重寫（覆蓋）的區別
英文位置不同作用不同重載overload同一個類中在一個類裡面為一種行為提供多種實現方式並提高可讀性重寫override子類和父類間父類方法無法滿足子類的要求，子類通過方法重寫滿足要求
修飾符返回值方法名參數拋出異常重載無關無關相同不同無關重寫大於等於小於等於相同相同小於等於
23.this和super關鍵字的作用
this是對象內部指代自身的引用,同時也是解決成員變量和局部變量同名問題；this可以調用成員變量，不能調用局部變量；this也可以調用成員方法，但是在普通方法中可以省略this，在構造方法中不允許省略，必須是構造方法的第一條語句。，而且在靜態方法當中不允許出現this關鍵字。
super代表對當前對象的直接父類對象的引用，super可以調用直接父類的成員變量（注意權限修飾符的影響，比如不能訪問private成員）
super可以調用直接父類的成員方法（注意權限修飾符的影響，比如不能訪問private成員）；super可以調用直接父類的構造方法，只限構造方法中使用，且必須是第一條語句。
24.static關鍵字的作用
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內部類：屬於整個外部類，而不是屬於外部類的每個對象。不能訪問外部類的非靜態成員（變量或者方法），.可以訪問外部類的靜態成員
25.final和abstract關鍵字的作用
final和abstract是功能相反的兩個關鍵字，可以對比記憶
abstract可以用來修飾類和方法，不能用來修飾屬性和構造方法；使用abstract修飾的類是抽象類，需要被繼承，使用abstract修飾的方法是抽象方法，需要子類被重寫。
final可以用來修飾類、方法和屬性，不能修飾構造方法。使用final修飾的類不能被繼承，使用final修飾的方法不能被重寫，使用final修飾的變量的值不能被修改，所以就成了常量。
特別注意：final修飾基本類型變量，其值不能改變，由原來的變量變為常量；但是final修飾引用類型變量，棧內存中的引用不能改變，但是所指向的堆內存中的對象的屬性值仍舊可以改變。例如
1
2
3
4
5
6
7
8
9
package com.bjsxt;
class Test {
public static void main(String[] args) {
final Dog dog = new Dog("歐歐");
dog.name = "美美";//正確
dog = new Dog("亞亞");//錯誤
}
}
26.final、finally、finalize的區別
final修飾符（關鍵字）如果一個類被聲明為final，意味著它不能再派生出新的子類，不能作為父類被繼承例如：String類、Math類等。將變量或方法聲明為final，可以保證它們在使用中不被改變。被聲明為final的變量必須在聲明時給定初值，而在以後的引用中只能讀取，不可修改。被聲明為final的方法也同樣只能使用，不能重寫，但是能夠重載。 使用final修飾的對象，對象的引用地址不能變，但是對象的值可以變！
finally在異常處理時提供 finally 塊來執行任何清除操作。如果有finally的話，則不管是否發生異常，finally語句都會被執行。一般情況下，都把關閉物理連接(IO流、數據庫連接、Socket連接)等相關操作，放入到此代碼塊中。
finalize方法名。Java 技術允許使用 finalize() 方法在垃圾收集器將對象從內存中清除出去之前做必要清理工作。finalize() 方法是在垃圾收集器刪除對象之前被調用的。它是在 Object 類中定義的，因此所有的類都繼承了它。子類覆蓋 finalize() 方法以整理系統資源或者執行其他清理工作。 一般情況下，此方法由JVM調用，程序員不要去調用！
27.寫出java.lang.Object類的六個常用方法
(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() 多線程中喚醒所有等待線程的功能
28.private/默認/protected/public權限修飾符的區別
同一個類同一個包子類所有類private*defailt**protected***public****
類的訪問權限只有兩種
public公共的 可被同一項目中所有的類訪問。 (必須與文件名同名)
default默認的 可被同一個包中的類訪問。
成員（成員變量或成員方法）訪問權限共有四種：
public 公共的 可以被項目中所有的類訪問。(項目可見性)
protected 受保護的 可以被這個類本身訪問；同一個包中的所有其他的類訪問；被它的子類（同一個包以及不同包中的子類）訪問。（子類可見性）
default 默認的被這個類本身訪問；被同一個包中的類訪問。（包可見性）
private 私有的 只能被這個類本身訪問。（類可見性）
29.繼承條件下構造方法的執行過程
繼承條件下構造方法的調用規則如下：
情況1：如果子類的構造方法中沒有通過super顯式調用父類的有參構造方法，也沒有通過this顯式調用自身的其他構造方法，則系統會默認先調用父類的無參構造方法。在這種情況下，寫不寫“super();”語句，效果是一樣的。
情況2：如果子類的構造方法中通過super顯式調用父類的有參構造方法，那將執行父類相應構造方法，而不執行父類無參構造方法。
情況3：如果子類的構造方法中通過this顯式調用自身的其他構造方法，在相應構造方法中應用以上兩條規則。
特別注意的是，如果存在多級繼承關係，在創建一個子類對象時，以上規則會多次向更高一級父類應用，一直到執行頂級父類Object類的無參構造方法為止。
30.==和equals的區別和聯繫
“==”是關係運算符，equals()是方法，同時他們的結果都返回布爾值；
“==”使用情況如下：
a) 基本類型，比較的是值
b) 引用類型，比較的是地址
c) 不能比較沒有父子關係的兩個對象
equals()方法使用如下：
a) 系統類一般已經覆蓋了equals()，比較的是內容。
b) 用戶自定義類如果沒有覆蓋equals()，將調用父類的equals （比如是Object），而Object的equals的比較是地址（return (this == obj);）
c) 用戶自定義類需要覆蓋父類的equals()
注意：Object的==和equals比較的都是地址，作用相同
31.談談Java的多態
實現多態的三個條件（前提條件，向上轉型、向下轉型）
1、繼承的存在；（繼承是多態的基礎，沒有繼承就沒有多態）
2、子類重寫父類的方法。（多態下會調用子類重寫後的方法）
3、父類引用變量指向子類對象。（涉及子類到父類的類型轉換）
向上轉型 Student person = new Student()
將一個父類的引用指向一個子類對象，成為向上轉型，自動進行類型轉換。此時通過父類引用變量調用的方法是子類覆蓋或繼承父類的方法，而不是父類的方法此時通過父類引用變量無法調用子類特有的方法。
向下轉型 Student stu = (Student)person;
將一個指向子類對象的引用賦給一個子類的引用，成為向下轉型，此時必須進行強制類型轉換。向下轉型必須轉換為父類引用指向的真實子類類型，，否則將出現ClassCastException，不是任意的強制轉換
向下轉型時可以結合使用instanceof運算符進行強制類型轉換，比如出現轉換異常---ClassCastException
32.簡述Java的垃圾回收機制
傳統的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方法，應該交給垃圾回收機制調用。
33.基本數據類型和包裝類
1) 八個基本數據類型的包裝類
基本數據類型包裝類
byteBytebooleanBooleanshortShortcharCharacterintIntegerlongLongfloatFloatdoubleDouble
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()--->字符串 基本類型變量
34.Integer與int的區別
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中還定義了表示整數的最大值和最小值的常量。
35.java.sql.Date和java.util.Date的聯繫和區別
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語句使用的，只包含日期而沒有時間部分。
36.使用遞歸算法輸出某個目錄下所有文件和子目錄列表
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
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());
}
}
}
37.關於Java編譯，下面哪一個正確（）（選擇一項）
AJava程序經編譯後產生machine codeB.Java程序經編譯後會生產byte codeC.Java程序經編譯後會產生DLLD.以上都不正確答案：B分析： Java是解釋型語言，編譯出來的是字節碼； 因此A不正確，C是C/C++語言編譯動態鏈接庫的文件為.DLL； 正確答案為B
38.下列說法正確的有（）（選擇一項）
Aclass中的construtor不可省略B.construtor與class同名，但方法不能與class同名C.construtor在一個對象被new時執行D.一個class只能定義一個construtor答案：C分析：A：如果class中的construtor省略不寫，系統會默認提供一個無參構造B：方法名可以與類名同名，只是不符合命名規範D：一個class中可以定義N多個construtor，這些construtor構成構造方法的重載
39.Java中接口的修飾符可以為（）（選擇一項）
AprivateB.protectedC.finalD.abstract答案：D分析：接口中的訪問權限修飾符只可以是public或default接口中的所有的方法必須要實現類實現，所以不能使用final接口中所有的方法默認都是abstract的，所以接口可以使用abstract修飾，但通常abstract可以省略不寫
40.給定以下代碼，程序將輸出 （）（選擇一項）
1
2
3
4
5
6
7
8
9
10
11
12
13
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();
}
}
A不能通過編譯B.通過編譯，輸出ABC.通過編譯，輸出BD.通過編譯，輸出A答案：B分析：在繼承關係下，創建子類對象，先執行父類的構造方法，再執行子類的構造方法。
41.下列關於關鍵字的使用說法錯誤的是（）（選擇一項）
Aabstract不能與final並列修飾同一個類B.abstract類中可以有private的成員C.abstract方法必須在abstract類中D.static方法能處理非static的屬性答案：D分析：因為static得方法在裝載class得時候首先完成，比 構造方法早，此時非static得屬性和方法還沒有完成初始化所以不能調用。
42.下列哪些語句關於內存回收的說法是正確的（）（選擇一項）
A程序員必須創建一個線程來釋放內存B.內存回收程序負責釋放無用內存C.內存回收程序允許程序員直接釋放內存D.內存回收程序可以在指定的時間釋放內存對象答案：B分析： A. 程序員不需要創建線程來釋放內存.C. 也不允許程序員直接釋放內存.D. 不一定在什麼時刻執行垃圾回收.
43.選出合理的標識符（）（選擇兩項）
A_sysl_111B.2 mailC.$changeD.class答案：AC分析： 標識符的命令規範，可以包含字母、數字、下劃線、$，不能以數字開頭，不能是Java關鍵字
44.下列說法正確的是（）（選擇多項）
Ajava.lang.Cloneable是類B.java.langRunnable是接口C.Double對象在java.lang包中D.Double a=1.0是正確的java語句Double a=1.0是正確的java語句分析：java.lang.Cloneable是接口
45.定義一個類名為”MyClass.java”的類，並且該類可被一個工程中的所有類訪問，那麼該類的正確聲明為（）（選擇兩項）
A45.定義一個類名為”MyClass.java”的類，並且該類可被一個工程中的所有類訪問，那麼該類的正確聲明為（）（選擇兩項）B.class MyClass extends ObjectC.public class MyClassD.public class MyClass extends Object答案：CD分析： A 類的訪問權限只能是public或defaultB使用默認訪問權限的類，只能在本包中訪問
46.面向對象的特徵有哪些方面？請用生活中的例子來描述。
答: 面向對象的三大特徵：封裝、繼承、多態。
舉例：（比如設計一個遊戲）我現在創建了一個對象，名叫戰士。
戰士的屬性是—性別，年齡，職業，等級，戰鬥力，血量。
它的方法—戰鬥，逃跑，吃飯，睡覺，死。
後來，我又建了一個對象，叫人。
屬性:性別，年齡，職業，等級，血量
方法:逃跑，吃飯，睡覺，死。
我讓人，成為戰士的父類，戰士可以直接繼承人的屬性和方法。
戰士修改成—
屬性:戰鬥力。
方法:戰鬥。
看上去戰士的資料變少了，實際上沒有，我們仍然可以調用方法—戰士.死。
而且我們還可以重載戰士.死的方法，簡稱重載死法。
我還建了一個對象—法師，父類也是人。
屬性:法力值
方法:施法，泡妞。
你看，用了繼承，創建對象變得更方便了。
再後來，我又建立了一個對象，叫怪物。
屬性:等級，戰力，血量。
方法:戰鬥，死。
建了個對象，叫白兔怪，父類怪物，可繼承怪物所有的屬性和方法。
屬性:毛色。
方法:賣萌，吃胡蘿蔔。
47.說明內存洩漏和內存溢出的區別和聯繫，結合項目經驗描述Java程序中如何檢測？如何解決？
答：
內存溢出 out of memory，是指程序在申請內存時，沒有足夠的內存空間供其使用，出現out of memory；比如申請了一個integer,但給它存了long才能存下的數，那就是內存溢出。
內存洩露 memory leak，是指程序在申請內存後，無法釋放已申請的內存空間，一次內存洩露危害可以忽略，但內存洩露堆積後果很嚴重，無論多少內存,遲早會被佔光。
memory leak會最終會導致out of memory！
48.什麼是Java的序列化，如何實現Java的序列化？列舉在哪些程序中見過Java序列化？
答：Java中的序列化機制能夠將一個實例對象（只序列化對象的屬性值，而不會去序列化什麼所謂的方法。）的狀態信息寫入到一個字節流中使其可以通過socket進行傳輸、或者持久化到存儲數據庫或文件系統中；然後在需要的時候通過字節流中的信息來重構一個相同的對象。一般而言，要使得一個類可以序列化，只需簡單實現java.io.Serializable接口即可。
對象的序列化主要有兩種用途：
1） 把對象的字節序列永久地保存到硬盤上，通常存放在一個文件中；
2） 在網絡上傳送對象的字節序列。
在很多應用中，需要對某些對象進行序列化，讓它們離開內存空間，入住物理硬盤，以便長期保存。比如最常見的是Web服務器中的Session對象，當有 10萬用戶併發訪問，就有可能出現10萬個Session對象，內存可能吃不消，於是Web容器就會把一些seesion先序列化到硬盤中，等要用了，再把保存在硬盤中的對象還原到內存中。
當兩個進程在進行遠程通信時，彼此可以發送各種類型的數據。無論是何種類型的數據，都會以二進制序列的形式在網絡上傳送。發送方需要把這個Java對象轉換為字節序列，才能在網絡上傳送；接收方則需要把字節序列再恢復為Java對象。
49.不通過構造函數也能創建對象嗎？
答：Java創建對象的幾種方式（重要）：
1、 用new語句創建對象，這是最常見的創建對象的方法。
2、 運用反射手段,調用java.lang.Class或者
java.lang.reflect.Constructor類的newInstance()實例方法。
3、 調用對象的clone()方法。
4、運用反序列化手段，調用java.io.ObjectInputStream對象的 readObject()方法。
(1)和(2)都會明確的顯式的調用構造函數 ；(3)是在內存上對已有對象的影印，所以不會調用構造函數 ；(4)是從文件中還原類的對象，也不會調用構造函數。
50.匿名內部類可不可以繼承或實現接口。為什麼？
答：匿名內部類是沒有名字的內部類,不能繼承其它類,但一個內部類可以作為一個接口,由另一個內部類實現.
1、由於匿名內部類沒有名字，所以它沒有構造函數。因為沒有構造函數，所以它必須完全借用父類的構造函數來實例化，換言之：匿名內部類完全把創建對象的任務交給了父類去完成。
2、在匿名內部類裡創建新的方法沒有太大意義，但它可以通過覆蓋父類的方法達到神奇效果，如上例所示。這是多態性的體現。
3、因為匿名內部類沒有名字，所以無法進行向下的強制類型轉換，持有對一個匿名內部類對象引用的變量類型一定是它的直接或間接父類類型。
51.在Java中，為什麼基本類型不能做為HashMap的鍵值，而只能是引用類型，把引用類型做為HashMap的健值，需要注意哪些地方。
(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類型。
52.簡述Java中如何實現多態
實現多態有三個前提條件：
1、 繼承的存在；（繼承是多態的基礎，沒有繼承就沒有多態）。
2、子類重寫父類的方法。（多態下會調用子類重寫後的方法）。
3、父類引用變量指向子類對象。（涉及子類到父類的類型轉換）。
最後使用父類的引用變量調用子類重寫的方法即可實現多態。
53.以下對繼承的描述錨誤的是 ()
AJava中的繼承允許一個子類繼承多個父類B.父類更具有通用性，子類更具體C.Java中的繼承存在著傳遞性D.當實例化子類時會遞歸調用父類中的構造方法答案：A分析：Java是單繼承的，一個類只能繼承一個父類。
54.Java 中 Math.random（）/Math.random（）值為？
54.Java 中 Math.random（）/Math.random（）值為？
如果除數與被除數均為0.0的話，則運行結果為NaN（Not a Number的簡寫），計算錯誤。
55.Java中，如果Manager是Employee的子類，那麼Pair是Pair的子類嗎？
不是，兩者沒有任何關聯；
Pair是單獨的類，只不過用不同類型的參數（泛型）進行了相應的實例化而已；所以，Pair< Manager>和Pair< Employee>不是子類的關係。
56.接口和抽象類的區別
56.接口和抽象類的區別
抽象類和接口均包含抽象方法，類必須實現所有的抽象方法，否則是抽象類
抽象類和接口都不能實例化，他們位於繼承樹的頂端，用來被其他類繼承和實現
兩者的區別主要體現在兩方面：語法方面和設計理念方面
語法方面的區別是比較低層次的，非本質的，主要表現在：
接口中只能定義全局靜態常量，不能定義變量。抽象類中可以定義常量和變量。
接口中所有的方法都是全局抽象方法。抽象類中可以有0個、1個或多個，甚至全部都是抽象方法。
抽象類中可以有構造方法，但不能用來實例化，而在子類實例化是執行，完成屬於抽象類的初始化操作。接口中不能定義構造方法。
一個類只能有一個直接父類（可以是抽象類），但可以充實實現多個接口。一個類使用extends來繼承抽象類，使用implements來實現接口。
一個類只能有一個直接父類（可以是抽象類），但可以充實實現多個接口。一個類使用extends來繼承抽象類，使用implements來實現接口。
抽象類體現了一種繼承關係，目的是複用代碼，抽象類中定義了各個子類的相同代碼，可以認為父類是一個實現了部分功能的“中間產品”，而子類是“最終產品”。父類和子類之間必須存在“is-a”的關係，即父類和子類在概念本質上應該是相同的。
接口並不要求實現類和接口在概念本質上一致的，僅僅是實現了接口定義的約定或者能力而已。接口定義了“做什麼”，而實現類負責完成“怎麼做”，體現了功能（規範）和實現分離的原則。接口和實現之間可以認為是一種“has-a的關係”
57.同步代碼塊和同步方法有什麼區別
相同點：
同步方法就是在方法前加關鍵字synchronized，然後被同步的方法一次只能有一個線程進入，其他線程等待。而同步代碼塊則是在方法內部使用大括號使得一個代碼塊得到同步。同步代碼塊會有一個同步的“目標”，使得同步塊更加靈活一些（同步代碼塊可以通過“目標”決定需要鎖定的對象）。
一般情況下，如果此“目標”為this，同步方法和代碼塊沒有太大的區別。
區別：
同步方法直接在方法上加synchronized實現加鎖，同步代碼塊則在方法內部加鎖。很明顯，同步方法鎖的範圍比較大，而同步代碼塊範圍要小點。一般同步的範圍越大，性能就越差。所以一般需要加鎖進行同步的時候，範圍越小越好，這樣性能更好。
58.靜態內部類和內部類有什麼區別
靜態內部類不需要有指向外部類的引用。但非靜態內部類需要持有對外部類的引用。
靜態內部類可以有靜態成員(方法，屬性)，而非靜態內部類則不能有靜態成員(方法，屬性)。
非靜態內部類能夠訪問外部類的靜態和非靜態成員。靜態內部類不能訪問外部類的非靜態成員，只能訪問外部類的靜態成員。
實例化方式不同：
1) 靜態內部類：不依賴於外部類的實例，直接實例化內部類對象
2) 非靜態內部類：通過外部類的對象實例生成內部類對象
59.反射的概念與作用
反射的概念：
反射，一種計算機處理方式。是程序可以訪問、檢測和修改它本身狀態或行為的一種能力。
Java反射可以於運行時加載,探知和使用編譯期間完全未知的類.
程序在運行狀態中, 可以動態加載一個只有名稱的類, 對於任意一個已經加載的類,都能夠知道這個類的所有屬性和方法; 對於任意一個對象,都能調用他的任意一個方法和屬性;
加載完類之後, 在堆內存中會產生一個Class類型的對象(一個類只有一個Class對象), 這個對象包含了完整的類的結構信息,而且這個Class對象就像一面鏡子,透過這個鏡子看到類的結構,所以被稱之為:反射.
java反射使得我們可以在程序運行時動態加載一個類，動態獲取類的基本信息和定義的方法,構造函數,域等。
除了檢閱類信息外，還可以動態創建類的實例，執行類實例的方法，獲取類實例的域值。反射使java這種靜態語言有了動態的特性。
反射的作用：
通過反射可以使程序代碼訪問裝載到JVM 中的類的內部信息
1) 獲取已裝載類的屬性信息
2) 獲取已裝載類的方法
3) 獲取已裝載類的構造方法信息
反射的優點：
增加程序的靈活性。
如struts中。請求的派發控制。
當請求來到時。struts通過查詢配置文件。找到該請求對應的action。已經方法。
然後通過反射實例化action。並調用響應method。
如果不適用反射，那麼你就只能寫死到代碼裡了。
所以說，一個靈活，一個不靈活。
很少情況下是非用反射不可的。大多數情況下反射是為了提高程序的靈活性。因此一般框架中使用較多。因為框架要適用更多的情況。對靈活性要求較高。
60.提供Java存取數據庫能力的包是（）
Ajava.sqlB.java.awtC.java.langD.java.swing答案：A分析：java.awt和javax.swing兩個包是圖形用戶界面編程所需要的包；java.lang包則提供了Java編程中用到的基礎類。
61.下列運算符合法的是（）（多選）
A&&B.<>C.ifD.=答案：AD分析：&&是邏輯運算符中的短路與；<>表示不等於，但是Java中不能這麼使用，應該是!=；if不是運算符；=是賦值運算符。
62.執行如下程序代碼，c的值打印出來是（）
1
2
3
4
5
6
7
8
9
10
11
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);
}
}
A0B.1C.-1D.死循環答案：C分析：do-while循環的特點是先執行後判斷，所以代碼先執行--c操作，得到c為-1，之後執行a=a-1的操作，得到a為-1，然後判斷a是否大於0，判斷條件不成立，退出循環，輸出c為-1。
63.下列哪一種敘述是正確的（）
Aabstract修飾符可修飾字段，方法和類B.抽象方法的body部分必須用一對大括號{}包住C.聲明抽象方法，大括號可有可無D.聲明抽象方法不可寫出大括號答案：D分析：abstract只能修飾方法和類，不能修飾字段；抽象方法不能有方法體，即沒有{}；同B。
64.下列語句正確的是（）
A形式參數可被視為local VariableB.形式參數可被視為local VariableC.形式參數可被所有的字段修飾符修飾D.形式參數為方法被調用時，真正被傳遞的參數答案：A分析：local Variable為局部變量，形參和局部變量一樣都只有在方法內才會發生作用，也只能在方法中使用，不會在方法外可見；對於形式參數只能用final修飾符，其它任何修飾符都會引起編譯器錯誤；真正被傳遞的參數是實參；形式參數可是基本數據類型也可以是引用類型（對象）。
65.下列哪種說法是正確的（）
A實例方法可直接調用超類的實例方法B.實例方法可直接調用超類的類方法C.實例方法可直接調用其他類的實例方法D.實例方法可直接調用本類的類方法答案：D分析：實例方法不可直接調用超類的私有實例方法；實例方法不可直接調用超類的私有的類方法；要看訪問權限。
66.Java程序的種類有（）(多選)
A類 (Class)
B.AppletC.ApplicationD.Servlet答案：BCD分析：是Java中的類，不是程序；內嵌於Web文件中，由瀏覽器來觀看的Applet；可獨立運行的 Application；服務器端的 Servlet。
67.下列說法正確的有（）(多選)
A環境變量可在編譯source code時指定B.在編譯程序時，所指定的環境變置不包括class pathC.javac —次可同時編譯數個Java 源文件D.javac.exe能指定編譯結果要置於哪個目錄（directory)答案：BCD分析：環境變量一般都是先配置好再編譯源文件。
68.下列標識符不合法的有（）(多選)
AnewB.$UsdollarsC.1234D.car.taxi答案：ACD分析：new是Java的關鍵字；C. 數字不能開頭；D. 不能有“.”。
69.下列說法錯誤的有（）(多選)
A數組是—種對象B.數組屬於一種原生類C.int number[]=(31,23,33,43,35,63)D.數組的大小可以任意改變答案：BCD分析：B. Java中的原生類（即基本數據類型）有8種，但不包括數組；C. 語法錯誤，應該“{···}”，而不是“(···)”；D. 數組的長度一旦確定就不能修改。
70.不能用來修飾interface的有（）(多選)
AprivateB.publicC.protectedD.static答案：ACD分析：能夠修飾interface的只有public、abstract以及默認的三種修飾符。
71.下列正確的有（）(多選)
Acall by value不會改變實際參數的數值B.call by reference能改變實際參數的參考地址C.call by reference 不能改變實際參數的參考地址D.call by reference 能改變實際參數的內容答案：ACD分析：Java中參數的傳遞有兩種，一種是按值傳遞（call by value：傳遞的是具體的值，如基礎數據類型），另一種是按引用傳遞（call by reference：傳遞的是對象的引用，即對象的存儲地址）。前者不能改變實參的數值，後者雖然不能改變實參的參考地址，但可以通過該地址訪問地址中的內容從而實現內容的改變。
72.下列說法錯誤的有（）(多選)
A在類方法中可用this來調用本類的類辦法B.在類方法中調用本類的類方法時可以直接調用C.在類方法中只能調用本類中的類方法D.在類方法中絕對不能調用實例方法答案：ACD分析：類方法是在類加載時被加載到方法區存儲的，此時還沒有創建對象，所以不能使用this或者super關鍵字；C. 在類方法中還可以調用其他類的類方法；D. 在類方法可以通過創建對象來調用實例方法。
73.下列說法錯誤的有（）(多選)
AJava面嚮對象語言容許單獨的過棧與函數存在B.Java面嚮對象語言容許單獨的方法存在C.Java語言中的方法屬於類中的成員（member）D.Java語言中的方法必定隸屬於某一類（對象），調用方法與過程或函數相同答案：ABC分析：B. Java不允許單獨的方法，過程或函數存在，需要隸屬於某一類中；C. 靜態方法屬於類的成員，非靜態方法屬於對象的成員。
74.下列說法錯誤的有（）(多選)
A能被java.exe成功運行的java class文件必須有main()方法B.J2SDK就是Java APIC.Appletviewer.exe可利用jar選項運行.jar文件D.能被Appletviewer成功運行的java class文件必須有main()方法答案：BCD分析：B. J2SDK是sun公司編程工具，API是指的應用程序編程接口；C. Appletviewer.exe就是用來解釋執行java applet應用程序的，一種執行HTML文件上的Java小程序類的Java瀏覽器；D. 能被Appletviewer成功運行的java class文件可以沒有main（）方法。
75.請問0.3332的數據類型是（）
AfloatB.doubleC.FloatD.Double答案：B分析：小數默認是雙精度浮點型即double類型的。
76.Java接口的修飾符可以為（）
AprivateB.protectedC.finalD.abstract答案：D分析：能夠修飾interface的只有public、abstract以及默認的三種修飾符。
77.不通過構造函數也能創建對象麼（）
A是B.否答案：A分析：Java創建對象的幾種方式：(1) 用new語句創建對象，這是最常見的創建對象的方法。(2) 運用反射手段,調用java.lang.Class或者
java.lang.reflect.Constructor類的newInstance()實例方法。(3) 調用對象的clone()方法。(4) 運用反序列化手段，調用java.io.ObjectInputStream對象的readObject()方法。(1)和(2)都會明確的顯式的調用構造函數；(3)是在內存上對已有對象的影印，所以不會調用構造函數；(4)是從文件中還原類的對象，也不會調用構造函數。
78.存在使i+1< i的數麼?
78.存在使i+1< i的數麼?
79.接口可否繼承接口？抽象類是否可實現接口？抽象類是否可繼承實體類？
接口可以繼承接口，抽象類可以實現接口，抽象類可以繼承實體類。
80.int與Integer有什麼區別？
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中還定義了表示整數的最大值和最小值的常量。
81.可序列化對象為什麼要定義serialversionUID值?
SerialVersionUid，簡言之，其目的是序列化對象版本控制，有關各版本反序列化時是否兼容。如果在新版本中這個值修改了，新版本就不兼容舊版本，反序列化時會拋出InvalidClassException異常。如果修改較小，比如僅僅是增加了一個屬性，我們希望向下兼容，老版本的數據都能保留，那就不用修改；如果我們刪除了一個屬性，或者更改了類的繼承關係，必然不兼容舊數據，這時就應該手動更新版本號，即SerialVersionUid。
82.寫一個Java正則，能過濾出html中的< a href=”url”>title< /a>形式中的鏈接地址和標題.
< a\b[^>]+\bhref="([^"]*)"[^>]*>([\s\S]*?)< /a>
< a\b[^>]+\bhref="([^"]*)"[^>]*>([\s\S]*?)< /a>
83.十進制數72轉換成八進制數是多少？
答: 110
84.Java程序中創建新的類對象，使用關鍵字new，回收無用的類對象使用關鍵字free正確麼？
答:Java程序中創建新的類對象，使用關鍵字new是正確的; 回收無用的類對象使用關鍵字free是錯誤的.
85.Class類的getDeclaredFields()方法與getFields()的區別？
答:getDeclaredFields(): 可以獲取所有本類自己聲明的方法, 不能獲取繼承的方法
getFields(): 只能獲取所有public聲明的方法, 包括繼承的方法
86.在switch和if-else語句之間進行選取，當控制選擇的條件不僅僅依賴於一個x時，應該使用switch結構；正確麼？
答:不正確。
通常情況下，進行比較判斷的處理，switch 和if-else可以互相轉換來寫；if-else作用的範圍比switch-case作用範圍要大，但是當switch-case和if-else都可以用的情況下，通常推薦使用switch-case。
比如：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
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
1
2
3
4
5
6
7
8
9
10
11
12
13
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");
}
87.描述&和&&的區別。
&和&&的聯繫(共同點)：
&和&&都可以用作邏輯與運算符，但是要看使用時的具體條件來決定。
操作數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類型時，&用於按位與運算符的操作。
88.使用final關鍵字修飾符一個變量時，是引用不能變，還是引用的對象不能變？
final修飾基本類型變量，其值不能改變。
但是final修飾引用類型變量，棧內存中的引用不能改變，但是所指向的堆內存中的對象的屬性值仍舊可以改變。
例如:
1
2
3
4
5
6
7
class Test {
public static void main(String[] args) {
final Dog dog = new Dog("歐歐");
dog.name = "美美";//正確
dog = new Dog("亞亞");//錯誤
}
}
89.請解釋以下常用正則含義：\d,\D,\s,.,*,?,|,[0-9]{6},\d+
\d: 匹配一個數字字符。等價於[0-9]
\D: 匹配一個非數字字符。等價於[^0-9]
\s: 匹配任何空白字符，包括空格、製表符、換頁符等等。等價於 [ \f\n\r\t\v]
. ：匹配除換行符 \n 之外的任何單字符。要匹配 . ，請使用 \. 。
*：匹配前面的子表達式零次或多次。要匹配 * 字符，請使用 \*。
+：匹配前面的子表達式一次或多次。要匹配 + 字符，請使用 \+。
|:將兩個匹配條件進行邏輯“或”（Or）運算
[0-9]{6}:匹配連續6個0-9之間的數字
\d+：匹配至少一個0-9之間的數字
90.已知表達式int m[] = {0,1,2,3,4,5,6}; 下面那個表達式的值與數組的長度相等（）
Am.length()B.m.lengthC.m.length()+1D.m.length+1答案：B分析：數組的長度是.length
91.下面那些聲明是合法的？（）
Along l = 4990B.int i = 4LC.float f = 1.1D.double d = 34.4答案：AD分析：B int屬於整數型應該是int=4 C應該是float f=1.1f
92.以下選項中選擇正確的java表達式（）
Aint k=new String(“aa”)B.String str = String(“bb”)C.char c=74;D.long j=8888;答案：CD分析：A需要強制類型轉換 B String str =new String(“bb”)
93.下列代碼的輸出結果是
1
2
3
System.out.println(""+("12"=="12"&&"12".equals("12")));
(“12”==”12”&&”12”.equals(“12”))
“12”==”12”&&”12”.equals(“12”)
true
false
94.以下哪些運算符是含有短路運算機制的？請選擇：（）
A&B.&&C.|D.||答案：BD分析：A C是邏輯與計算
95.下面哪個函數是public void example(){....}的重載函數？（）
Aprivate void example（int m）{...}B.public int example（）{...}C.public void example2（）{...}D.public int example（int m.float f）{...}答案：AD分析：BC定義的是新函數
96.給定某java程序片段，該程序運行後，j的輸出結果為（）
1
2
3
4
int i=1；
Int j=i++；
If（（j>++j）&&(i++==j)）{j+=i:}
System.out.println(j);
A1B.2C.3D.4答案：B分析： i++先引用後。++i 先增加後引用
97.在java中，無論測試條件是什麼，下列（）循環將至少執行一次。
AforB.do...whileC.whileD.while...do答案：B分析： ACD都不一定進行循環
98.打印結果：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
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
99.指出下列程序的運行結果
1
2
3
4
5
6
7
8
9
10
11
12
13
14
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
100.解釋繼承、重載、覆蓋。
繼承（英語：inheritance）是面向對象軟件技術當中的一個概念。如果一個類別A“繼承自”另一個類別B，就把這個A稱為“B的子類別”，而把B稱為“A的父類別”也可以稱“B是A的超類”。繼承可以使得子類別具有父類別的各種屬性和方法，而不需要再次編寫相同的代碼。在令子類別繼承父類別的同時，可以重新定義某些屬性，並重寫某些方法，即覆蓋父類別的原有屬性和方法，使其獲得與父類別不同的功能。另外，為子類別追加新的屬性和方法也是常見的做法。 一般靜態的面向對象編程語言，繼承屬於靜態的，意即在子類別的行為在編譯期就已經決定，無法在執行期擴充。
那麼如何使用繼承呢？用extends關鍵字來繼承父類。
如上面A類與B類，當寫繼承語句時， class A類 extends B類{ } 其中A類是子類，B類是父類。
英文位置不同作用不同重載overload同一個類中在一個類裡面為一種行為提供多種實現方式並提高可讀性現方式並提高可讀性重寫override子類和父類間父類方法無法滿足子類的要求，子類通過方法重寫滿足要求
小編這裡有一套Python丶java丶大數據丶web前端丶linux自學從入門到精通的全套視頻學習資料，以及1000道名企面試題現在免費分享給大家
獲取方式：
1.評論區評論
2.關注並私信小編“學習” 領取資源，小編會第一時間回覆
