2021最新版Java后端面試題有哪些

這篇文章主要講解了“2021最新版Java后端面試題有哪些”，文中的講解內容簡單清晰，易于學習與理解，下面請大家跟著小編的思路慢慢深入，一起來研究和學習“2021最新版Java后端面試題有哪些”吧！

1、面向對象

對比面向過程，是兩種不同的處理問題的角度

面向過程更注重事情的每一個步驟及順序，面向對象更注重事情有哪些參與者（對象）、及各自需要做什么

比如：洗衣機洗衣服

面向過程會將任務拆解成一系列的步驟（函數），1、打開洗衣機----->2、放衣服----->3、放洗衣粉----->4、清洗----->5、烘干

面向對象會拆出人和洗衣機兩個對象：

人：打開洗衣機 放衣服 放洗衣粉

洗衣機：清洗 烘干

從以上例子能看出，面向過程比較直接高效，而面向對象更易于復用、擴展和維護

面向對象

封裝：封裝的意義，在于明確標識出允許外部使用的所有成員函數和數據項

內部細節對外部調用透明，外部調用無需修改或者關心內部實現

（1）、javabean的屬性私有，提供getset對外訪問，因為屬性的賦值或者獲取邏輯只能由javabean本身決 定。而不能由外部胡亂修改

private String name;
public void setName(String name){
	this.name = "tuling_"+name;
}
該name有自己的命名規則，明顯不能由外部直接賦值

（2）、orm框架

操作數據庫，我們不需要關心鏈接是如何建立的、sql是如何執行的，只需要引入mybatis，調方法即可

繼承：繼承基類的方法，并做出自己的改變和/或擴展

子類共性的方法或者屬性直接使用父類的，而不需要自己再定義，只需擴展自己個性化的

多態：基于對象所屬類的不同，外部對同一個方法的調用，實際執行的邏輯不同。

繼承，方法重寫，父類引用指向子類對象

父類類型 變量名 = new 子類對象 ;
變量名.方法名();

無法調用子類特有的功能

2、 JDK、JRE、JVM

JDK：

Java Develpment Kit java 開發工具

JRE：

Java Runtime Environment java運行時環境

JVM：

java Virtual Machine java 虛擬機

3、 ==和equals比較

==對比的是棧中的值，基本數據類型是變量值，引用類型是堆中內存對象的地址

equals：object中默認也是采用==比較，通常會重寫

Object

public Boolean equals(Object obj) {
	return (this == obj);
}

String

public Boolean equals(Object anObject) {
	if (this == anObject) {
		return true;
	}
	if (anObject instanceof String) {
		String anotherString = (String)anObject;
		int n = value.length;
		if (n == anotherString.value.length) {
			char v1[] = value;
			char v2[] = anotherString.value;
			int i = 0;
			while (n-- != 0) {
				if (v1[i] != v2[i])
				return false;
				i++;
			}
			return true;
		}
	}
	return false;
}

上述代碼可以看出，String類中被復寫的equals()方法其實是比較兩個字符串的內容。

public class StringDemo {
	public static void main(String args[]) {
		String str1 = "Hello";
		String str2 = new String("Hello");
		String str3 = str2;
		// 引用傳遞
		System.out.println(str1 == str2);
		// false
		System.out.println(str1 == str3);
		// false
		System.out.println(str2 == str3);
		// true
		System.out.println(str1.equals(str2));
		// true
		System.out.println(str1.equals(str3));
		// true
		System.out.println(str2.equals(str3));
		// true
	}
}

4、hashCode與equals

hashCode介紹：

hashCode() 的作用是獲取哈希碼，也稱為散列碼；它實際上是返回一個int整數。這個哈希碼的作用是確定該對象在哈希表中的索引位置。hashCode() 定義在JDK的Object.java中，Java中的任何類都包含有hashCode() 函數。

散列表存儲的是鍵值對(key-value)，它的特點是：能根據“鍵”快速的檢索出對應的“值”。這其中就利用 到了散列碼！（可以快速找到所需要的對象）

為什么要有hashCode：

以HashSet如何檢查重復為例子來說明為什么要有hashCode：

對象加入HashSet時，HashSet會先計算對象的hashcode值來判斷對象加入的位置，看該位置是否有值，如果沒有、HashSet會假設對象沒有重復出現。但是如果發現有值，這時會調用equals（）方法來檢查兩個對象是否真的相同。如果兩者相同，HashSet就不會讓其加入操作成功。如果不同的話，就會重新散列到其他位置。這樣就大大減少了equals的次數，相應就大大提高了執行速度。

（1）如果兩個對象相等，則hashcode一定也是相同的

（2）兩個對象相等,對兩個對象分別調用equals方法都返回true

（3）兩個對象有相同的hashcode值，它們也不一定是相等的

（4）因此，equals方法被覆蓋過，則hashCode方法也必須被覆蓋

（5）hashCode()的默認行為是對堆上的對象產生獨特值。如果沒有重寫hashCode()，則該class的兩個 對象無論如何都不會相等（即使這兩個對象指向相同的數據）

5、final

最終的

修飾類：表示類不可被繼承

修飾方法：表示方法不可被子類覆蓋，但是可以重載

修飾變量：表示變量一旦被賦值就不可以更改它的值。

（1）修飾成員變量

如果final修飾的是類變量，只能在靜態初始化塊中指定初始值或者聲明該類變量時指定初始值。 如果final修飾的是成員變量，可以在非靜態初始化塊、聲明該變量或者構造器中執行初始值。

（2）修飾局部變量

系統不會為局部變量進行初始化，局部變量必須由程序員顯示初始化。因此使用final修飾局部變量時，即可以在定義時指定默認值（后面的代碼不能對變量再賦值），也可以不指定默認值，而在后面的代碼中對final變量賦初值（僅一次）

public class FinalVar {
	final static int a = 0;
	//再聲明的時候就需要賦值 或者靜態代碼塊賦值
	/**
static{
a = 0;
}
*/
	final int b = 0;
	//再聲明的時候就需要賦值 或者代碼塊中賦值 或者構造器賦值
	/*{
b = 0;
}*/
	public static void main(String[] args) {
		final int localA;
		//局部變量只聲明沒有初始化，不會報錯,與final無關。
		localA = 0;
		//在使用之前一定要賦值
		//localA = 1; 但是不允許第二次賦值
	}
}

（3）修飾基本類型數據和引用類型數據

如果是基本數據類型的變量，則其數值一旦在初始化之后便不能更改； 如果是引用類型的變量，則在對其初始化之后便不能再讓其指向另一個對象。但是引用的值是可變的。

public class FinalReferenceTest{
	public static void main(){
		final int[] iArr={1,2,3,4};
		iArr[2]=-3;
		//合法
		iArr=null;
		//非法，對iArr不能重新賦值
		final Person p = new Person(25);
		p.setAge(24);
		//合法
		p=null;
		//非法
	}
}

為什么局部內部類和匿名內部類只能訪問局部final變量？

編譯之后會生成兩個class文件，Test.class Test1.class

public class Test {
	public static void main(String[] args) {
	}
	//局部final變量a,b
	public void test(final int b) {
		//jdk8在這里做了優化, 不用寫,語法糖，但實際上也是有
		的，也不能修改
		final int a = 10;
		//匿名內部類
		new Thread(){
			public void run() {
				System.out.println(a);
				System.out.println(b);
			}
			;
		}
		.start();
	}
}
class OutClass {
	private int age = 12;
	public void outPrint(final int x) {
		class InClass {
			public void InPrint() {
				System.out.println(x);
				System.out.println(age);
			}
		}
		new InClass().InPrint();
	}
}

首先需要知道的一點是: 內部類和外部類是處于同一個級別的，內部類不會因為定義在方法中就會隨著 方法的執行完畢就被銷毀。

這里就會產生問題：當外部類的方法結束時，局部變量就會被銷毀了，但是內部類對象可能還存在(只有沒有人再引用它時，才會死亡)。這里就出現了一個矛盾：內部類對象訪問了一個不存在的變量。為了解決這個問題，就將局部變量復制了一份作為內部類的成員變量，這樣當局部變量死亡后，內部類仍可以訪問它，實際訪問的是局部變量的"copy"。這樣就好像延長了局部變量的生命周期

將局部變量復制為內部類的成員變量時，必須保證這兩個變量是一樣的，也就是如果我們在內部類中修改了成員變量，方法中的局部變量也得跟著改變，怎么解決問題呢？

就將局部變量設置為final，對它初始化后，我就不讓你再去修改這個變量，就保證了內部類的成員變量 和方法的局部變量的一致性。這實際上也是一種妥協。使得局部變量與內部類內建立的拷貝保持一致。

6、String、StringBuffer、StringBuilder

String是final修飾的，不可變，每次操作都會產生新的String對象

StringBuffer和StringBuilder都是在原對象上操作

StringBuffer是線程安全的，StringBuilder線程不安全的

StringBuffer方法都是synchronized修飾的

性能：StringBuilder > StringBuffer > String

場景：經常需要改變字符串內容時使用后面兩個

優先使用StringBuilder，多線程使用共享變量時使用StringBuffer

7、重載和重寫的區別

重載：

發生在同一個類中，方法名必須相同，參數類型不同、個數不同、順序不同，方法返回值和訪問 修飾符可以不同，發生在編譯時。

重寫：

發生在父子類中，方法名、參數列表必須相同，返回值范圍小于等于父類，拋出的異常范圍小于 等于父類，訪問修飾符范圍大于等于父類；如果父類方法訪問修飾符為private則子類就不能重寫該方 法。

public int add(int a,String b)
public String add(int a,String b)
//編譯報錯

8、接口和抽象類的區別

（1）抽象類可以存在普通成員函數，而接口中只能存在public abstract 方法。

（2）抽象類中的成員變量可以是各種類型的，而接口中的成員變量只能是public static final類型的。

（3）抽象類只能繼承一個，接口可以實現多個。

接口的設計目的，是對類的行為進行約束（更準確的說是一種“有”約束，因為接口不能規定類不可以有什么行為），也就是提供一種機制，可以強制要求不同的類具有相同的行為。它只約束了行為的有無，但不對如何實現行為進行限制。

而抽象類的設計目的，是代碼復用。當不同的類具有某些相同的行為(記為行為集合A)，且其中一部分行為的實現方式一致時（A的非真子集，記為B），可以讓這些類都派生于一個抽象類。在這個抽象類中實現了B，避免讓所有的子類來實現B，這就達到了代碼復用的目的。而A減B的部分，留給各個子類自己實現。正是因為A-B在這里沒有實現，所以抽象類不允許實例化出來（否則當調用到A-B時，無法執行）。

抽象類是對類本質的抽象，表達的是 is a 的關系，比如： BMW is a Car。抽象類包含并實現子類的通用特性，將子類存在差異化的特性進行抽象，交由子類去實現。

而接口是對行為的抽象，表達的是 like a 的關系。比如： Bird like a Aircraft（像飛行器一樣可以飛），但其本質上 is a Bird。接口的核心是定義行為，即實現類可以做什么，至于實現類主體是誰、是如何實現的，接口并不關心。

使用場景：當你關注一個事物的本質的時候，用抽象類；當你關注一個操作的時候，用接口。

抽象類的功能要遠超過接口，但是，定義抽象類的代價高。因為高級語言來說（從實際設計上來說也是）每個類只能繼承一個類。在這個類中，你必須繼承或編寫出其所有子類的所有共性。雖然接口在功能上會弱化許多，但是它只是針對一個動作的描述。而且你可以在一個類中同時實現多個接口。在設計階段會降低難度

9、List和Set的區別

List

有序，按對象進入的順序保存對象，可重復，允許多個Null元素對象，可以使用Iterator取出所有元素，在逐一遍歷，還可以使用get(int index)獲取指定下標的元素

Set

無序，不可重復，最多允許有一個Null元素對象，取元素時只能用Iterator接口取得所有元素，在逐一遍歷各個元素

10、ArrayList和LinkedList區別

ArrayList：

基于動態數組，連續內存存儲，適合下標訪問（隨機訪問），擴容機制：因為數組長度固定，超出長度存數據時需要新建數組，然后將老數組的數據拷貝到新數組，如果不是尾部插入數據還會涉及到元素的移動（往后復制一份，插入新元素），使用尾插法并指定初始容量可以極大提升性能、甚至超過linkedList（需要創建大量的node對象）

LinkedList：

基于鏈表，可以存儲在分散的內存中，適合做數據插入及刪除操作，不適合查詢：需要逐一遍歷

遍歷LinkedList必須使用iterator不能使用for循環，因為每次for循環體內通過get(i)取得某一元素時都需要對list重新進行遍歷，性能消耗極大。

另外不要試圖使用indexOf等返回元素索引，并利用其進行遍歷，使用indexlOf對list進行了遍歷，當結 果為空時會遍歷整個列表。

11、HashMap和HashTable有什么區別？其底層實現是什 么？

區別 ：

（1）HashMap方法沒有synchronized修飾，線程非安全，HashTable線程安全；

（2）HashMap允許key和value為null，而HashTable不允許

底層實現：數組+鏈表實現

jdk8開始鏈表高度到8、數組長度超過64，鏈表轉變為紅黑樹，元素以內部類Node節點存在

（1）計算key的hash值，二次hash然后對數組長度取模，對應到數組下標。

（2）如果沒有產生hash沖突(下標位置沒有元素)，則直接創建Node存入數組

（3）如果產生hash沖突，先進行equal比較，相同則取代該元素，不同，則判斷鏈表高度插入鏈表，鏈表高度達到8，并且數組長度到64則轉變為紅黑樹，長度低于6則將紅黑樹轉回鏈表

（4）key為null，存在下標0的位置數組擴容

12、ConcurrentHashMap原理，jdk7和jdk8版本的區別

jdk7：

數據結構：ReentrantLock+Segment+HashEntry，一個Segment中包含一個HashEntry數組，每個HashEntry又是一個鏈表結構

元素查詢：二次hash，第一次Hash定位到Segment，第二次Hash定位到元素所在的鏈表的頭部

鎖：Segment分段鎖 Segment繼承了ReentrantLock，鎖定操作的Segment，其他的Segment不受影響，并發度為segment個數，可以通過構造函數指定，數組擴容不會影響其他的segment

get方法無需加鎖，volatile保證

jdk8：

數據結構：synchronized+CAS+Node+紅黑樹，Node的val和next都用volatile修飾，保證可見性

查找，替換，賦值操作都使用CAS

鎖：鎖鏈表的head節點，不影響其他元素的讀寫，鎖粒度更細，效率更高，擴容時，阻塞所有的讀寫操作、并發擴容

讀操作無鎖：

Node的val和next使用volatile修飾，讀寫線程對該變量互相可見數組用volatile修飾，保證擴容時被讀線程感知

13、什么是字節碼？采用字節碼的好處是什么？

Java中的編譯器和解釋器：

Java中引入了虛擬機的概念，即在機器和編譯程序之間加入了一層抽象的虛擬的機器。這臺虛擬的機器 在任何平臺上都提供給編譯程序一個的共同的接口。

編譯程序只需要面向虛擬機，生成虛擬機能夠理解的代碼，然后由解釋器來將虛擬機代碼轉換為特定系統的機器碼執行。在Java中，這種供虛擬機理解的代碼叫做 字節碼（即擴展名為 .class的文件），它不面向任何特定的處理器，只面向虛擬機。

每一種平臺的解釋器是不同的，但是實現的虛擬機是相同的。Java源程序經過編譯器編譯后變成字節碼，字節碼由虛擬機解釋執行，虛擬機將每一條要執行的字節碼送給解釋器，解釋器將其翻譯成特定機器上的機器碼，然后在特定的機器上運行。這也就是解釋了Java的編譯與解釋并存的特點。

Java源代碼---->編譯器---->jvm可執行的Java字節碼(即虛擬指令)---->jvm---->jvm中解釋器----->機器可執行的二進制機器碼---->程序運行。

采用字節碼的好處：

Java語言通過字節碼的方式，在一定程度上解決了傳統解釋型語言執行效率低的問題，同時又保留了解釋型語言可移植的特點。所以Java程序運行時比較高效，而且，由于字節碼并不專對一種特定的機器，因此，Java程序無須重新編譯便可在多種不同的計算機上運行。

14、Java中的異常體系

Java中的所有異常都來自頂級父類Throwable。

Throwable下有兩個子類Exception和Error。

Error是程序無法處理的錯誤，一旦出現這個錯誤，則程序將被迫停止運行。

Exception不會導致程序停止，又分為兩個部分RunTimeException運行時異常和CheckedException檢查異常。

RunTimeException常常發生在程序運行過程中，會導致程序當前線程執行失敗。CheckedException常 常發生在程序編譯過程中，會導致程序編譯不通過。

15、Java類加載器

JDK自帶有三個類加載器：bootstrap ClassLoader、ExtClassLoader、AppClassLoader。

BootStrapClassLoader是ExtClassLoader的父類加載器，默認負責加載%JAVA_HOME%lib下的jar包和class文件。

ExtClassLoader是AppClassLoader的父類加載器，負責加載%JAVA_HOME%/lib/ext文件夾下的jar包和 class類。

AppClassLoader是自定義類加載器的父類，負責加載classpath下的類文件。系統類加載器，線程上下文加載器繼承ClassLoader實現自定義類加載器

16、雙親委托模型

雙親委派模型的好處：

主要是為了安全性，避免用戶自己編寫的類動態替換 Java的一些核心類，比如 String。同時也避免了類的重復加載，因為 JVM中區分不同類，不僅僅是根據類名，相同的 class文件被不同的 ClassLoader加載就是不同的兩個類

17、GC如何判斷對象可以被回收

引用計數法：每個對象有一個引用計數屬性，新增一個引用時計數加1，引用釋放時計數減1，計數為0時可以回收，

可達性分析法：從 GC Roots 開始向下搜索，搜索所走過的路徑稱為引用鏈。當一個對象到 GCRoots 沒有任何引用鏈相連時，則證明此對象是不可用的，那么虛擬機就判斷是可回收對象。

引用計數法，可能會出現A 引用了 B，B 又引用了 A，這時候就算他們都不再使用了，但因為相互引用 計數器=1 永遠無法被回收。

GC Roots的對象有：

虛擬機棧(棧幀中的本地變量表）中引用的對象 方法區中類靜態屬性引用的對象 方法區中常量引用的對象 本地方法棧中JNI(即一般說的Native方法)引用的對象

可達性算法中的不可達對象并不是立即死亡的，對象擁有一次自我拯救的機會。對象被系統宣告死亡至少要經歷兩次標記過程：第一次是經過可達性分析發現沒有與GC Roots相連接的引用鏈，第二次是在由虛擬機自動建立的Finalizer隊列中判斷是否需要執行finalize()方法。

當對象變成(GC Roots)不可達時，GC會判斷該對象是否覆蓋了finalize方法，若未覆蓋，則直接將其回收。否則，若對象未執行過finalize方法，將其放入F-Queue隊列，由一低優先級線程執行該隊列中對象的finalize方法。執行finalize方法完畢后，GC會再次判斷該對象是否可達，若不可達，則進行回收，否則，對象“復活”每個對象只能觸發一次finalize()方法

由于finalize()方法運行代價高昂，不確定性大，無法保證各個對象的調用順序，不推薦大家使用，建議遺忘它。

感謝各位的閱讀，以上就是“2021最新版Java后端面試題有哪些”的內容了，經過本文的學習后，相信大家對2021最新版Java后端面試題有哪些這一問題有了更深刻的體會，具體使用情況還需要大家實踐驗證。這里是億速云，小編將為大家推送更多相關知識點的文章，歡迎關注！