子類擁有父類非 private 的屬性和方法。

子類可以擁有自己屬性和方法，即子類可以對父類進行擴展。

子類可以用自己的方式實現(xiàn)父類的方法。（以后介紹）。

所謂多態(tài)就是指程序中定義的引用變量所指向的具體類型和通過該引用變量發(fā)出的方法調(diào)用在編程時并不確定，而是在程序運行期間才確定，即一個引用變量到底會指向哪個類的實例對象，該引用變量發(fā)出的方法調(diào)用到底是哪個類中實現(xiàn)的方法，必須在由程序運行期間才能決定。

在Java中有兩種形式可以實現(xiàn)多態(tài)：繼承（多個子類對同一方法的重寫）和接口（實現(xiàn)接口并覆蓋接口中同一方法）。

可變性
　

簡單的來說：String 類中使用 final 關(guān)鍵字修飾字符數(shù)組來保存字符串，private　final　char　value[]，所以 String 對象是不可變的。而StringBuilder 與 StringBuffer 都繼承自 AbstractStringBuilder 類，在 AbstractStringBuilder 中也是使用字符數(shù)組保存字符串char[]value 但是沒有用 final 關(guān)鍵字修飾，所以這兩種對象都是可變的。

StringBuilder 與 StringBuffer 的構(gòu)造方法都是調(diào)用父類構(gòu)造方法也就是 AbstractStringBuilder 實現(xiàn)的，大家可以自行查閱源碼。

AbstractStringBuilder.java

abstract class AbstractStringBuilder implements Appendable, CharSequence {
    char[] value;
    int count;
    AbstractStringBuilder() {
    }
    AbstractStringBuilder(int capacity) {
        value = new char[capacity];
    }

線程安全性

String 中的對象是不可變的，也就可以理解為常量，線程安全。AbstractStringBuilder 是 StringBuilder 與 StringBuffer 的公共父類，定義了一些字符串的基本操作，如 expandCapacity、append、insert、indexOf 等公共方法。StringBuffer 對方法加了同步鎖或者對調(diào)用的方法加了同步鎖，所以是線程安全的。StringBuilder 并沒有對方法進行加同步鎖，所以是非線程安全的。
　　

性能

每次對 String 類型進行改變的時候，都會生成一個新的 String 對象，然后將指針指向新的 String 對象。StringBuffer 每次都會對 StringBuffer 對象本身進行操作，而不是生成新的對象并改變對象引用。相同情況下使用 StringBuilder 相比使用 StringBuffer 僅能獲得 10%~15% 左右的性能提升，但卻要冒多線程不安全的風(fēng)險。

對于三者使用的總結(jié)：

操作少量的數(shù)據(jù): 適用String

單線程操作字符串緩沖區(qū)下操作大量數(shù)據(jù): 適用StringBuilder

多線程操作字符串緩沖區(qū)下操作大量數(shù)據(jù): 適用StringBuffer

裝箱：將基本類型用它們對應(yīng)的引用類型包裝起來；

拆箱：將包裝類型轉(zhuǎn)換為基本數(shù)據(jù)類型；

由于靜態(tài)方法可以不通過對象進行調(diào)用，因此在靜態(tài)方法里，不能調(diào)用其他非靜態(tài)變量，也不可以訪問非靜態(tài)變量成員。

　Java 程序在執(zhí)行子類的構(gòu)造方法之前，如果沒有用 super() 來調(diào)用父類特定的構(gòu)造方法，則會調(diào)用父類中“沒有參數(shù)的構(gòu)造方法”。因此，如果父類中只定義了有參數(shù)的構(gòu)造方法，而在子類的構(gòu)造方法中又沒有用 super() 來調(diào)用父類中特定的構(gòu)造方法，則編譯時將發(fā)生錯誤，因為 Java 程序在父類中找不到?jīng)]有參數(shù)的構(gòu)造方法可供執(zhí)行。解決辦法是在父類里加上一個不做事且沒有參數(shù)的構(gòu)造方法。
　

剛開始的時候 JavaAPI 所必需的包是 java 開頭的包，javax 當(dāng)時只是擴展 API 包來使用。然而隨著時間的推移，javax 逐漸地擴展成為 Java API 的組成部分。但是，但是，將擴展從 javax 包移動到 java 包確實太麻煩了，最終會破壞一堆現(xiàn)有的代碼。因此，最終決定 javax 包將成為標準API的一部分。

所以，實際上java和javax沒有區(qū)別。這都是一個名字。

接口的方法默認是 public，所有方法在接口中不能有實現(xiàn)(Java 8 開始接口方法可以有默認實現(xiàn)），而抽象類可以有非抽象的方法。

接口中的實例變量默認是 final 類型的，而抽象類中則不一定。

一個類可以實現(xiàn)多個接口，但最多只能實現(xiàn)一個抽象類。

一個類實現(xiàn)接口的話要實現(xiàn)接口的所有方法，而抽象類不一定。

接口不能用 new 實例化，但可以聲明，但是必須引用一個實現(xiàn)該接口的對象。從設(shè)計層面來說，抽象是對類的抽象，是一種模板設(shè)計，而接口是對行為的抽象，是一種行為的規(guī)范。

備注:在JDK8中，接口也可以定義靜態(tài)方法，可以直接用接口名調(diào)用。實現(xiàn)類和實現(xiàn)是不可以調(diào)用的。如果同時實現(xiàn)兩個接口，接口中定義了一樣的默認方法，則必須重寫，不然會報錯。(詳見issue:https://github.com/Snailclimb/JavaGuide/issues/146)

從語法形式上看:成員變量是屬于類的，而局部變量是在方法中定義的變量或是方法的參數(shù)；成員變量可以被 public,private,static 等修飾符所修飾，而局部變量不能被訪問控制修飾符及 static 所修飾；但是，成員變量和局部變量都能被 final 所修飾。

從變量在內(nèi)存中的存儲方式來看:如果成員變量是使用static修飾的，那么這個成員變量是屬于類的，如果沒有使用使用static修飾，這個成員變量是屬于實例的。而對象存在于堆內(nèi)存，局部變量則存在于棧內(nèi)存。

從變量在內(nèi)存中的生存時間上看:成員變量是對象的一部分，它隨著對象的創(chuàng)建而存在，而局部變量隨著方法的調(diào)用而自動消失。

成員變量如果沒有被賦初值:則會自動以類型的默認值而賦值（一種情況例外被 final 修飾的成員變量也必須顯示地賦值），而局部變量則不會自動賦值。

new運算符，new創(chuàng)建對象實例（對象實例在堆內(nèi)存中），對象引用指向?qū)ο髮嵗▽ο笠么娣旁跅?nèi)存中）。一個對象引用可以指向0個或1個對象（一根繩子可以不系氣球，也可以系一個氣球）;一個對象可以有n個引用指向它（可以用n條繩子系住一個氣球）。

方法的返回值是指我們獲取到的某個方法體中的代碼執(zhí)行后產(chǎn)生的結(jié)果！（前提是該方法可能產(chǎn)生結(jié)果）。返回值的作用:接收出結(jié)果，使得它可以用于其他的操作！

主要作用是完成對類對象的初始化工作?？梢詧?zhí)行。因為一個類即使沒有聲明構(gòu)造方法也會有默認的不帶參數(shù)的構(gòu)造方法。

名字與類名相同。

沒有返回值，但不能用void聲明構(gòu)造函數(shù)。

生成類的對象時自動執(zhí)行，無需調(diào)用。

在外部調(diào)用靜態(tài)方法時，可以使用"類名.方法名"的方式，也可以使用"對象名.方法名"的方式。而實例方法只有后面這種方式。也就是說，調(diào)用靜態(tài)方法可以無需創(chuàng)建對象。

靜態(tài)方法在訪問本類的成員時，只允許訪問靜態(tài)成員（即靜態(tài)成員變量和靜態(tài)方法），而不允許訪問實例成員變量和實例方法；實例方法則無此限制。

對象的相等，比的是內(nèi)存中存放的內(nèi)容是否相等。而引用相等，比較的是他們指向的內(nèi)存地址是否相等。

幫助子類做初始化工作。

== : 它的作用是判斷兩個對象的地址是不是相等。即，判斷兩個對象是不是同一個對象(基本數(shù)據(jù)類型==比較的是值，引用數(shù)據(jù)類型==比較的是內(nèi)存地址)。

equals() : 它的作用也是判斷兩個對象是否相等。但它一般有兩種使用情況：

情況1：類沒有覆蓋 equals() 方法。則通過 equals() 比較該類的兩個對象時，等價于通過“==”比較這兩個對象。

情況2：類覆蓋了 equals() 方法。一般，我們都覆蓋 equals() 方法來兩個對象的內(nèi)容相等；若它們的內(nèi)容相等，則返回 true (即，認為這兩個對象相等)。

舉個例子：

public class test1 {
    public static void main(String[] args) {
        String a = new String("ab"); // a 為一個引用
        String b = new String("ab"); // b為另一個引用,對象的內(nèi)容一樣
        String aa = "ab"; // 放在常量池中
        String bb = "ab"; // 從常量池中查找
        if (aa == bb) // true
            System.out.println("aa==bb");
        if (a == b) // false，非同一對象
            System.out.println("a==b");
        if (a.equals(b)) // true
            System.out.println("aEQb");
        if (42 == 42.0) { // true
            System.out.println("true");
        }
    }
}

說明：

String 中的 equals 方法是被重寫過的，因為 object 的 equals 方法是比較的對象的內(nèi)存地址，而 String 的 equals 方法比較的是對象的值。

當(dāng)創(chuàng)建 String 類型的對象時，虛擬機會在常量池中查找有沒有已經(jīng)存在的值和要創(chuàng)建的值相同的對象，如果有就把它賦給當(dāng)前引用。如果沒有就在常量池中重新創(chuàng)建一個 String 對象。

面試官可能會問你：“你重寫過 hashcode 和 equals 么，為什么重寫equals時必須重寫hashCode方法？”

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

散列表存儲的是鍵值對(key-value)，它的特點是：能根據(jù)“鍵”快速的檢索出對應(yīng)的“值”。這其中就利用到了散列碼?。梢钥焖僬业剿枰膶ο螅?/p> 為什么要有 hashCode

我們以“HashSet 如何檢查重復(fù)”為例子來說明為什么要有 hashCode：

當(dāng)你把對象加入 HashSet 時，HashSet 會先計算對象的 hashcode 值來判斷對象加入的位置，同時也會與其他已經(jīng)加入的對象的 hashcode 值作比較，如果沒有相符的hashcode，HashSet會假設(shè)對象沒有重復(fù)出現(xiàn)。但是如果發(fā)現(xiàn)有相同 hashcode 值的對象，這時會調(diào)用 equals（）方法來檢查 hashcode 相等的對象是否真的相同。如果兩者相同，HashSet 就不會讓其加入操作成功。如果不同的話，就會重新散列到其他位置。（摘自我的Java啟蒙書《Head first java》第二版）。這樣我們就大大減少了 equals 的次數(shù)，相應(yīng)就大大提高了執(zhí)行速度。

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

兩個對象相等,對兩個對象分別調(diào)用equals方法都返回true

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

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

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

為什么Java中只有值傳遞？

線程與進程相似，但線程是一個比進程更小的執(zhí)行單位。一個進程在其執(zhí)行的過程中可以產(chǎn)生多個線程。與進程不同的是同類的多個線程共享同一塊內(nèi)存空間和一組系統(tǒng)資源，所以系統(tǒng)在產(chǎn)生一個線程，或是在各個線程之間作切換工作時，負擔(dān)要比進程小得多，也正因為如此，線程也被稱為輕量級進程。

程序是含有指令和數(shù)據(jù)的文件，被存儲在磁盤或其他的數(shù)據(jù)存儲設(shè)備中，也就是說程序是靜態(tài)的代碼。

進程是程序的一次執(zhí)行過程，是系統(tǒng)運行程序的基本單位，因此進程是動態(tài)的。系統(tǒng)運行一個程序即是一個進程從創(chuàng)建，運行到消亡的過程。簡單來說，一個進程就是一個執(zhí)行中的程序，它在計算機中一個指令接著一個指令地執(zhí)行著，同時，每個進程還占有某些系統(tǒng)資源如CPU時間，內(nèi)存空間，文件，文件，輸入輸出設(shè)備的使用權(quán)等等。換句話說，當(dāng)程序在執(zhí)行時，將會被操作系統(tǒng)載入內(nèi)存中。
線程是進程劃分成的更小的運行單位。線程和進程最大的不同在于基本上各進程是獨立的，而各線程則不一定，因為同一進程中的線程極有可能會相互影響。從另一角度來說，進程屬于操作系統(tǒng)的范疇，主要是同一段時間內(nèi)，可以同時執(zhí)行一個以上的程序，而線程則是在同一程序內(nèi)幾乎同時執(zhí)行一個以上的程序段。

Java 線程在運行的生命周期中的指定時刻只可能處于下面6種不同狀態(tài)的其中一個狀態(tài)（圖源《Java 并發(fā)編程藝術(shù)》4.1.4節(jié)）。

線程在生命周期中并不是固定處于某一個狀態(tài)而是隨著代碼的執(zhí)行在不同狀態(tài)之間切換。Java 線程狀態(tài)變遷如下圖所示（圖源《Java 并發(fā)編程藝術(shù)》4.1.4節(jié)）：

由上圖可以看出：

線程創(chuàng)建之后它將處于 NEW（新建） 狀態(tài)，調(diào)用 start() 方法后開始運行，線程這時候處于 READY（可運行） 狀態(tài)?？蛇\行狀態(tài)的線程獲得了 cpu 時間片（timeslice）后就處于 RUNNING（運行） 狀態(tài)。

操作系統(tǒng)隱藏 Java虛擬機（JVM）中的 RUNNABLE 和 RUNNING 狀態(tài)，它只能看到 RUNNABLE 狀態(tài)（圖源：HowToDoInJava：Java Thread Life Cycle and Thread States），所以 Java 系統(tǒng)一般將這兩個狀態(tài)統(tǒng)稱為 RUNNABLE（運行中） 狀態(tài) 。

當(dāng)線程執(zhí)行 wait()方法之后，線程進入 WAITING（等待）狀態(tài)。進入等待狀態(tài)的線程需要依靠其他線程的通知才能夠返回到運行狀態(tài)，而 TIME_WAITING(超時等待) 狀態(tài)相當(dāng)于在等待狀態(tài)的基礎(chǔ)上增加了超時限制，比如通過 sleep（long millis）方法或 wait（long millis）方法可以將 Java 線程置于 TIMED WAITING 狀態(tài)。當(dāng)超時時間到達后 Java 線程將會返回到 RUNNABLE 狀態(tài)。當(dāng)線程調(diào)用同步方法時，在沒有獲取到鎖的情況下，線程將會進入到 BLOCKED（阻塞） 狀態(tài)。線程在執(zhí)行 Runnable 的 run() 方法之后將會進入到 TERMINATED（終止） 狀態(tài)。

final關(guān)鍵字主要用在三個地方：變量、方法、類。

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

當(dāng)用final修飾一個類時，表明這個類不能被繼承。final類中的所有成員方法都會被隱式地指定為final方法。

使用final方法的原因有兩個。第一個原因是把方法鎖定，以防任何繼承類修改它的含義；第二個原因是效率。在早期的Java實現(xiàn)版本中，會將final方法轉(zhuǎn)為內(nèi)嵌調(diào)用。但是如果方法過于龐大，可能看不到內(nèi)嵌調(diào)用帶來的任何性能提升（現(xiàn)在的Java版本已經(jīng)不需要使用final方法進行這些優(yōu)化了）。類中所有的private方法都隱式地指定為final。

在 Java 中，所有的異常都有一個共同的祖先java.lang包中的 Throwable類。Throwable： 有兩個重要的子類：Exception（異常） 和 Error（錯誤） ，二者都是 Java 異常處理的重要子類，各自都包含大量子類。

Error（錯誤）:是程序無法處理的錯誤，表示運行應(yīng)用程序中較嚴重問題。大多數(shù)錯誤與代碼編寫者執(zhí)行的操作無關(guān)，而表示代碼運行時 JVM（Java 虛擬機）出現(xiàn)的問題。例如，Java虛擬機運行錯誤（Virtual MachineError），當(dāng) JVM 不再有繼續(xù)執(zhí)行操作所需的內(nèi)存資源時，將出現(xiàn) OutOfMemoryError。這些異常發(fā)生時，Java虛擬機（JVM）一般會選擇線程終止。

這些錯誤表示故障發(fā)生于虛擬機自身、或者發(fā)生在虛擬機試圖執(zhí)行應(yīng)用時，如Java虛擬機運行錯誤（Virtual MachineError）、類定義錯誤（NoClassDefFoundError）等。這些錯誤是不可查的，因為它們在應(yīng)用程序的控制和處理能力之 外，而且絕大多數(shù)是程序運行時不允許出現(xiàn)的狀況。對于設(shè)計合理的應(yīng)用程序來說，即使確實發(fā)生了錯誤，本質(zhì)上也不應(yīng)該試圖去處理它所引起的異常狀況。在 Java中，錯誤通過Error的子類描述。

Exception（異常）:是程序本身可以處理的異常。Exception 類有一個重要的子類 RuntimeException。RuntimeException 異常由Java虛擬機拋出。NullPointerException（要訪問的變量沒有引用任何對象時，拋出該異常）、ArithmeticException（算術(shù)運算異常，一個整數(shù)除以0時，拋出該異常）和 ArrayIndexOutOfBoundsException （下標越界異常）。

注意：異常和錯誤的區(qū)別：異常能被程序本身可以處理，錯誤是無法處理。

public string getMessage():返回異常發(fā)生時的詳細信息

public string toString():返回異常發(fā)生時的簡要描述

public string getLocalizedMessage():返回異常對象的本地化信息。使用Throwable的子類覆蓋這個方法，可以聲稱本地化信息。如果子類沒有覆蓋該方法，則該方法返回的信息與getMessage（）返回的結(jié)果相同

public void printStackTrace():在控制臺上打印Throwable對象封裝的異常信息

try 塊：用于捕獲異常。其后可接零個或多個catch塊，如果沒有catch塊，則必須跟一個finally塊。

catch 塊：用于處理try捕獲到的異常。

finally 塊：無論是否捕獲或處理異常，finally塊里的語句都會被執(zhí)行。當(dāng)在try塊或catch塊中遇到return語句時，finally語句塊將在方法返回之前被執(zhí)行。

在以下4種特殊情況下，finally塊不會被執(zhí)行：

在finally語句塊第一行發(fā)生了異常。 因為在其他行，finally塊還是會得到執(zhí)行

在前面的代碼中用了System.exit(int)已退出程序。 exit是帶參函數(shù) ；若該語句在異常語句之后，finally會執(zhí)行

程序所在的線程死亡。

關(guān)閉CPU。

下面這部分內(nèi)容來自issue:https://github.com/Snailclimb...。

關(guān)于返回值：

如果try語句里有return，返回的是try語句塊中變量值。
詳細執(zhí)行過程如下：

如果有返回值，就把返回值保存到局部變量中；

執(zhí)行jsr指令跳到finally語句里執(zhí)行；

執(zhí)行完finally語句后，返回之前保存在局部變量表里的值。

如果try，finally語句里均有return，忽略try的return，而使用finally的return.

對于不想進行序列化的變量，使用transient關(guān)鍵字修飾。

transient關(guān)鍵字的作用是：阻止實例中那些用此關(guān)鍵字修飾的的變量序列化；當(dāng)對象被反序列化時，被transient修飾的變量值不會被持久化和恢復(fù)。transient只能修飾變量，不能修飾類和方法。

方法1：通過 Scanner

Scanner input = new Scanner(System.in);
String s  = input.nextLine();
input.close();

方法2：通過 BufferedReader

BufferedReader input = new BufferedReader(new InputStreamReader(System.in)); 
String s = input.readLine(); 

https://stackoverflow.com/que...

https://www.educba.com/oracle...

https://stackoverflow.com/que...