面試寶典總結：

java 基礎

Java 中的八種數據類型

四類八種字節數數據范圍

整型	byte	1	-128··127
整型	short	2	-32768··32767
整型	int	4
整型	long	8	-2^63 ·· 2^63-1
浮點型	float	4
浮點型	double	8
字符型	char	2
布爾型	boolean	1	true，false

一個byte類型在計算機中占一個字節，那么就是8個bit，就是8位，那么最 大就是11111111，
就是說能表示255個不同的值，那么以0作為中心點，范圍就是-128到127
計算機中負數的存儲方式是補碼。
方法為：對負數的絕對值的二進制值取反，再加一，即為負數的二進制 碼。
如：-1的絕對值1的二進制碼為00000001，取反得到11111110，再加一為11111111。
而-128的絕對值128的二進制碼為10000000，取反得到01111111，再加一為10000000，
正好是Byte的最大表示范圍
計算機是如何來區分有無符號數的？
有符號數和無符號數在計算機里表示都是一樣的，二進制的補碼形式。
是有符號還是無符號，是編譯器來辨認的。
例如：
unsigned char uch， char ch；
如何查看一個二進制是否是正數還是負數？
看一個二進制是否是正數還是負數，需要先說明其是存儲在計算機中，然后要搞清楚其在計算機中是以有符號進行存儲還是無符號進行存儲。

如果是無符號存儲，則其為一個正數。

若是有符號存儲，則為補碼存儲。
(補碼存儲)需要看其最高位，最高位為0，為正數; 反之，為負數。

面向對象的四大特征：

繼承：繼承是從已有類得到繼承信息，創建新類的過程。提供繼承信息的類叫做父類，得到繼承信息的類叫做子類。

封裝：隱藏一切可隱藏的東西，只向外界提供最簡單的編程接口。

多態：多態性指允許不同子類型的對象對同一消息做出不同的響應。（同樣的對象引用調用同樣的方法但是做了不同的事）多態必須滿足的兩個條件：1. 方法重寫，2. 父類引用指向子類

抽象：抽象就是將一類對象的共同特征總結出來構造類的過程，包括數據抽象和行為抽象，抽象只關注對象有哪些屬性和行為，不關心具體實現。

訪問權限修飾符的區別

修飾符當前類同包子類其他包

public	√	√	√	√
protected	√	√	√	×
default	√	√	×	×
private	√	×	×	×

對象的克隆

克隆出來的對象是一個新的對象。
深拷貝和淺拷貝的區別：
當對象的中的對象是引用數據類型時，淺拷貝指向的時對象的引用，深拷貝才是新的創建。(Clone方法是淺拷貝)

如何實現深拷貝？

如果想深拷貝一個對象（對象中含有引用對象），這個對象非必須要實現Cloneable 接口，實現Clone方法，并且在clone方法內部，把該對象的引用的其他對象也要clone一份，這也意味者這個其他對象內部也要實現Cloneable接口，重寫clone方法。

深克隆的方法驗證

static class Body implements Cloneable {public Head head;public Body() {}public Body(Head head) {this.head = head;}@Overrideprotected Object clone() throws CloneNotSupportedException {Body newBody = (Body) super.clone();newBody.head = (Head) head.clone();return newBody;} }static class Head implements Cloneable {public Face face;public Head() {}@Overrideprotected Object clone() throws CloneNotSupportedException {return super.clone();} }public static void main(String[] args) throws CloneNotSupportedException {Body body = new Body(new Head(new Face()));Body body1 = (Body) body.clone();System.out.println("body == body1 : " + (body == body1));System.out.println("body.head == body1.head : " + (body.head == body1.head)); } /*** 程序執行結果：* body == body1 : false* body.head == body1.head : false*/

& 和 && 的區別：

& ：

位運算符 （可用于基本類型的數據運算（僅限byte，short，int，char，boolean））

邏輯與
&&：短路與
雖然& 和 && 運算符都要求左右兩端的布爾值都是 true，整個表達式的結果才為true，但是短路與&& 運算符只有當左邊的表達式為true時才會繼續進行有右邊等式的運算，右邊為false時，會直接短路掉,右邊的表達式不會執行。

java 中如何跳出當前的多重嵌套循環？

break關鍵字，在最外層循環加一個標記A，通過breakA；可以跳出多重循環

兩對象的HashCode值比較。

如果兩個對象equals方法返回true，那么它們的 hashCode 值一定相同。
兩個對象的 hashCode 值相同，它們的equals方法不一定返回 true。（hash沖突）
A==B判斷的兩個對象的地址值是否相同，A.equals(B) 比較的是兩個對象的值是否相同。
instanceOf 判斷的是兩個對象是否是同一個類型。

String 是否可以被繼承？（final 修飾的類）

由于String 是被final修飾的類，所以不能被繼承。

當一個對象被當作參數傳遞到一個方法后，方法可以改變這個對象的屬性，并可返回變化后的結果，那么這里到底是值傳遞還是引用傳遞？

//基礎類型作為值傳遞 public class test {public static void main(String[] args) {int i = 1;System.out.println("before change, i = "+i);change(i);System.out.println("after change, i = "+i);}public static void change(int i){i = 5;} } /*** 輸出的結果是 before change i = 1;* 輸出的結果是 after change i = 1;* 當基本數據類型作為參數傳遞時，傳遞的是實參值的副本，即傳的是值，無論在函數中怎么操作這個副本， * 實參的值是不會被改變的。*///對象（引用類型）作為值傳遞 public class test {public static void main(String[] args) {StringBuffer sb = new StringBuffer("Hello ");System.out.println("before change, sb is "+sb.toString());change(sb);System.out.println("after change, sb is "+sb.toString());}public static void change(StringBuffer stringBuffer){stringBuffer.append("world !");} } /*** before change, sb is Hello* after change, sb is Hello world !*//*** 從輸出結果中我們可以發現，sb所指向的對象的值被改變了，那么是否我們可以推論出，在Java中，當 * 對象作為參數傳遞時，傳遞的是該對象的引用呢？我們再來看下面這個例子*/public class test {public static void main(String[] args) {StringBuffer sb = new StringBuffer("Hello ");System.out.println("before change, sb is "+sb.toString());change(sb);System.out.println("after change, sb is "+sb.toString());}public static void change(StringBuffer stringBuffer){stringBuffer = new StringBuffer("Hi ");stringBuffer.append("world !");} }/*** 如果上面的推論是正確的，即Java中對象作為參數傳遞，實際傳遞的是該對象的引用，那么在調用change * 函數之后，原對象的值應該是會改變的，變為“Hi world ！”，但是，當我們運行程序后，結果卻是如下所示：* before change, sb is Hello* after change, sb is Hello** 原對象的值并沒有被改變，這與上面的推論相矛盾！*//*** 總結就是基本數據類型傳遞的是形參，形參不影響實參；引用數據類型傳遞的是地址，形參在方法內被改變，實 * 參也會改變，若在方法內實例化了同名對象，即產生了新的地址，對這個同名對象的改變，由于地址不一樣， * 所以不影響原來的對象*/

總結：

當基本數據類型作為參數傳遞時，傳遞的是實參值的副本，即值的傳遞；無論在函數中怎么操作這個副本，實參的值是不會被改變的。

引用數據類型傳遞的是地址，形參在方法內被改變，實參也會改變，若在方法內實例化了同名對象，即產生了新的地址，對這個同名對象的改變，由于地址不一樣，所以不影響原來的對象

---

方法重載和方法重寫的區別

方法的重載和方法的重寫都是實現多態的方式。方法的重載是編譯時的多態性，而方法的重寫是運行時的多態性。

**方法重載的規則**- 方法名一致- 請求參數不同（個數不同，參數類型不同）- 和方法的返回值無關。- 可以拋出不同的異常，可以有不同的修飾符**方法的重寫**- 方法名，請求參數，返回值相同- 構造方法不能被重寫，static 和 final 修飾的方法不能被重寫- 重寫的方法不能拋出被重寫方法更廣泛的異常。

抽象類 Abstract 和 interface 的區別？

相同： 都不能被實例化。
不同：

抽象類中可以定義構造器，接口中不能定義構造器。

接口中的成員全是public 的。抽象類中的成員可以是任何。

抽象類中可以有成員變量，接口中沒有。

抽象類中可以有抽象方法和具體方法。接口中只有抽象方法。

有抽象方法的類必須被聲明成抽象類，但是抽象類中可以沒有抽象方法 ，接口中的成員變量就是常量（接口中的成員變量默認是public staic final修飾的）。抽象類中可以有靜態方法。

抽象類只能夠單繼承。接口可以多繼承。

在 Jdk8 之后，接口中可以有默認方法和靜態方法。不僅僅止于抽象方法了。

== 和 equal 的區別

一個是方法一個是運算符， == 如果比較的是基本類型的變量，則比較的是數值是否相等。如果比較的是引用類型，那么比較的是引用類型的地址值是否相等。 equal是用來比較兩個對象的內容是否相等。equal是不能用來比較基本類型的（基本數據類型沒有equals() 方法，可以做裝箱處理然后再使用equals()方法）。如果對象沒有對equal 方法進行重寫，那么equal方法比較的是對象的地址值；

String x = "string"; String y = "string"; String z = new String("string"); System.out.println(x==y); // true System.out.println(x==z); // false System.out.println(x.equals(y)); // true System.out.println(x.equals(z)); // true // new String() 方法是重寫開辟了空間，所以 == 的結果為 false

equal 默認情況下是引用的比較（也就是 == 比較），不過很多的類都重寫了 equal 方法，比如 String，Integer 等內部將equal 方法變成了 值 得比較。

break 和 continue 的區別

都是用來控制循環語句的。break 是用來結束一個循環的。continue 是用來跳過此次循環，執行下次循環。

throw 和 throws 的區別

throw 是用在方法體中的，用來拋出異常。執行throw 一定是拋出了某種異常。

throws 是用在方法聲明后面的，表示可能會跑出某種異常。表示了某種異常的可能性，不一定會拋出異常。

final ，finally，finalize 的區別

final 修飾類，方法，屬性，表示為最終態不可變。finally 異常處理語句結構的一部分，表示最終一定會被執行。finalize ： Object 的一個方法，在垃圾回收器執行的時候會調用被回收對象的這個方法。更像是一個對象生命周期的臨終方法，當此方法被調用代表著該對象的死亡。

final 修飾的類叫最終類，該類不能被繼承 final 修飾的方法不能被重寫 final 修飾的變量叫常量，常量必須初始化，初始化后不能再被修改

Math.round()方法

數據軸向右取整。 -11.5==》-11 11.5 ==》 12

switch 中可使用的類型

java 5 以前只能使用 byte，short，int ，char 。 java5 開始 引入了 enum 。 java7 后，引入了 String ，但是 Long 類型一直都是不可以的。

String，StringBuffer ，Stringbuild 的區別

String 是被final 修飾的。不能被修改，Stringbuild 的值是可以被修改的。 StringBuffer 是線程安全的類。被 Synchronized 修飾。

String 聲明的是不可變的變量，每次操作都會生成新的String對象，而Stringbuild 和 Stringbuffer 都是在原字符串上進行操作的。
StringBuild 是線程不安全的，推薦在單線程下使用，而StringBuffer 是線程安全的推薦在多線程下使用。

public final class StringBuffer extends AbstractStringBuilder implements java.io.Serializable,CharSequence{public synchronized int length(){return count;}// StringBuffer 是一個線程安全的類，類被final修飾。類中的所有方法都被 `synchronized` }

String str="i"與 String str=new String(“i”)一樣嗎？

不一樣，因為內存的分配方式不一樣。String str="i"的方式，java 虛擬機會將其分配到常量池中；而 String str=new String(“i”) 則會被分到堆內存中。

BIO，AIO，NIO 有什么區別？

BIO：同步阻塞式IO，簡單方便，并發處理效率低
NIO：同步非阻塞IO，客戶端和服務器通過channel 信道，實現了多路復用
AIO：NIO的升級,也叫NIO2。異步非阻塞IO

?

泛型

泛型類型用于類的定義中，被稱為泛型類。通過泛型可以完成對一組類的操作對外開放相同的接口。最典型的就是各種容器類，如：List、Set、Map。

public interface List<E> extends Collection<E> { ........ }//泛型的最基本寫法：classs 類名稱<泛型標識：可以隨便寫任意標識符，標識指定的泛型的類型>{private 泛型標識 /* （成員變量類型） */ var ；}public void showKeyValue1(Generic<?> obj){Log.d("泛型測試","key value is " + obj.getKey()); } ?

總結

以上是生活随笔為你收集整理的java 面试宝典总结的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。