大家都應(yīng)該知道Java是目前最火的計算機(jī)語言之一，連續(xù)幾年蟬聯(lián)最受程序員歡迎的計算機(jī)語言榜首，因此每年新入職Java程序員也數(shù)不勝數(shù)。究竟這些新入職的Java程序員是入坑還是入行呢?那就要看他們對于Java這門語言的看法了。不管如何，在入職之前，問題會要經(jīng)過面試，那么Java面試題是怎么出的呢?下面羅列了20道常見初級Java面試題，簡直是入職者必備!?

遂川網(wǎng)站制作公司哪家好，找成都創(chuàng)新互聯(lián)！從網(wǎng)頁設(shè)計、網(wǎng)站建設(shè)、微信開發(fā)、APP開發(fā)、成都響應(yīng)式網(wǎng)站建設(shè)等網(wǎng)站項目制作，到程序開發(fā)，運(yùn)營維護(hù)。成都創(chuàng)新互聯(lián)從2013年成立到現(xiàn)在10年的時間，我們擁有了豐富的建站經(jīng)驗和運(yùn)維經(jīng)驗，來保證我們的工作的順利進(jìn)行。專注于網(wǎng)站建設(shè)就選成都創(chuàng)新互聯(lián)。

?

1、面向?qū)ο蟮奶卣饔心男┓矫??

答：面向?qū)ο蟮奶卣髦饕幸韵聨讉€方面：?

- 抽象：抽象是將一類對象的共同特征總結(jié)出來構(gòu)造類的過程，包括數(shù)據(jù)抽象和行為抽象兩方面。抽象只關(guān)注對象有哪些屬性和行為，并不關(guān)注這些行為的細(xì)節(jié)是什么。?

- 繼承：繼承是從已有類得到繼承信息創(chuàng)建新類的過程。提供繼承信息的類被稱為父類(超類、基類);得到繼承信息的類被稱為子類(派生類)。繼承讓變化中的軟件系統(tǒng)有了一定的延續(xù)性，同時繼承也是封裝程序中可變因素的重要手段(如果不能理解請閱讀閻宏博士的《Java與模式》或《設(shè)計模式精解》中關(guān)于橋梁模式的部分)。?

- 封裝：通常認(rèn)為封裝是把數(shù)據(jù)和操作數(shù)據(jù)的方法綁定起來，對數(shù)據(jù)的訪問只能通過已定義的接口。面向?qū)ο蟮谋举|(zhì)就是將現(xiàn)實世界描繪成一系列完全自治、封閉的對象。我們在類中編寫的方法就是對實現(xiàn)細(xì)節(jié)的一種封裝;我們編寫一個類就是對數(shù)據(jù)和數(shù)據(jù)操作的封裝?？梢哉f，封裝就是隱藏一切可隱藏的東西，只向外界提供最簡單的編程接口(可以想想普通洗衣機(jī)和全自動洗衣機(jī)的差別，明顯全自動洗衣機(jī)封裝更好因此操作起來更簡單;我們現(xiàn)在使用的智能手機(jī)也是封裝得足夠好的，因為幾個按鍵就搞定了所有的事情)。?

- 多態(tài)性：多態(tài)性是指允許不同子類型的對象對同一消息作出不同的響應(yīng)。簡單的說就是用同樣的對象引用調(diào)用同樣的方法但是做了不同的事情。多態(tài)性分為編譯時的多態(tài)性和運(yùn)行時的多態(tài)性。如果將對象的方法視為對象向外界提供的服務(wù)，那么運(yùn)行時的多態(tài)性可以解釋為：當(dāng)A系統(tǒng)訪問B系統(tǒng)提供的服務(wù)時，B系統(tǒng)有多種提供服務(wù)的方式，但一切對A系統(tǒng)來說都是透明的(就像電動剃須刀是A系統(tǒng)，它的供電系統(tǒng)是B系統(tǒng)，B系統(tǒng)可以使用電池供電或者用交流電，甚至還有可能是太陽能，A系統(tǒng)只會通過B類對象調(diào)用供電的方法，但并不知道供電系統(tǒng)的底層實現(xiàn)是什么，究竟通過何種方式獲得了動力)。方法重載(overload)實現(xiàn)的是編譯時的多態(tài)性(也稱為前綁定)，而方法重寫(override)實現(xiàn)的是運(yùn)行時的多態(tài)性(也稱為后綁定)。運(yùn)行時的多態(tài)是面向?qū)ο笞罹璧臇|西，要實現(xiàn)多態(tài)需要做兩件事：1). 方法重寫(子類繼承父類并重寫父類中已有的或抽象的方法);2). 對象造型(用父類型引用引用子類型對象，這樣同樣的引用調(diào)用同樣的方法就會根據(jù)子類對象的不同而表現(xiàn)出不同的行為)。?

2、訪問修飾符public,private,protected,以及不寫(默認(rèn))時的區(qū)別??

答：

類的成員不寫訪問修飾時默認(rèn)為default。默認(rèn)對于同一個包中的其他類相當(dāng)于公開(public)，對于不是同一個包中的其他類相當(dāng)于私有(private)。受保護(hù)(protected)對子類相當(dāng)于公開，對不是同一包中的沒有父子關(guān)系的類相當(dāng)于私有。Java中，外部類的修飾符只能是public或默認(rèn)，類的成員(包括內(nèi)部類)的修飾符可以是以上四種。?

3、String 是最基本的數(shù)據(jù)類型嗎??

答：不是。Java中的基本數(shù)據(jù)類型只有8個：byte、short、int、long、float、double、char、boolean;除了基本類型(primitive type)和枚舉類型(enumeration type)，剩下的都是引用類型(reference type)。?

4、float f=3.4;是否正確??

答:不正確。3.4是雙精度數(shù)，將雙精度型(double)賦值給浮點型(float)屬于下轉(zhuǎn)型(down-casting，也稱為窄化)會造成精度損失，因此需要強(qiáng)制類型轉(zhuǎn)換float f =(float)3.4; 或者寫成float f =3.4F;。?

5、short s1 = 1; s1 = s1 + 1;有錯嗎?short s1 = 1; s1 += 1;有錯嗎??

答：對于short s1 = 1; s1 = s1 + 1;由于1是int類型，因此s1+1運(yùn)算結(jié)果也是int 型，需要強(qiáng)制轉(zhuǎn)換類型才能賦值給short型。而short s1 = 1; s1 += 1;可以正確編譯，因為s1+= 1;相當(dāng)于s1 = (short)(s1 + 1);其中有隱含的強(qiáng)制類型轉(zhuǎn)換。?

?

6、Java有沒有g(shù)oto??

答：goto 是Java中的保留字，在目前版本的Java中沒有使用。(根據(jù)James Gosling(Java之父)編寫的《The Java Programming Language》一書的附錄中給出了一個Java關(guān)鍵字列表，其中有g(shù)oto和const，但是這兩個是目前無法使用的關(guān)鍵字，因此有些地方將其稱之為保留字，其實保留字這個詞應(yīng)該有更廣泛的意義，因為熟悉C語言的程序員都知道，在系統(tǒng)類庫中使用過的有特殊意義的單詞或單詞的組合都被視為保留字)?

7、int和Integer有什么區(qū)別??

答：Java是一個近乎純潔的面向?qū)ο缶幊陶Z言，但是為了編程的方便還是引入了基本數(shù)據(jù)類型，但是為了能夠?qū)⑦@些基本數(shù)據(jù)類型當(dāng)成對象操作，Java為每一個基本數(shù)據(jù)類型都引入了對應(yīng)的包裝類型(wrapper class)，int的包裝類就是Integer，從Java 5開始引入了自動裝箱/拆箱機(jī)制，使得二者可以相互轉(zhuǎn)換。?

Java 為每個原始類型提供了包裝類型：?

- 原始類型: boolean，char，byte，short，int，long，float，double?

- 包裝類型：Boolean，Character，Byte，Short，Integer，Long，F(xiàn)loat，Double?

class AutoUnboxingTest {

public static void main(String[] args) {

Integer a = new Integer(3);

Integer b = 3; // 將3自動裝箱成Integer類型

int c = 3;

System.out.println(a == b); // false 兩個引用沒有引用同一對象

System.out.println(a == c); // true a自動拆箱成int類型再和c比較

}

}

最近還遇到一個面試題，也是和自動裝箱和拆箱有點關(guān)系的，代碼如下所示：?

public class Test03 {

public static void main(String[] args) {

Integer f1 = 100, f2 = 100, f3 = 150, f4 = 150;

System.out.println(f1 == f2);

System.out.println(f3 == f4);

}

}

如果不明就里很容易認(rèn)為兩個輸出要么都是true要么都是false。首先需要注意的是f1、f2、f3、f4四個變量都是Integer對象引用，所以下面的==運(yùn)算比較的不是值而是引用。裝箱的本質(zhì)是什么呢?當(dāng)我們給一個Integer對象賦一個int值的時候，會調(diào)用Integer類的靜態(tài)方法valueOf，如果看看valueOf的源代碼就知道發(fā)生了什么。?

public static Integer valueOf(int i) {

if (i >= IntegerCache.low && i <= IntegerCache.high)

return IntegerCache.cache[i + (-IntegerCache.low)];

return new Integer(i);

}

IntegerCache是Integer的內(nèi)部類，其代碼如下所示：?

/**

* Cache to support the object identity semantics of autoboxing for values between

* -128 and 127 (inclusive) as required by JLS.

*

* The cache is initialized on first usage. The size of the cache

* may be controlled by the {@code -XX:AutoBoxCacheMax=} option.

* During VM initialization, java.lang.Integer.IntegerCache.high property

* may be set and saved in the private system properties in the

* sun.misc.VM class.

*/

private static class IntegerCache {

static final int low = -128;

static final int high;

static final Integer cache[];

static {

// high value may be configured by property

int h = 127;

String integerCacheHighPropValue =

sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");

if (integerCacheHighPropValue != null) {

try {

int i = parseInt(integerCacheHighPropValue);

i = Math.max(i, 127);

// Maximum array size is Integer.MAX_VALUE

h = Math.min(i, Integer.MAX_VALUE - (-low) -1);

} catch( NumberFormatException nfe) {

// If the property cannot be parsed into an int, ignore it.

}

}

high = h;

cache = new Integer[(high - low) + 1];

int j = low;

for(int k = 0; k < cache.length; k++)

cache[k] = new Integer(j++);

// range [-128, 127] must be interned (JLS7 5.1.7)

assert IntegerCache.high >= 127;

}

private IntegerCache() {}

}

簡單的說，如果整型字面量的值在-128到127之間，那么不會new新的Integer對象，而是直接引用常量池中的Integer對象，所以上面的面試題中f1==f2的結(jié)果是true，而f3==f4的結(jié)果是false。?

提醒：越是貌似簡單的面試題其中的玄機(jī)就越多，需要面試者有相當(dāng)深厚的功力。?

8、解釋內(nèi)存中的棧(stack)、堆(heap)和靜態(tài)區(qū)(static area)的用法。?

答：通常我們定義一個基本數(shù)據(jù)類型的變量，一個對象的引用，還有就是函數(shù)調(diào)用的現(xiàn)場保存都使用內(nèi)存中的棧空間;而通過new關(guān)鍵字和構(gòu)造器創(chuàng)建的對象放在堆空間;程序中的字面量(literal)如直接書寫的100、”hello”和常量都是放在靜態(tài)區(qū)中。?？臻g操作起來最快但是棧很小，通常大量的對象都是放在堆空間，理論上整個內(nèi)存沒有被其他進(jìn)程使用的空間甚至硬盤上的虛擬內(nèi)存都可以被當(dāng)成堆空間來使用。?

String str = new String("hello");

上面的語句中變量str放在棧上，用new創(chuàng)建出來的字符串對象放在堆上，而”hello”這個字面量放在靜態(tài)區(qū)。?

9、當(dāng)一個對象被當(dāng)作參數(shù)傳遞到一個方法后，此方法可改變這個對象的屬性，并可返回變化后的結(jié)果，那么這里到底是值傳遞還是引用傳遞??

答：是值傳遞。Java語言的方法調(diào)用只支持參數(shù)的值傳遞。當(dāng)一個對象實例作為一個參數(shù)被傳遞到方法中時，參數(shù)的值就是對該對象的引用。對象的屬性可以在被調(diào)用過程中被改變，但對對象引用的改變是不會影響到調(diào)用者的。C++和C#中可以通過傳引用或傳輸出參數(shù)來改變傳入的參數(shù)的值。在C#中可以編寫如下所示的代碼，但是在Java中卻做不到。?

using System;

namespace CS01 {

class Program {

public static void swap(ref int x, ref int y) {

int temp = x;

x = y;

y = temp;

}

public static void Main (string[] args) {

int a = 5, b = 10;

swap (ref a, ref b);

// a = 10, b = 5;

Console.WriteLine ("a = {0}, b = {1}", a, b);

}

}

}

說明：Java中沒有傳引用實在是非常的不方便，這一點在Java 8中仍然沒有得到改進(jìn)，正是如此在Java編寫的代碼中才會出現(xiàn)大量的Wrapper類(將需要通過方法調(diào)用修改的引用置于一個Wrapper類中，再將Wrapper對象傳入方法)，這樣的做法只會讓代碼變得臃腫，尤其是讓從C和C++轉(zhuǎn)型為Java程序員的開發(fā)者無法容忍。?

10、重載(Overload)和重寫(Override)的區(qū)別。重載的方法能否根據(jù)返回類型進(jìn)行區(qū)分??

答：方法的重載和重寫都是實現(xiàn)多態(tài)的方式，區(qū)別在于前者實現(xiàn)的是編譯時的多態(tài)性，而后者實現(xiàn)的是運(yùn)行時的多態(tài)性。重載發(fā)生在一個類中，同名的方法如果有不同的參數(shù)列表(參數(shù)類型不同、參數(shù)個數(shù)不同或者二者都不同)則視為重載;重寫發(fā)生在子類與父類之間，重寫要求子類被重寫方法與父類被重寫方法有相同的返回類型，比父類被重寫方法更好訪問，不能比父類被重寫方法聲明更多的異常(里氏代換原則)。重載對返回類型沒有特殊的要求。?

面試題：華為的面試題中曾經(jīng)問過這樣一個問題 - “為什么不能根據(jù)返回類型來區(qū)分重載”，快說出你的答案吧!?

11、描述一下JVM加載class文件的原理機(jī)制??

答：JVM中類的裝載是由類加載器(ClassLoader)和它的子類來實現(xiàn)的，Java中的類加載器是一個重要的Java運(yùn)行時系統(tǒng)組件，它負(fù)責(zé)在運(yùn)行時查找和裝入類文件中的類。?

由于Java的跨平臺性，經(jīng)過編譯的Java源程序并不是一個可執(zhí)行程序，而是一個或多個類文件。當(dāng)Java程序需要使用某個類時，JVM會確保這個類已經(jīng)被加載、連接(驗證、準(zhǔn)備和解析)和初始化。類的加載是指把類的.class文件中的數(shù)據(jù)讀入到內(nèi)存中，通常是創(chuàng)建一個字節(jié)數(shù)組讀入.class文件，然后產(chǎn)生與所加載類對應(yīng)的Class對象。加載完成后，Class對象還不完整，所以此時的類還不可用。當(dāng)類被加載后就進(jìn)入連接階段，這一階段包括驗證、準(zhǔn)備(為靜態(tài)變量分配內(nèi)存并設(shè)置默認(rèn)的初始值)和解析(將符號引用替換為直接引用)三個步驟。最后JVM對類進(jìn)行初始化，包括：1)如果類存在直接的父類并且這個類還沒有被初始化，那么就先初始化父類;2)如果類中存在初始化語句，就依次執(zhí)行這些初始化語句。?

類的加載是由類加載器完成的，類加載器包括：根加載器(BootStrap)、擴(kuò)展加載器(Extension)、系統(tǒng)加載器(System)和用戶自定義類加載器(java.lang.ClassLoader的子類)。從Java 2(JDK 1.2)開始，類加載過程采取了父親委托機(jī)制(PDM)。PDM更好的保證了Java平臺的安全性，在該機(jī)制中，JVM自帶的Bootstrap是根加載器，其他的加載器都有且僅有一個父類加載器。類的加載首先請求父類加載器加載，父類加載器無能為力時才由其子類加載器自行加載。JVM不會向Java程序提供對Bootstrap的引用。下面是關(guān)于幾個類加載器的說明：?

Bootstrap：一般用本地代碼實現(xiàn)，負(fù)責(zé)加載JVM基礎(chǔ)核心類庫(rt.jar);?

Extension：從java.ext.dirs系統(tǒng)屬性所指定的目錄中加載類庫，它的父加載器是Bootstrap;?

System：又叫應(yīng)用類加載器，其父類是Extension。它是應(yīng)用最廣泛的類加載器。它從環(huán)境變量classpath或者系統(tǒng)屬性java.class.path所指定的目錄中記載類，是用戶自定義加載器的默認(rèn)父加載器。?

12、抽象類(abstract class)和接口(interface)有什么異同??

答：抽象類和接口都不能夠?qū)嵗?，但可以定義抽象類和接口類型的引用。一個類如果繼承了某個抽象類或者實現(xiàn)了某個接口都需要對其中的抽象方法全部進(jìn)行實現(xiàn)，否則該類仍然需要被聲明為抽象類。接口比抽象類更加抽象，因為抽象類中可以定義構(gòu)造器，可以有抽象方法和具體方法，而接口中不能定義構(gòu)造器而且其中的方法全部都是抽象方法。抽象類中的成員可以是private、默認(rèn)、protected、public的，而接口中的成員全都是public的。抽象類中可以定義成員變量，而接口中定義的成員變量實際上都是常量。有抽象方法的類必須被聲明為抽象類，而抽象類未必要有抽象方法。?

13、靜態(tài)嵌套類(Static Nested Class)和內(nèi)部類(Inner Class)的不同??

答：Static Nested Class是被聲明為靜態(tài)(static)的內(nèi)部類，它可以不依賴于外部類實例被實例化。而通常的內(nèi)部類需要在外部類實例化后才能實例化，其語法看起來挺詭異的，如下所示。?

/**

* 撲克類(一副撲克)

*

*/

public class Poker {

private static String[] suites = {"黑桃", "紅桃", "草花", "方塊"};

private static int[] faces = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13};

private Card[] cards;

/**

* 構(gòu)造器

*

*/

public Poker() {

cards = new Card[52];

for(int i = 0; i < suites.length; i++) {

for(int j = 0; j < faces.length; j++) {

cards[i * 13 + j] = new Card(suites[i], faces[j]);

}

}

}

/**

* 洗牌 (隨機(jī)亂序)

*

*/

public void shuffle() {

for(int i = 0, len = cards.length; i < len; i++) {

int index = (int) (Math.random() * len);

Card temp = cards[index];

cards[index] = cards[i];

cards[i] = temp;

}

}

/**

* 發(fā)牌

* @param index 發(fā)牌的位置

*

*/

public Card deal(int index) {

return cards[index];

}

/**

* 卡片類(一張撲克)

* [內(nèi)部類]

*/

public class Card {

private String suite; // 花色

private int face; // 點數(shù)

public Card(String suite, int face) {

this.suite = suite;

this.face = face;

}

@Override

public String toString() {

String faceStr = "";

switch(face) {

case 1: faceStr = "A"; break;

case 11: faceStr = "J"; break;

case 12: faceStr = "Q"; break;

case 13: faceStr = "K"; break;

default: faceStr = String.valueOf(face);

}

return suite + faceStr;

}

}

}

測試代碼：

class PokerTest {

public static void main(String[] args) {

Poker poker = new Poker();

poker.shuffle(); // 洗牌

Poker.Card c1 = poker.deal(0); // 發(fā)第一張牌

// 對于非靜態(tài)內(nèi)部類Card

// 只有通過其外部類Poker對象才能創(chuàng)建Card對象

Poker.Card c2 = poker.new Card("紅心", 1); // 自己創(chuàng)建一張牌

System.out.println(c1); // 洗牌后的第一張

System.out.println(c2); // 打印: 紅心A

}

}

面試題 - 下面的代碼哪些地方會產(chǎn)生編譯錯誤??

class Outer {

class Inner {}

public static void foo() { new Inner(); }

public void bar() { new Inner(); }

public static void main(String[] args) {

new Inner();

}

}

注意：Java中非靜態(tài)內(nèi)部類對象的創(chuàng)建要依賴其外部類對象，上面的面試題中foo和main方法都是靜態(tài)方法，靜態(tài)方法中沒有this，也就是說沒有所謂的外部類對象，因此無法創(chuàng)建內(nèi)部類對象，如果要在靜態(tài)方法中創(chuàng)建內(nèi)部類對象，可以這樣做：?

new Outer().new Inner();

14、Java 中會存在內(nèi)存泄漏嗎，請簡單描述。?

答：理論上Java因為有垃圾回收機(jī)制(GC)不會存在內(nèi)存泄露問題(這也是Java被廣泛使用于服務(wù)器端編程的一個重要原因);然而在實際開發(fā)中，可能會存在無用但可達(dá)的對象，這些對象不能被GC回收，因此也會導(dǎo)致內(nèi)存泄露的發(fā)生。例如Hibernate的Session(一級緩存)中的對象屬于持久態(tài)，垃圾回收器是不會回收這些對象的，然而這些對象中可能存在無用的垃圾對象，如果不及時關(guān)閉(close)或清空(flush)一級緩存就可能導(dǎo)致內(nèi)存泄露。下面例子中的代碼也會導(dǎo)致內(nèi)存泄露。?

import java.util.Arrays;

import java.util.EmptyStackException;

public class MyStack {

private T[] elements;

private int size = 0;

private static final int INIT_CAPACITY = 16;

public MyStack() {

elements = (T[]) new Object[INIT_CAPACITY];

}

public void push(T elem) {

ensureCapacity();

elements[size++] = elem;

}

public T pop() {

if(size == 0)

throw new EmptyStackException();

return elements[--size];

}

private void ensureCapacity() {

if(elements.length == size) {

elements = Arrays.copyOf(elements, 2 * size + 1);

}

}

}

上面的代碼實現(xiàn)了一個棧(先進(jìn)后出(FILO))結(jié)構(gòu)，乍看之下似乎沒有什么明顯的問題，它甚至可以通過你編寫的各種單元測試。然而其中的pop方法卻存在內(nèi)存泄露的問題，當(dāng)我們用pop方法彈出棧中的對象時，該對象不會被當(dāng)作垃圾回收，即使使用棧的程序不再引用這些對象，因為棧內(nèi)部維護(hù)著對這些對象的過期引用(obsolete reference)。在支持垃圾回收的語言中，內(nèi)存泄露是很隱蔽的，這種內(nèi)存泄露其實就是無意識的對象保持。如果一個對象引用被無意識的保留起來了，那么垃圾回收器不會處理這個對象，也不會處理該對象引用的其他對象，即使這樣的對象只有少數(shù)幾個，也可能會導(dǎo)致很多的對象被排除在垃圾回收之外，從而對性能造成重大影響，極端情況下會引發(fā)Disk Paging(物理內(nèi)存與硬盤的虛擬內(nèi)存交換數(shù)據(jù))，甚至造成OutOfMemoryError。?

15、如何實現(xiàn)對象克隆??

答：有兩種方式：?

1). 實現(xiàn)Cloneable接口并重寫Object類中的clone()方法;?

2). 實現(xiàn)Serializable接口，通過對象的序列化和反序列化實現(xiàn)克隆，可以實現(xiàn)真正的深度克隆，代碼如下。?

import java.io.ByteArrayInputStream;

import java.io.ByteArrayOutputStream;

import java.io.ObjectInputStream;

import java.io.ObjectOutputStream;

public class MyUtil {

private MyUtil() {

throw new Asserti();

}

public static T clone(T obj) throws Exception {

ByteArrayOutputStream bout = new ByteArrayOutputStream();

ObjectOutputStream oos = new ObjectOutputStream(bout);

oos.writeObject(obj);

ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());

ObjectInputStream ois = new ObjectInputStream(bin);

return (T) ois.readObject();

// 說明：調(diào)用ByteArrayInputStream或ByteArrayOutputStream對象的close方法沒有任何意義

// 這兩個基于內(nèi)存的流只要垃圾回收器清理對象就能夠釋放資源，這一點不同于對外部資源(如文件流)的釋放

}

}

下面是測試代碼：?

import java.io.Serializable;

/**

* 人類

*/

class Person implements Serializable {

private static final long serialVersionUID = -9102017020286042305L;

private String name; // 姓名

private int age; // 年齡

private Car car; // 座駕

public Person(String name, int age, Car car) {

this.name = name;

this.age = age;

this.car = car;

}

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

public int getAge() {

return age;

}

public void setAge(int age) {

this.age = age;

}

public Car getCar() {

return car;

}

public void setCar(Car car) {

this.car = car;

}

@Override

public String toString() {

return "Person [name=" + name + ", age=" + age + ", car=" + car + "]";

}

}1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950

/**

* 小汽車類

*/

class Car implements Serializable {

private static final long serialVersionUID = -5713945027627603702L;

private String brand; // 品牌

private int maxSpeed; // 最高時速

public Car(String brand, int maxSpeed) {

this.brand = brand;

this.maxSpeed = maxSpeed;

}

public String getBrand() {

return brand;

}

public void setBrand(String brand) {

this.brand = brand;

}

public int getMaxSpeed() {

return maxSpeed;

}

public void setMaxSpeed(int maxSpeed) {

this.maxSpeed = maxSpeed;

}

@Override

public String toString() {

return "Car [brand=" + brand + ", maxSpeed=" + maxSpeed + "]";

}

}

class CloneTest {

public static void main(String[] args) {

try {

Person p1 = new Person("Hao LUO", 33, new Car("Benz", 300));

Person p2 = MyUtil.clone(p1); // 深度克隆

p2.getCar().setBrand("BYD");

// 修改克隆的Person對象p2關(guān)聯(lián)的汽車對象的品牌屬性

// 原來的Person對象p1關(guān)聯(lián)的汽車不會受到任何影響

// 因為在克隆Person對象時其關(guān)聯(lián)的汽車對象也被克隆了

System.out.println(p1);

} catch (Exception e) {

e.printStackTrace();

}

}

}

注意：基于序列化和反序列化實現(xiàn)的克隆不僅僅是深度克隆，更重要的是通過泛型限定，可以檢查出要克隆的對象是否支持序列化，這項檢查是編譯器完成的，不是在運(yùn)行時拋出異常，這種是方案明顯優(yōu)于使用Object類的clone方法克隆對象。讓問題在編譯的時候暴露出來總是優(yōu)于把問題留到運(yùn)行時。?

16、GC是什么?為什么要有GC??

答：GC是垃圾收集的意思，內(nèi)存處理是編程人員容易出現(xiàn)問題的地方，忘記或者錯誤的內(nèi)存回收會導(dǎo)致程序或系統(tǒng)的不穩(wěn)定甚至崩潰，Java提供的GC功能可以自動監(jiān)測對象是否超過作用域從而達(dá)到自動回收內(nèi)存的目的，Java語言沒有提供釋放已分配內(nèi)存的顯示操作方法。Java程序員不用擔(dān)心內(nèi)存管理，因為垃圾收集器會自動進(jìn)行管理。要請求垃圾收集，可以調(diào)用下面的方法之一：System.gc() 或Runtime.getRuntime().gc() ，但JVM可以屏蔽掉顯示的垃圾回收調(diào)用。?

垃圾回收可以有效的防止內(nèi)存泄露，有效的使用可以使用的內(nèi)存。垃圾回收器通常是作為一個單獨(dú)的低優(yōu)先級的線程運(yùn)行，不可預(yù)知的情況下對內(nèi)存堆中已經(jīng)死亡的或者長時間沒有使用的對象進(jìn)行清除和回收，程序員不能實時的調(diào)用垃圾回收器對某個對象或所有對象進(jìn)行垃圾回收。在Java誕生初期，垃圾回收是Java最大的亮點之一，因為服務(wù)器端的編程需要有效的防止內(nèi)存泄露問題，然而時過境遷，如今Java的垃圾回收機(jī)制已經(jīng)成為被詬病的東西。移動智能終端用戶通常覺得iOS的系統(tǒng)比Android系統(tǒng)有更好的用戶體驗，其中一個深層次的原因就在于Android系統(tǒng)中垃圾回收的不可預(yù)知性。?

補(bǔ)充：垃圾回收機(jī)制有很多種，包括：分代復(fù)制垃圾回收、標(biāo)記垃圾回收、增量垃圾回收等方式。標(biāo)準(zhǔn)的Java進(jìn)程既有棧又有堆。棧保存了原始型局部變量，堆保存了要創(chuàng)建的對象。Java平臺對堆內(nèi)存回收和再利用的基本算法被稱為標(biāo)記和清除，但是Java對其進(jìn)行了改進(jìn)，采用“分代式垃圾收集”。這種方法會跟Java對象的生命周期將堆內(nèi)存劃分為不同的區(qū)域，在垃圾收集過程中，可能會將對象移動到不同區(qū)域：?

- 伊甸園(Eden)：這是對象最初誕生的區(qū)域，并且對大多數(shù)對象來說，這里是它們唯一存在過的區(qū)域。?

- 幸存者樂園(Survivor)：從伊甸園幸存下來的對象會被挪到這里。?

- 終身頤養(yǎng)園(Tenured)：這是足夠老的幸存對象的歸宿。年輕代收集(Minor-GC)過程是不會觸及這個地方的。當(dāng)年輕代收集不能把對象放進(jìn)終身頤養(yǎng)園時，就會觸發(fā)一次完全收集(Major-GC)，這里可能還會牽扯到壓縮，以便為大對象騰出足夠的空間。?

與垃圾回收相關(guān)的JVM參數(shù)：?

-Xms / -Xmx — 堆的初始大小 / 堆的最大大小?

-Xmn — 堆中年輕代的大小?

-XX:-DisableExplicitGC — 讓System.gc()不產(chǎn)生任何作用?

-XX:+PrintGCDetails — 打印GC的細(xì)節(jié)?

-XX:+PrintGCDateStamps — 打印GC操作的時間戳?

-XX:NewSize / XX:MaxNewSize — 設(shè)置新生代大小/新生代最大大小?

-XX:NewRatio — 可以設(shè)置老生代和新生代的比例?

-XX:PrintTenuringDistribution — 設(shè)置每次新生代GC后輸出幸存者樂園中對象年齡的分布?

-XX:InitialTenuringThreshold / -XX:MaxTenuringThreshold：設(shè)置老年代閥值的初始值和最大值?

-XX:TargetSurvivorRatio：設(shè)置幸存區(qū)的目標(biāo)使用率?

17、日期和時間：?

- 如何取得年月日、小時分鐘秒??

- 如何取得從1970年1月1日0時0分0秒到現(xiàn)在的毫秒數(shù)??

- 如何取得某月的最后一天??

- 如何格式化日期??

答：?

問題1：創(chuàng)建java.util.Calendar 實例，調(diào)用其get()方法傳入不同的參數(shù)即可獲得參數(shù)所對應(yīng)的值。Java 8中可以使用java.time.LocalDateTimel來獲取，代碼如下所示。?

public class DateTimeTest {

public static void main(String[] args) {

Calendar cal = Calendar.getInstance();

System.out.println(cal.get(Calendar.YEAR));

System.out.println(cal.get(Calendar.MONTH)); // 0 - 11

System.out.println(cal.get(Calendar.DATE));

System.out.println(cal.get(Calendar.HOUR_OF_DAY));

System.out.println(cal.get(Calendar.MINUTE));

System.out.println(cal.get(Calendar.SECOND));

// Java 8

LocalDateTime dt = LocalDateTime.now();

System.out.println(dt.getYear());

System.out.println(dt.getMonthValue()); // 1 - 12

System.out.println(dt.getDayOfMonth());

System.out.println(dt.getHour());

System.out.println(dt.getMinute());

System.out.println(dt.getSecond());

}

}

問題2：以下方法均可獲得該毫秒數(shù)。?

? ?Calendar.getInstance().getTimeInMillis();

System.currentTimeMillis();

Clock.systemDefaultZone().millis(); // Java 8

問題3：代碼如下所示。?

? ?Calendar time = Calendar.getInstance();

time.getActualMaximum(Calendar.DAY_OF_MONTH);12

問題4：利用java.text.DataFormat 的子類(如SimpleDateFormat類)中的format(Date)方法可將日期格式化。Java 8中可以用java.time.format.DateTimeFormatter來格式化時間日期，代碼如下所示。?

import java.text.SimpleDateFormat;

import java.time.LocalDate;

import java.time.format.DateTimeFormatter;

import java.util.Date;

class DateFormatTest {

public static void main(String[] args) {

SimpleDateFormat oldFormatter = new SimpleDateFormat("yyyy/MM/dd");

Date date1 = new Date();

System.out.println(oldFormatter.format(date1));

// Java 8

DateTimeFormatter newFormatter = DateTimeFormatter.ofPattern("yyyy/MM/dd");

LocalDate date2 = LocalDate.now();

System.out.println(date2.format(newFormatter));

}

}

補(bǔ)充：Java的時間日期API一直以來都是被詬病的東西，為了解決這一問題，Java 8中引入了新的時間日期API，其中包括LocalDate、LocalTime、LocalDateTime、Clock、Instant等類，這些的類的設(shè)計都使用了不變模式，因此是線程安全的設(shè)計。如果不理解這些內(nèi)容，可以參考我的另一篇文章《關(guān)于Java并發(fā)編程的總結(jié)和思考》。?

18、比較一下Java和JavaSciprt。?

答：Java 與Java是兩個公司開發(fā)的不同的兩個產(chǎn)品。Java 是原Sun Microsystems公司推出的面向?qū)ο蟮某绦蛟O(shè)計語言，特別適合于互聯(lián)網(wǎng)應(yīng)用程序開發(fā);而Java是Netscape公司的產(chǎn)品，為了擴(kuò)展Netscape瀏覽器的功能而開發(fā)的一種可以嵌入Web頁面中運(yùn)行的基于對象和事件驅(qū)動的解釋性語言。Java的前身是Live;而Java的前身是Oak語言。?

下面對兩種語言間的異同作如下比較：?

- 基于對象和面向?qū)ο螅篔ava是一種真正的面向?qū)ο蟮恼Z言，即使是開發(fā)簡單的程序，必須設(shè)計對象;Java是種腳本語言，它可以用來制作與網(wǎng)絡(luò)無關(guān)的，與用戶交互作用的復(fù)雜軟件。它是一種基于對象(Object-Based)和事件驅(qū)動(Event-Driven)的編程語言，因而它本身提供了非常豐富的內(nèi)部對象供設(shè)計人員使用。?

- 解釋和編譯：Java的源代碼在執(zhí)行之前，必須經(jīng)過編譯。Java是一種解釋性編程語言，其源代碼不需經(jīng)過編譯，由瀏覽器解釋執(zhí)行。(目前的瀏覽器幾乎都使用了JIT(即時編譯)技術(shù)來提升Java的運(yùn)行效率)?

- 強(qiáng)類型變量和類型弱變量：Java采用強(qiáng)類型變量檢查，即所有變量在編譯之前必須作聲明;Java中變量是弱類型的，甚至在使用變量前可以不作聲明，Java的解釋器在運(yùn)行時檢查推斷其數(shù)據(jù)類型。?

- 代碼格式不一樣。?

19、Java堆的結(jié)構(gòu)是什么樣子的?什么是堆中的永久代(Perm Gen space)??

JVM的堆是運(yùn)行時數(shù)據(jù)區(qū)，所有類的實例和數(shù)組都是在堆上分配內(nèi)存。它在JVM啟動的時候被創(chuàng)建。對象所占的堆內(nèi)存是由自動內(nèi)存管理系統(tǒng)也就是垃圾收集器回收。?

堆內(nèi)存是由存活和死亡的對象組成的。存活的對象是應(yīng)用可以訪問的，不會被垃圾回收。死亡的對象是應(yīng)用不可訪問尚且還沒有被垃圾收集器回收掉的對象。一直到垃圾收集器把這些對象回收掉之前，他們會一直占據(jù)堆內(nèi)存空間。?

20、闡述ArrayList、Vector、LinkedList的存儲性能和特性。?

答：ArrayList 和Vector都是使用數(shù)組方式存儲數(shù)據(jù)，此數(shù)組元素數(shù)大于實際存儲的數(shù)據(jù)以便增加和插入元素，它們都允許直接按序號索引元素，但是插入元素要涉及數(shù)組元素移動等內(nèi)存操作，所以索引數(shù)據(jù)快而插入數(shù)據(jù)慢，Vector中的方法由于添加了synchronized修飾，因此Vector是線程安全的容器，但性能上較ArrayList差，因此已經(jīng)是Java中的遺留容器。LinkedList使用雙向鏈表實現(xiàn)存儲(將內(nèi)存中零散的內(nèi)存單元通過附加的引用關(guān)聯(lián)起來，形成一個可以按序號索引的線性結(jié)構(gòu)，這種鏈?zhǔn)酱鎯Ψ绞脚c數(shù)組的連續(xù)存儲方式相比，內(nèi)存的利用率更高)，按序號索引數(shù)據(jù)需要進(jìn)行前向或后向遍歷，但是插入數(shù)據(jù)時只需要記錄本項的前后項即可，所以插入速度較快。Vector屬于遺留容器(Java早期的版本中提供的容器，除此之外，Hashtable、Dictionary、BitSet、Stack、Properties都是遺留容器)，已經(jīng)不推薦使用，但是由于ArrayList和LinkedListed都是非線程安全的，如果遇到多個線程操作同一個容器的場景，則可以通過工具類Collections中的synchronizedList方法將其轉(zhuǎn)換成線程安全的容器后再使用(這是對裝潢模式的應(yīng)用，將已有對象傳入另一個類的構(gòu)造器中創(chuàng)建新的對象來增強(qiáng)實現(xiàn))。?

補(bǔ)充：遺留容器中的Properties類和Stack類在設(shè)計上有嚴(yán)重的問題，Properties是一個鍵和值都是字符串的特殊的鍵值對映射，在設(shè)計上應(yīng)該是關(guān)聯(lián)一個Hashtable并將其兩個泛型參數(shù)設(shè)置為String類型，但是Java API中的Properties直接繼承了Hashtable，這很明顯是對繼承的濫用。這里復(fù)用代碼的方式應(yīng)該是Has-A關(guān)系而不是Is-A關(guān)系，另一方面容器都屬于工具類，繼承工具類本身就是一個錯誤的做法，使用工具類最好的方式是Has-A關(guān)系(關(guān)聯(lián))或Use-A關(guān)系(依賴)。同理，Stack類繼承Vector也是不正確的。Sun公司的工程師們也會犯這種低級錯誤，讓人唏噓不已。

歡迎工作一到五年的Java工程師朋友們加入Java技術(shù)交流群：659270626
群內(nèi)提供免費(fèi)的Java架構(gòu)學(xué)習(xí)資料（里面有高可用、高并發(fā)、高性能及分布式、Jvm性能調(diào)優(yōu)、Spring源碼，MyBatis，Netty,redis,Kafka,MySQL,Zookeeper,Tomcat,Docker,Dubbo,Nginx等多個知識點的架構(gòu)資料）合理利用自己每一分每一秒的時間來學(xué)習(xí)提升自己，不要再用"沒有時間“來掩飾自己思想上的懶惰！趁年輕，使勁拼，給未來的自己一個交代！

?

新聞名稱：Java面試必看二十問題
文章鏈接：http://aaarwkj.com/article18/jjhdgp.html

成都網(wǎng)站建設(shè)公司_創(chuàng)新互聯(lián)，為您提供品牌網(wǎng)站設(shè)計、軟件開發(fā)、網(wǎng)站維護(hù)、用戶體驗、動態(tài)網(wǎng)站、ChatGPT

廣告

聲明：本網(wǎng)站發(fā)布的內(nèi)容（圖片、視頻和文字）以用戶投稿、用戶轉(zhuǎn)載內(nèi)容為主，如果涉及侵權(quán)請盡快告知，我們將會在第一時間刪除。文章觀點不代表本網(wǎng)站立場，如需處理請聯(lián)系客服。電話：028-86922220；郵箱：631063699@qq.com。內(nèi)容未經(jīng)允許不得轉(zhuǎn)載，或轉(zhuǎn)載時需注明來源： 創(chuàng)新互聯(lián)