Java最全面試題專題---1、Java基礎知識（2）

筆者有七八年的面試者經驗，負責公司技術同學的社招和校招，近些年面試過三四百個技術同學，考慮接近年底這個時段，整理并更新一些以往的面試經驗，希望同學們跳槽能有個更好的工作，如有需要的同學可以關注下筆者，近期會迭代更新。

這章更新Java面向對象的面試題。

面向對象

面向對象概述

面向對象和面向過程的區別

**面向過程：**優點：性能比面向對象高，因為類調用時需要實例化，開銷比較大，比較消耗資源;比如單片機、嵌入式開發、Linux/Unix等一般采用面向過程開發，性能是最重要的因素。缺點：沒有面向對象易維護、易復用、易擴展
**面向對象：**優點：易維護、易復用、易擴展，由于面向對象有封裝、繼承、多態性的特性，可以設計出低耦合的系統，使系統更加靈活、更加易于維護缺點：性能比面向過程低

面向過程是具體化的，流程化的，解決一個問題，你需要一步一步的分析，一步一步的實現。

面向對象是模型化的，你只需抽象出一個類，這是一個封閉的盒子，在這里你擁有數據也擁有解決問題的方法。需要什么功能直接使用就可以了，不必去一步一步的實現，至于這個功能是如何實現的，管我們什么事？我們會用就可以了。面向對象的底層其實還是面向過程，把面向過程抽象成類，然后封裝，方便我們使用的就是面向對象了。

面向對象三大特性

面向對象的特征有哪些方面

面向對象的特征主要有以下幾個方面：
抽象：
抽象是將一類對象的共同特征總結出來構造類的過程，包括數據抽象和行為抽象兩方面。抽象只關注對象有哪些屬性和行為，并不關注這些行為的細節是什么。
封裝
封裝把一個對象的屬性私有化，同時提供一些可以被外界訪問的屬性的方法，如果屬性不想被外界訪問，我們大可不必提供方法給外界訪問。但是如果一個類沒有提供給外界訪問的方法，那么這個類也沒有什么意義了。繼承
繼承是使用已存在的類的定義作為基礎建立新類的技術，新類的定義可以增加新的數據或新的功能，也可以用父類的功能，但不能選擇性地繼承父類。通過使用繼承我們能夠非常方便地復用以前的代碼。
關于繼承如下 3 點請記住：1. 子類擁有父類非 private 的屬性和方法。2. 子類可以擁有自己屬性和方法，即子類可以對父類進行擴展。3. 子類可以用自己的方式實現父類的方法。（以后介紹）。
多態
所謂多態就是指程序中定義的引用變量所指向的具體類型和通過該引用變量發出的方法調用在編程時并不確定，而是在程序運行期間才確定，即一個引用變量到底會指向哪個類的實例對象，該引用變量發出的方法調用到底是哪個類中實現的方法，必須在由程序運行期間才能決定。
在Java中有兩種形式可以實現多態：繼承（多個子類對同一方法的重寫）和接口（實現接口并覆蓋接口中同一方法）。

其中Java 面向對象編程三大特性：封裝繼承多態
**封裝：**隱藏對象的屬性和實現細節，僅對外提供公共訪問方式，將變化隔離，便于使用，提高復用性和安全性。
**繼承：**繼承是使用已存在的類的定義作為基礎建立新類的技術，新類的定義可以增加新的數據或新的功能，也可以用父類的功能，但不能選擇性地繼承父類。通過使用繼承可以提高代碼復用性。繼承是多態的前提。
關于繼承如下 3 點請記住：

子類擁有父類非 private 的屬性和方法。
子類可以擁有自己屬性和方法，即子類可以對父類進行擴展。
子類可以用自己的方式實現父類的方法。
**多態性：**父類或接口定義的引用變量可以指向子類或具體實現類的實例對象。提高了程序的拓展性。
在Java中有兩種形式可以實現多態：繼承（多個子類對同一方法的重寫）和接口（實現接口并覆蓋接口中同一方法）。
方法重載（overload）實現的是編譯時的多態性（也稱為前綁定），而方法重寫（override）實現的是運行時的多態性（也稱為后綁定）。一個引用變量到底會指向哪個類的實例對象，該引用變量發出的方法調用到底是哪個類中實現的方法，必須在由程序運行期間才能決定。運行時的多態是面向對象最精髓的東西，要實現多態需要做兩件事：

方法重寫（子類繼承父類并重寫父類中已有的或抽象的方法）；
對象造型（用父類型引用子類型對象，這樣同樣的引用調用同樣的方法就會根據子類對象的不同而表現出不同的行為）。

什么是多態機制？Java語言是如何實現多態的？

所謂多態就是指程序中定義的引用變量所指向的具體類型和通過該引用變量發出的方法調用在編程時并不確定，而是在程序運行期間才確定，即一個引用變量倒底會指向哪個類的實例對象，該引用變量發出的方法調用到底是哪個類中實現的方法，必須在由程序運行期間才能決定。因為在程序運行時才確定具體的類，這樣，不用修改源程序代碼，就可以讓引用變量綁定到各種不同的類實現上，從而導致該引用調用的具體方法隨之改變，即不修改程序代碼就可以改變程序運行時所綁定的具體代碼，讓程序可以選擇多個運行狀態，這就是多態性。

多態分為編譯時多態和運行時多態。其中編輯時多態是靜態的，主要是指方法的重載，它是根據參數列表的不同來區分不同的函數，通過編輯之后會變成兩個不同的函數，在運行時談不上多態。而運行時多態是動態的，它是通過動態綁定來實現的，也就是我們所說的多態性。

多態的實現

Java實現多態有三個必要條件：繼承、重寫、向上轉型。

繼承：在多態中必須存在有繼承關系的子類和父類。

重寫：子類對父類中某些方法進行重新定義，在調用這些方法時就會調用子類的方法。

向上轉型：在多態中需要將子類的引用賦給父類對象，只有這樣該引用才能夠具備技能調用父類的方法和子類的方法。

只有滿足了上述三個條件，我們才能夠在同一個繼承結構中使用統一的邏輯實現代碼處理不同的對象，從而達到執行不同的行為。

對于Java而言，它多態的實現機制遵循一個原則：當超類對象引用變量引用子類對象時，被引用對象的類型而不是引用變量的類型決定了調用誰的成員方法，但是這個被調用的方法必須是在超類中定義過的，也就是說被子類覆蓋的方法。

類與接口

抽象類和接口的對比

抽象類是用來捕捉子類的通用特性的。接口是抽象方法的集合。從設計層面來說，抽象類是對類的抽象，是一種模板設計，接口是行為的抽象，是一種行為的規范。

相同點

接口和抽象類都不能實例化
都位于繼承的頂端，用于被其他實現或繼承
都包含抽象方法，其子類都必須覆寫這些抽象方法

不同點

參數	抽象類	接口
聲明	抽象類使用abstract關鍵字聲明	接口使用interface關鍵字聲明
實現	子類使用extends關鍵字來繼承抽象類。如果子類不是抽象類的話，它需要提供抽象類中所有聲明的方法的實現	子類使用implements關鍵字來實現接口。它需要提供接口中所有聲明的方法的實現
構造器	抽象類可以有構造器	接口不能有構造器
訪問修飾符	抽象類中的方法可以是任意訪問修飾符	接口方法默認修飾符是public。并且不允許定義為 private 或者 protected
多繼承	一個類最多只能繼承一個抽象類	一個類可以實現多個接口
字段聲明	抽象類的字段聲明可以是任意的	接口的字段默認都是 static 和 final 的

備注： Java8中接口中引入默認方法和靜態方法，以此來減少抽象類和接口之間的差異。
現在，我們可以為接口提供默認實現的方法了，并且不用強制子類來實現它。接口和抽象類各有優缺點，在接口和抽象類的選擇上，必須遵守這樣一個原則：

行為模型應該總是通過接口而不是抽象類定義，所以通常是優先選用接口，盡量少用抽象類。
選擇抽象類的時候通常是如下情況：需要定義子類的行為，又要為子類提供通用的功能。

普通類和抽象類有哪些區別？

普通類不能包含抽象方法，抽象類可以包含抽象方法。
抽象類不能直接實例化，普通類可以直接實例化。

抽象類能使用 final 修飾嗎？

不能，定義抽象類就是讓其他類繼承的，如果定義為 final 該類就不能被繼承，這樣彼此就會產生矛盾，所以 final 不能修飾抽象類

創建一個對象用什么關鍵字？對象實例與對象引用有何不同？

new關鍵字，new創建對象實例（對象實例在堆內存中），對象引用指向對象實例（對象引用存放在棧內存中）。一個對象引用可以指向0個或1個對象（一根繩子可以不系氣球，也可以系一個氣球）;一個對象可以有n個引用指向它（可以用n條繩子系住一個氣球）

變量與方法

成員變量與局部變量的區別有哪些

變量：在程序執行的過程中，在某個范圍內其值可以發生改變的量。從本質上講，變量其實是內存中的一小塊區域
成員變量：方法外部，類內部定義的變量
局部變量：類的方法中的變量。

成員變量和局部變量的區別

作用域
成員變量：針對整個類有效。
局部變量：只在某個范圍內有效。(一般指的就是方法,語句體內)
存儲位置
成員變量：隨著對象的創建而存在，隨著對象的消失而消失，存儲在堆內存中。
局部變量：在方法被調用，或者語句被執行的時候存在，存儲在棧內存中。當方法調用完，或者語句結束后，就自動釋放。
生命周期
成員變量：隨著對象的創建而存在，隨著對象的消失而消失
局部變量：當方法調用完，或者語句結束后，就自動釋放。
初始值
成員變量：有默認初始值。
局部變量：沒有默認初始值，使用前必須賦值。
使用原則
在使用變量時需要遵循的原則為：就近原則首先在局部范圍找，有就使用；接著在成員位置找。

在Java中定義一個不做事且沒有參數的構造方法的作用

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

在調用子類構造方法之前會先調用父類沒有參數的構造方法，其目的是？

幫助子類做初始化工作。

個類的構造方法的作用是什么？若一個類沒有聲明構造方法，改程序能正確執行嗎？為什么？

主要作用是完成對類對象的初始化工作。可以執行。因為一個類即使沒有聲明構造方法也會有默認的不帶參數的構造方法。

構造方法有哪些特性？

名字與類名相同；沒有返回值，但不能用void聲明構造函數；生成類的對象時自動執行，無需調用。

靜態變量和實例變量區別

靜態變量：靜態變量由于不屬于任何實例對象，屬于類的，所以在內存中只會有一份，在類的加載過程中，JVM只為靜態變量分配一次內存空間。
實例變量：每次創建對象，都會為每個對象分配成員變量內存空間，實例變量是屬于實例對象的，在內存中，創建幾次對象，就有幾份成員變量。

靜態變量與普通變量區別

static變量也稱作靜態變量，靜態變量和非靜態變量的區別是：靜態變量被所有的對象所共享，在內存中只有一個副本，它當且僅當在類初次加載時會被初始化。而非靜態變量是對象所擁有的，在創建對象的時候被初始化，存在多個副本，各個對象擁有的副本互不影響。
還有一點就是static成員變量的初始化順序按照定義的順序進行初始化。

靜態方法和實例方法有何不同？

靜態方法和實例方法的區別主要體現在兩個方面：

在外部調用靜態方法時，可以使用"類名.方法名"的方式，也可以使用"對象名.方法名"的方式。而實例方法只有后面這種方式。也就是說，調用靜態方法可以無需創建對象。
靜態方法在訪問本類的成員時，只允許訪問靜態成員（即靜態成員變量和靜態方法），而不允許訪問實例成員變量和實例方法；實例方法則無此限制

在一個靜態方法內調用一個非靜態成員為什么是非法的？

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

什么是方法的返回值？返回值的作用是什么？

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

內部類

什么是內部類？

在Java中，可以將一個類的定義放在另外一個類的定義內部，這就是內部類。內部類本身就是類的一個屬性，與其他屬性定義方式一致。

內部類的分類有哪些

內部類可以分為四種：成員內部類、局部內部類、匿名內部類和靜態內部類。

靜態內部類

定義在類內部的靜態類，就是靜態內部類。

public class Outer {private static int radius = 1;static class StaticInner { public void visit() { System.out.println("visit outer static variable:" + radius); }}
}

靜態內部類可以訪問外部類所有的靜態變量，而不可訪問外部類的非靜態變量；靜態內部類的創建方式，new 外部類.靜態內部類()，如下：

Outer.StaticInner inner = new Outer.StaticInner();
inner.visit();

成員內部類

定義在類內部，成員位置上的非靜態類，就是成員內部類。

public class Outer {
private static int radius = 1;
private int count =2;class Inner {
public void visit() {
System.out.println("visit outer static variable:" + radius);
System.out.println("visit outer variable:" + count);}}}

成員內部類可以訪問外部類所有的變量和方法，包括靜態和非靜態，私有和公有。成員內部類依賴于外部類的實例，它的創建方式外部類實例.new 內部類()，如下：

Outer outer = new Outer();
Outer.Inner inner = outer.new Inner();
inner.visit();

局部內部類

定義在方法中的內部類，就是局部內部類。

public class Outer {private int out_a = 1;
private static int STATIC_b = 2;public void testFunctionClass(){
int inner_c =3;
class Inner {
private void fun(){
System.out.println(out_a);
System.out.println(STATIC_b);
System.out.println(inner_c);
}
}
Inner inner = new Inner();
inner.fun();
}
public static void testStaticFunctionClass(){
int d =3;
class Inner {
private void fun(){
// System.out.println(out_a); 編譯錯誤，定義在靜態方法中的局部類不可以訪問外部類的實例變量
System.out.println(STATIC_b);
System.out.println(d);
}
}
Inner inner = new Inner();
inner.fun();
}
}

定義在實例方法中的局部類可以訪問外部類的所有變量和方法，定義在靜態方法中的局部類只能訪問外部類的靜態變量和方法。局部內部類的創建方式，在對應方法內，new 內部類()，如下：

public static void testStaticFunctionClass(){
class Inner {
}
Inner inner = new Inner();
}

匿名內部類

匿名內部類就是沒有名字的內部類，日常開發中使用的比較多。

public class Outer {private void test(final int i) {
new Service() {
public void method() {
for (int j = 0; j < i; j++) {
System.out.println("匿名內部類" );
}
}
}.method();
}
}
//匿名內部類必須繼承或實現一個已有的接口
interface Service{
void method();
}

除了沒有名字，匿名內部類還有以下特點：

匿名內部類必須繼承一個抽象類或者實現一個接口。
匿名內部類不能定義任何靜態成員和靜態方法。
當所在的方法的形參需要被匿名內部類使用時，必須聲明為 final。
匿名內部類不能是抽象的，它必須要實現繼承的類或者實現的接口的所有抽象方法。

匿名內部類創建方式：

new 類/接口{
//匿名內部類實現部分
}

內部類的優點

我們為什么要使用內部類呢？因為它有以下優點：

一個內部類對象可以訪問創建它的外部類對象的內容，包括私有數據！
內部類不為同一包的其他類所見，具有很好的封裝性；
內部類有效實現了“多重繼承”，優化 java 單繼承的缺陷。
匿名內部類可以很方便的定義回調。

內部類有哪些應用場景

一些多算法場合
解決一些非面向對象的語句塊。
適當使用內部類，使得代碼更加靈活和富有擴展性。
當某個類除了它的外部類，不再被其他的類使用時。

局部內部類和匿名內部類訪問局部變量的時候，為什么變量必須要加上final？

局部內部類和匿名內部類訪問局部變量的時候，為什么變量必須要加上final呢？
它內部原理是什么呢？
先看這段代碼：

public class Outer {
void outMethod(){
final int a =10;
class Inner {
void innerMethod(){
System.out.println(a);
}
} 
}
}

以上例子，為什么要加final呢？是因為生命周期不一致，局部變量直接存儲在棧中，當方法執行結束后，非final的局部變量就被銷毀。而局部內部類對局部變量的引用依然存在，如果局部內部類要調用局部變量時，就會出錯。加了final，可以確保局部內部類使用的變量與外層的局部變量區分開，解決了這個問題。

內部類相關，看程序說出運行結果

public class Outer {
private int age = 12;class Inner {
private int age = 13;
public void print() {
int age = 14;
System.out.println("局部變量：" + age);
System.out.println("內部類變量：" + this.age);
System.out.println("外部類變量：" + Outer.this.age);
}
}
public static void main(String[] args) {
Outer.Inner in = new Outer().new Inner();
in.print();
}
}

運行結果：

局部變量：14
內部類變量：13
外部類變量：12

重寫與重載

構造器（constructor）是否可被重寫（override）

構造器不能被繼承，因此不能被重寫，但可以被重載。

重載（Overload）和重寫（Override）的區別。重載的方法能否根據返回類型進行區分？

方法的重載和重寫都是實現多態的方式，區別在于前者實現的是編譯時的多態性，而后者實現的是運行時的多態性。
重載：發生在同一個類中，方法名相同參數列表不同（參數類型不同、個數不同、順序不同），與方法返回值和訪問修飾符無關，即重載的方法不能根據返回類型進行區分
重寫：發生在父子類中，方法名、參數列表必須相同，返回值小于等于父類，拋出的異常小于等于父類，訪問修飾符大于等于父類（里氏代換原則）；如果父類方法訪問修飾符為private則子類中就不是重寫。

對象相等判斷

== 和 equals 的區別是什么

== : 它的作用是判斷兩個對象的地址是不是相等。即，判斷兩個對象是不是同一個對象。(基本數據類型 == 比較的是值，引用數據類型 == 比較的是內存地址)
equals() : 它的作用也是判斷兩個對象是否相等。但它一般有兩種使用情況：情況1：類沒有覆蓋 equals() 方法。則通過 equals() 比較該類的兩個對象時，等價于通過“==”比較這兩個對象。
情況2：類覆蓋了 equals() 方法。一般，我們都覆蓋 equals() 方法來兩個對象的內容相等；若它們的內容相等，則返回 true (即，認為這兩個對象相等)。
舉個例子：

public class test1 {
public static void main(String[] args) {
String a = new String("ab"); // a 為一個引用
String b = new String("ab"); // b為另一個引用,對象的內容一樣
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方法是比較的對象的內存地址，而String的equals方法比較的是對象的值。
當創建String類型的對象時，虛擬機會在常量池中查找有沒有已經存在的值和要創建的值相同的對象，如果有就把它賦給當前引用。如果沒有就在常量池中重新創建一個String對象。

hashCode 與 equals (重要)

HashSet如何檢查重復
兩個對象的 hashCode() 相同，則 equals() 也一定為 true，對嗎？
hashCode和equals方法的關系
面試官可能會問你：“你重寫過 hashcode 和 equals 么，為什么重寫equals時必須重寫hashCode方法？”
hashCode()介紹
hashCode() 的作用是獲取哈希碼，也稱為散列碼；它實際上是返回一個int整數。這個哈希碼的作用是確定該對象在哈希表中的索引位置。hashCode() 定義在JDK的Object.java中，這就意味著Java中的任何類都包含有hashCode()函數。
散列表存儲的是鍵值對(key-value)，它的特點是：能根據“鍵”快速的檢索出對應的“值”。這其中就利用到了散列碼！（可以快速找到所需要的對象）
為什么要有 hashCode
我們以“HashSet 如何檢查重復”為例子來說明為什么要有 hashCode：
當你把對象加入 HashSet 時，HashSet 會先計算對象的 hashcode 值來判斷對象加入的位置，同時也會與其他已經加入的對象的 hashcode 值作比較，如果沒有相符的hashcode，HashSet會假設對象沒有重復出現。但是如果發現有相同 hashcode 值的對象，這時會調用 equals()方法來檢查 hashcode 相等的對象是否真的相同。如果兩者相同，HashSet 就不會讓其加入操作成功。如果不同的話，就會重新散列到其他位置。（摘自我的Java啟蒙書《Head first java》第二版）。這樣我們就大大減少了 equals 的次數，相應就大大提高了執行速度。
hashCode()與equals()的相關規定
如果兩個對象相等，則hashcode一定也是相同的
兩個對象相等，對兩個對象分別調用equals方法都返回true
兩個對象有相同的hashcode值，它們也不一定是相等的
因此，equals 方法被覆蓋過，則 hashCode 方法也必須被覆蓋
hashCode() 的默認行為是對堆上的對象產生獨特值。如果沒有重寫hashCode()，則該 class 的兩個對象無論如何都不會相等（即使這兩個對象指向相同的數據）

對象的相等與指向他們的引用相等，兩者有什么不同？

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

值傳遞

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

是值傳遞。Java 語言的方法調用只支持參數的值傳遞。當一個對象實例作為一個參數被傳遞到方法中時，參數的值就是對該對象的引用。對象的屬性可以在被調用過程中被改變，但對對象引用的改變是不會影響到調用者的

為什么 Java 中只有值傳遞

首先回顧一下在程序設計語言中有關將參數傳遞給方法（或函數）的一些專業術語。按值調用(call by value)表示方法接收的是調用者提供的值，而按引用調用（call by reference)表示方法接收的是調用者提供的變量地址。一個方法可以修改傳遞引用所對應的變量值，而不能修改傳遞值調用所對應的變量值。它用來描述各種程序設計語言（不只是Java)中方法參數傳遞方式。Java程序設計語言總是采用按值調用。也就是說，方法得到的是所有參數值的一個拷貝，也就是說，方法不能修改傳遞給它的任何參數變量的內容。

值傳遞和引用傳遞有什么區別

值傳遞：指的是在方法調用時，傳遞的參數是按值的拷貝傳遞，傳遞的是值的拷貝，也就是說傳遞后就互不相關了。
引用傳遞：指的是在方法調用時，傳遞的參數是按引用進行傳遞，其實傳遞的引用的地址，也就是變量所對應的內存空間的地址。傳遞的是值的引用，也就是說傳遞前和傳遞后都指向同一個引用（也就是同一個內存空間）。

Java包

JDK 中常用的包有哪些

java.lang：這個是系統的基礎類；
java.io：這里面是所有輸入輸出有關的類，比如文件操作等；
java.nio：為了完善 io 包中的功能，提高 io 包中性能而寫的一個新包；
java.net：這里面是與網絡有關的類；
java.util：這個是系統輔助類，特別是集合類；
java.sql：這個是數據庫操作的類。

import java和javax有什么區別

剛開始的時候 JavaAPI 所必需的包是 java 開頭的包，javax 當時只是擴展 API包來說使用。然而隨著時間的推移，javax 逐漸的擴展成為 Java API 的組成部分。但是，將擴展從 javax 包移動到 java 包將是太麻煩了，最終會破壞一堆現有的代碼。因此，最終決定 javax 包將成為標準API的一部分。
所以，實際上java和javax沒有區別。這都是一個名字。