基礎(chǔ)不牢靠，何以爭朝夕？Java基礎(chǔ)面試82道詳細(xì)解析?。ㄒ唬?/h1>

發(fā)布時間：2020-03-31 12:08:31 來源：網(wǎng)絡(luò) 閱讀：294 作者：wx5d9ed7c8443c3 欄目：編程語言

計算機(jī)軟件系統(tǒng)是現(xiàn)實(shí)生活中的業(yè)務(wù)在計算機(jī)中的映射，而現(xiàn)實(shí)生活中的業(yè)務(wù)其實(shí)就是一個個對象協(xié)作的過程。面向?qū)ο缶幊叹褪前船F(xiàn)實(shí)業(yè)務(wù)一樣的方式將程序代碼按一個個對象進(jìn)行組織和編寫，讓計算機(jī)系統(tǒng)能夠識別和理解用對象方式組織和編寫的程序代碼，這樣就可以把現(xiàn)實(shí)生活中的業(yè)務(wù)對象映射到計算機(jī)系統(tǒng)中。
面向?qū)ο蟮木幊陶Z言有封裝、繼承 、抽象、多態(tài)等4個主要的特征。

封裝：
封裝是保證軟件部件具有優(yōu)良的模塊性的基礎(chǔ)，封裝的目標(biāo)就是要實(shí)現(xiàn)軟件部件的“高內(nèi)聚、低耦合”，防止程序相互依賴性而帶來的變動影響。在面向?qū)ο蟮木幊陶Z言中，對象是封裝的最基本單位，面向?qū)ο蟮姆庋b比傳統(tǒng)語言的封裝更為清晰、更為有力。面向?qū)ο蟮姆庋b就是把描述一個對象的屬性和行為的代碼封裝在一個“模塊”中，也就是一個類中，屬性用變量定義，行為用方法進(jìn)行定義，方法可以直接訪問同一個對象中的屬性。通常情況下，只要記住讓變量和訪問這個變量的方法放在一起，將一個類中的成員變量全部定義成私有的，只有這個類自己的方法才可以訪問到這些成員變量，這就基本上實(shí)現(xiàn)對象的封裝，就很容易找出要分配到這個類上的方法了，就基本上算是會面向?qū)ο蟮木幊塘恕０盐找粋€原則：把對同一事物進(jìn)行操作的方法和相關(guān)的方法放在同一個類中，把方法和它操作的數(shù)據(jù)放在同一個類中。

例如，人要在黑板上畫圓，這一共涉及三個對象：人、黑板、圓，畫圓的方法要分配給哪個對象呢？由于畫圓需要使用到圓心和半徑，圓心和半徑顯然是圓的屬性，如果將它們在類中定義成了私有的成員變量，那么，畫圓的方法必須分配給圓，它才能訪問到圓心和半徑這兩個屬性，人以后只是調(diào)用圓的畫圓方法、表示給圓發(fā)給消息而已，畫圓這個方法不應(yīng)該分配在人這個對象上，這就是面向?qū)ο蟮姆庋b性，即將對象封裝成一個高度自治和相對封閉的個體，對象狀態(tài)（屬性）由這個對象自己的行為（方法）來讀取和改變。一個更便于理解的例子就是，司機(jī)將火車剎住了，剎車的動作是分配給司機(jī)，還是分配給火車，顯然，應(yīng)該分配給火車，因?yàn)樗緳C(jī)自身是不可能有那么大的力氣將一個火車給停下來的，只有火車自己才能完成這一動作，火車需要調(diào)用內(nèi)部的離合器和剎車片等多個器件協(xié)作才能完成剎車這個動作，司機(jī)剎車的過程只是給火車發(fā)了一個消息，通知火車要執(zhí)行剎車動作而已。

抽象：
抽象就是找出一些事物的相似和共性之處，然后將這些事物歸為一個類，這個類只考慮這些事物的相似和共性之處，并且會忽略與當(dāng)前主題和目標(biāo)無關(guān)的那些方面，將注意力集中在與當(dāng)前目標(biāo)有關(guān)的方面。例如，看到一只螞蟻和大象，你能夠想象出它們的相同之處，那就是抽象。抽象包括行為抽象和狀態(tài)抽象兩個方面。例如，定義一個Person類，如下：

class Person{
        String name;
        int age;
}

人本來是很復(fù)雜的事物，有很多方面，但因?yàn)楫?dāng)前系統(tǒng)只需要了解人的姓名和年齡，所以上面定義的類中只包含姓名和年齡這兩個屬性，這就是一種抽像，使用抽象可以避免考慮一些與目標(biāo)無關(guān)的細(xì)節(jié)。我對抽象的理解就是不要用顯微鏡去看一個事物的所有方面，這樣涉及的內(nèi)容就太多了，而是要善于劃分問題的邊界，當(dāng)前系統(tǒng)需要什么，就只考慮什么。

繼承：
在定義和實(shí)現(xiàn)一個類的時候，可以在一個已經(jīng)存在的類的基礎(chǔ)之上來進(jìn)行，把這個已經(jīng)存在的類所定義的內(nèi)容作為自己的內(nèi)容，并可以加入若干新的內(nèi)容，或修改原來的方法使之更適合特殊的需要，這就是繼承。繼承是子類自動共享父類數(shù)據(jù)和方法的機(jī)制，這是類之間的一種關(guān)系，提高了軟件的可重用性和可擴(kuò)展性。

多態(tài)：
多態(tài)是指程序中定義的引用變量所指向的具體類型和通過該引用變量發(fā)出的方法調(diào)用在編程時并不確定，而是在程序運(yùn)行期間才確定，即一個引用變量倒底會指向哪個類的實(shí)例對象，該引用變量發(fā)出的方法調(diào)用到底是哪個類中實(shí)現(xiàn)的方法，必須在由程序運(yùn)行期間才能決定。因?yàn)樵诔绦蜻\(yùn)行時才確定具體的類，這樣，不用修改源程序代碼，就可以讓引用變量綁定到各種不同的類實(shí)現(xiàn)上，從而導(dǎo)致該引用調(diào)用的具體方法隨之改變，即不修改程序代碼就可以改變程序運(yùn)行時所綁定的具體代碼，讓程序可以選擇多個運(yùn)行狀態(tài)，這就是多態(tài)性。多態(tài)性增強(qiáng)了軟件的靈活性和擴(kuò)展性。例如，下面代碼中的UserDao是一個接口，它定義引用變量userDao指向的實(shí)例對象由daofactory.getDao()在執(zhí)行的時候返回，有時候指向的是UserJdbcDao這個實(shí)現(xiàn)，有時候指向的是UserHibernateDao這個實(shí)現(xiàn)，這樣，不用修改源代碼，就可以改變userDao指向的具體類實(shí)現(xiàn)，從而導(dǎo)致userDao.insertUser()方法調(diào)用的具體代碼也隨之改變，即有時候調(diào)用的是UserJdbcDao的insertUser方法，有時候調(diào)用的是UserHibernateDao的insertUser方法：
UserDao userDao = daofactory.getDao(); userDao.insertUser(user);

比喻：人吃飯，你看到的是左手，還是右手？

23、java中實(shí)現(xiàn)多態(tài)的機(jī)制是什么？

靠的是父類或接口定義的引用變量可以指向子類或具體實(shí)現(xiàn)類的實(shí)例對象，而程序調(diào)用的方法在運(yùn)行期才動態(tài)綁定，就是引用變量所指向的具體實(shí)例對象的方法，也就是內(nèi)存里正在運(yùn)行的那個對象的方法，而不是引用變量的類型中定義的方法。

24、abstract class和interface有什么區(qū)別?

含有abstract修飾符的class即為抽象類，abstract 類不能創(chuàng)建的實(shí)例對象。含有abstract方法的類必須定義為abstract class，abstract class類中的方法不必是抽象的。abstract class類中定義抽象方法必須在具體(Concrete)子類中實(shí)現(xiàn)，所以，不能有抽象構(gòu)造方法或抽象靜態(tài)方法。如果的子類沒有實(shí)現(xiàn)抽象父類中的所有抽象方法，那么子類也必須定義為abstract類型。

接口（interface）可以說成是抽象類的一種特例，接口中的所有方法都必須是抽象的。接口中的方法定義默認(rèn)為public abstract類型，接口中的成員變量類型默認(rèn)為public static final。

下面比較一下兩者的語法區(qū)別：

1. 抽象類可以有構(gòu)造方法，接口中不能有構(gòu)造方法。
2. 抽象類中可以有普通成員變量，接口中沒有普通成員變量
3. 抽象類中可以包含非抽象的普通方法，接口中的所有方法必須都是抽象的，不能有非抽象的普通方法。
4. 抽象類中的抽象方法的訪問類型可以是public，protected和（默認(rèn)類型,雖然eclipse下不報錯，但應(yīng)該也不行），但接口中的抽象方法只能是public類型的，并且默認(rèn)即為public abstract類型。
5. 抽象類中可以包含靜態(tài)方法，接口中不能包含靜態(tài)方法
6. 抽象類和接口中都可以包含靜態(tài)成員變量，抽象類中的靜態(tài)成員變量的訪問類型可以任意，但接口中定義的變量只能是public static final類型，并且默認(rèn)即為public static final類型。
7. 一個類可以實(shí)現(xiàn)多個接口，但只能繼承一個抽象類。

下面接著再說說兩者在應(yīng)用上的區(qū)別：

接口更多的是在系統(tǒng)架構(gòu)設(shè)計方法發(fā)揮作用，主要用于定義模塊之間的通信契約。而抽象類在代碼實(shí)現(xiàn)方面發(fā)揮作用，可以實(shí)現(xiàn)代碼的重用，例如，模板方法設(shè)計模式是抽象類的一個典型應(yīng)用，假設(shè)某個項目的所有Servlet類都要用相同的方式進(jìn)行權(quán)限判斷、記錄訪問日志和處理異常，那么就可以定義一個抽象的基類，讓所有的Servlet都繼承這個抽象基類，在抽象基類的service方法中完成權(quán)限判斷、記錄訪問日志和處理異常的代碼，在各個子類中只是完成各自的業(yè)務(wù)邏輯代碼，偽代碼如下：

public abstract class BaseServlet extends HttpServlet{
        public final void service(HttpServletRequest request, HttpServletResponse response) throws IOExcetion,ServletException  {
            記錄訪問日志
            進(jìn)行權(quán)限判斷
if(具有權(quán)限){
    try{
        doService(request,response);
}
    catch(Excetpion e)  {
            記錄異常信息
    }
}
        } 
        protected abstract void doService(HttpServletRequest request, HttpServletResponse response) throws IOExcetion,ServletException;  
//注意訪問權(quán)限定義成protected，顯得既專業(yè)，又嚴(yán)謹(jǐn)，因?yàn)樗菍ｉT給子類用的
}

public class MyServlet1 extends BaseServlet
{
protected void doService(HttpServletRequest request, HttpServletResponse response) throws IOExcetion,ServletException
        {
            本Servlet只處理的具體業(yè)務(wù)邏輯代碼
        } 

}

父類方法中間的某段代碼不確定，留給子類干，就用模板方法設(shè)計模式。

備注：這道題的思路是先從總體解釋抽象類和接口的基本概念，然后再比較兩者的語法細(xì)節(jié)，最后再說兩者的應(yīng)用區(qū)別。比較兩者語法細(xì)節(jié)區(qū)別的條理是：先從一個類中的構(gòu)造方法、普通成員變量和方法（包括抽象方法），靜態(tài)變量和方法，繼承性等6個方面逐一去比較回答，接著從第三者繼承的角度的回答，特別是最后用了一個典型的例子來展現(xiàn)自己深厚的技術(shù)功底。

25、abstract的method是否可同時是static,是否可同時是native，是否可同時是synchronized?

abstract的method 不可以是static的，因?yàn)槌橄蟮姆椒ㄊ且蛔宇悓?shí)現(xiàn)的，而static與子類扯不上關(guān)系！

native方法表示該方法要用另外一種依賴平臺的編程語言實(shí)現(xiàn)的，不存在著被子類實(shí)現(xiàn)的問題，所以，它也不能是抽象的，不能與abstract混用。例如，F(xiàn)ileOutputSteam類要硬件打交道，底層的實(shí)現(xiàn)用的是操作系統(tǒng)相關(guān)的api實(shí)現(xiàn)，例如，在windows用c語言實(shí)現(xiàn)的，所以，查看jdk 的源代碼，可以發(fā)現(xiàn)FileOutputStream的open方法的定義如下：

private native void open(String name) throws FileNotFoundException;

如果我們要用java調(diào)用別人寫的c語言函數(shù)，我們是無法直接調(diào)用的，我們需要按照java的要求寫一個c語言的函數(shù)，又我們的這個c語言函數(shù)去調(diào)用別人的c語言函數(shù)。由于我們的c語言函數(shù)是按java的要求來寫的，我們這個c語言函數(shù)就可以與java對接上，java那邊的對接方式就是定義出與我們這個c函數(shù)相對應(yīng)的方法，java中對應(yīng)的方法不需要寫具體的代碼，但需要在前面聲明native。

關(guān)于synchronized與abstract合用的問題，我覺得也不行，因?yàn)樵谖規(guī)啄甑膶W(xué)習(xí)和開發(fā)中，從來沒見到過這種情況，并且我覺得synchronized應(yīng)該是作用在一個具體的方法上才有意義。而且，方法上的synchronized同步所使用的同步鎖對象是this，而抽象方法上無法確定this是什么。

26、什么是內(nèi)部類？Static Nested Class 和 Inner Class的不同。

內(nèi)部類就是在一個類的內(nèi)部定義的類，內(nèi)部類中不能定義靜態(tài)成員（靜態(tài)成員不是對象的特性，只是為了找一個容身之處，所以需要放到一個類中而已，這么一點(diǎn)小事，你還要把它放到類內(nèi)部的一個類中，過分了啊！提供內(nèi)部類，不是為讓你干這種事情，無聊，不讓你干。我想可能是既然靜態(tài)成員類似c語言的全局變量，而內(nèi)部類通常是用于創(chuàng)建內(nèi)部對象用的，所以，把“全局變量”放在內(nèi)部類中就是毫無意義的事情，既然是毫無意義的事情，就應(yīng)該被禁止），內(nèi)部類可以直接訪問外部類中的成員變量，內(nèi)部類可以定義在外部類的方法外面，也可以定義在外部類的方法體中，如下所示：

public class Outer
{
        int out_x  = 0;
        public void method()
        {
            Inner1 inner1 = new Inner1();
            public class Inner2   //在方法體內(nèi)部定義的內(nèi)部類
            {
                public method()
                {
                    out_x = 3;
                }
            }
            Inner2 inner2 = new Inner2();
        }

        public class Inner1   //在方法體外面定義的內(nèi)部類
        {
        }

}

在方法體外面定義的內(nèi)部類的訪問類型可以是public,protecte,默認(rèn)的，private等4種類型，這就好像類中定義的成員變量有4種訪問類型一樣，它們決定這個內(nèi)部類的定義對其他類是否可見；對于這種情況，我們也可以在外面創(chuàng)建內(nèi)部類的實(shí)例對象，創(chuàng)建內(nèi)部類的實(shí)例對象時，一定要先創(chuàng)建外部類的實(shí)例對象，然后用這個外部類的實(shí)例對象去創(chuàng)建內(nèi)部類的實(shí)例對象，代碼如下：

Outer outer = new Outer();
Outer.Inner1 inner1 = outer.new Innner1();

在方法內(nèi)部定義的內(nèi)部類前面不能有訪問類型修飾符，就好像方法中定義的局部變量一樣，但這種內(nèi)部類的前面可以使用final或abstract修飾符。這種內(nèi)部類對其他類是不可見的其他類無法引用這種內(nèi)部類，但是這種內(nèi)部類創(chuàng)建的實(shí)例對象可以傳遞給其他類訪問。這種內(nèi)部類必須是先定義，后使用，即內(nèi)部類的定義代碼必須出現(xiàn)在使用該類之前，這與方法中的局部變量必須先定義后使用的道理也是一樣的。這種內(nèi)部類可以訪問方法體中的局部變量，但是，該局部變量前必須加final修飾符。

對于這些細(xì)節(jié)，只要在eclipse寫代碼試試，根據(jù)開發(fā)工具提示的各類錯誤信息就可以馬上了解到。

在方法體內(nèi)部還可以采用如下語法來創(chuàng)建一種匿名內(nèi)部類，即定義某一接口或類的子類的同時，還創(chuàng)建了該子類的實(shí)例對象，無需為該子類定義名稱：

public class Outer
{
        public void start()
        {
            new Thread(
new Runable(){
                    public void run(){};
}
).start();
        }
}

最后，在方法外部定義的內(nèi)部類前面可以加上static關(guān)鍵字，從而成為Static Nested Class，它不再具有內(nèi)部類的特性，所有，從狹義上講，它不是內(nèi)部類。Static Nested Class與普通類在運(yùn)行時的行為和功能上沒有什么區(qū)別，只是在編程引用時的語法上有一些差別，它可以定義成public、protected、默認(rèn)的、private等多種類型，而普通類只能定義成public和默認(rèn)的這兩種類型。在外面引用Static Nested Class類的名稱為“外部類名.內(nèi)部類名”。在外面不需要創(chuàng)建外部類的實(shí)例對象，就可以直接創(chuàng)建Static Nested Class，例如，假設(shè)Inner是定義在Outer類中的Static Nested Class，那么可以使用如下語句創(chuàng)建Inner類：

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

由于static Nested Class不依賴于外部類的實(shí)例對象，所以，static Nested Class能訪問外部類的非static成員變量。當(dāng)在外部類中訪問Static Nested Class時，可以直接使用Static Nested Class的名字，而不需要加上外部類的名字了，在Static Nested Class中也可以直接引用外部類的static的成員變量，不需要加上外部類的名字。

在靜態(tài)方法中定義的內(nèi)部類也是Static Nested Class，這時候不能在類前面加static關(guān)鍵字，靜態(tài)方法中的Static Nested Class與普通方法中的內(nèi)部類的應(yīng)用方式很相似，它除了可以直接訪問外部類中的static的成員變量，還可以訪問靜態(tài)方法中的局部變量，但是，該局部變量前必須加final修飾符。

備注：首先根據(jù)你的印象說出你對內(nèi)部類的總體方面的特點(diǎn)：例如，在兩個地方可以定義，可以訪問外部類的成員變量，不能定義靜態(tài)成員，這是大的特點(diǎn)。然后再說一些細(xì)節(jié)方面的知識，例如，幾種定義方式的語法區(qū)別，靜態(tài)內(nèi)部類，以及匿名內(nèi)部類。

27、內(nèi)部類可以引用它的包含類的成員嗎？有沒有什么限制？

完全可以。如果不是靜態(tài)內(nèi)部類，那沒有什么限制！
如果你把靜態(tài)嵌套類當(dāng)作內(nèi)部類的一種特例，那在這種情況下不可以訪問外部類的普通成員變量，而只能訪問外部類中的靜態(tài)成員，例如，下面的代碼：

class Outer
{
    static int x;
    static class Inner
    {
        void test()
        {
            syso(x);
        }
    }
}

答題時，也要能察言觀色，揣摩提問者的心思，顯然人家希望你說的是靜態(tài)內(nèi)部類不能訪問外部類的成員，但你一上來就頂牛，這不好，要先順著人家，讓人家滿意，然后再說特殊情況，讓人家吃驚。

28、Anonymous Inner Class (匿名內(nèi)部類) 是否可以extends(繼承)其它類，是否可以implements(實(shí)現(xiàn))interface(接口)?

可以繼承其他類或?qū)崿F(xiàn)其他接口。不僅是可以，而是必須!

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

基本數(shù)據(jù)類型包括byte、int、char、long、float、double、boolean和short。

java.lang.String類是final類型的，因此不可以繼承這個類、不能修改這個類。為了提高效率節(jié)省空間，我們應(yīng)該用StringBuffer類

30、Java 中怎么獲取一份線程 dump 文件？

在 Linux 下，你可以通過命令 kill -3 PID （Java 進(jìn)程的進(jìn)程 ID）來獲取 Java應(yīng)用的 dump 文件。在 Windows 下，你可以按下 Ctrl + Break 來獲取。這樣 JVM 就會將線程的 dump 文件打印到標(biāo)準(zhǔn)輸出或錯誤文件中，它可能打印在控制臺或者日志文件中，具體位置依賴應(yīng)用的配置。如果你使用 Tomcat。

31、String?s?=?"Hello";s?=?s?+?"?world!";這兩行代碼執(zhí)行后，原始的String對象中的內(nèi)容到底變了沒有？

沒有。因?yàn)镾tring被設(shè)計成不可變(immutable)類，所以它的所有對象都是不可變對象。在這段代碼中，s原先指向一個String對象，內(nèi)容是 "Hello"，然后我們對s進(jìn)行了+操作，那么s所指向的那個對象是否發(fā)生了改變呢？答案是沒有。這時，s不指向原來那個對象了，而指向了另一個 String對象，內(nèi)容為"Hello?world!"，原來那個對象還存在于內(nèi)存之中，只是s這個引用變量不再指向它了。

通過上面的說明，我們很容易導(dǎo)出另一個結(jié)論，如果經(jīng)常對字符串進(jìn)行各種各樣的修改，或者說，不可預(yù)見的修改，那么使用String來代表字符串的話會引起很大的內(nèi)存開銷。因?yàn)?String對象建立之后不能再改變，所以對于每一個不同的字符串，都需要一個String對象來表示。這時，應(yīng)該考慮使用StringBuffer類，它允許修改，而不是每個不同的字符串都要生成一個新的對象。并且，這兩種類的對象轉(zhuǎn)換十分容易。

同時，我們還可以知道，如果要使用內(nèi)容相同的字符串，不必每次都new一個String。例如我們要在構(gòu)造器中對一個名叫s的String引用變量進(jìn)行初始化，把它設(shè)置為初始值，應(yīng)當(dāng)這樣做：

public?class?Demo?{
private?String?s;
...
public?Demo?{
s?=?"Initial?Value";
}
...
}

而非

s?=?new?String("Initial?Value");

后者每次都會調(diào)用構(gòu)造器，生成新對象，性能低下且內(nèi)存開銷大，并且沒有意義，因?yàn)镾tring對象不可改變，所以對于內(nèi)容相同的字符串，只要一個String對象來表示就可以了。也就說，多次調(diào)用上面的構(gòu)造器創(chuàng)建多個對象，他們的String類型屬性s都指向同一個對象。

上面的結(jié)論還基于這樣一個事實(shí)：對于字符串常量，如果內(nèi)容相同，Java認(rèn)為它們代表同一個String對象。而用關(guān)鍵字new調(diào)用構(gòu)造器，總是會創(chuàng)建一個新的對象，無論內(nèi)容是否相同。

至于為什么要把String類設(shè)計成不可變類，是它的用途決定的。其實(shí)不只String，很多Java標(biāo)準(zhǔn)類庫中的類都是不可變的。在開發(fā)一個系統(tǒng)的時候，我們有時候也需要設(shè)計不可變類，來傳遞一組相關(guān)的值，這也是面向?qū)ο笏枷氲捏w現(xiàn)。不可變類有一些優(yōu)點(diǎn)，比如因?yàn)樗膶ο笫侵蛔x的，所以多線程并發(fā)訪問也不會有任何問題。當(dāng)然也有一些缺點(diǎn)，比如每個不同的狀態(tài)都要一個對象來代表，可能會造成性能上的問題。所以Java標(biāo)準(zhǔn)類庫還提供了一個可變版本，即 StringBuffer。

32、是否可以繼承String類?

String類是final類故不可以繼承。

33、String s = new String("xyz");創(chuàng)建了幾個String Object? 二者之間有什么區(qū)別？

兩個或一個，”xyz”對應(yīng)一個對象，這個對象放在字符串常量緩沖區(qū)，常量”xyz”不管出現(xiàn)多少遍，都是緩沖區(qū)中的那一個。New String每寫一遍，就創(chuàng)建一個新的對象，它一句那個常量”xyz”對象的內(nèi)容來創(chuàng)建出一個新String對象。如果以前就用過’xyz’，這句代表就不會創(chuàng)建”xyz”自己了，直接從緩沖區(qū)拿。

34、String 和StringBuffer的區(qū)別

JAVA平臺提供了兩個類：String和StringBuffer，它們可以儲存和操作字符串，即包含多個字符的字符數(shù)據(jù)。這個String類提供了數(shù)值不可改變的字符串。而這個StringBuffer類提供的字符串進(jìn)行修改。當(dāng)你知道字符數(shù)據(jù)要改變的時候你就可以使用StringBuffer。典型地，你可以使用StringBuffers來動態(tài)構(gòu)造字符數(shù)據(jù)。另外，String實(shí)現(xiàn)了equals方法，new String(“abc”).equals(new String(“abc”)的結(jié)果為true,而StringBuffer沒有實(shí)現(xiàn)equals方法，所以，new StringBuffer(“abc”).equals(new StringBuffer(“abc”)的結(jié)果為false。

接著要舉一個具體的例子來說明，我們要把1到100的所有數(shù)字拼起來，組成一個串。

StringBuffer sbf = new StringBuffer();  
for(int i=0;i<100;i++)
{
    sbf.append(i);
}

上面的代碼效率很高，因?yàn)橹粍?chuàng)建了一個StringBuffer對象，而下面的代碼效率很低，因?yàn)閯?chuàng)建了101個對象。

String str = new String();  
for(int i=0;i<100;i++)
{
    str = str + i;
}

在講兩者區(qū)別時，應(yīng)把循環(huán)的次數(shù)搞成10000，然后用endTime-beginTime來比較兩者執(zhí)行的時間差異，最后還要講講StringBuilder與StringBuffer的區(qū)別。

String覆蓋了equals方法和hashCode方法，而StringBuffer沒有覆蓋equals方法和hashCode方法，所以，將StringBuffer對象存儲進(jìn)Java集合類中時會出現(xiàn)問題。

第一條語句打印的結(jié)果為false，第二條語句打印的結(jié)果為true，這說明javac編譯可以對字符串常量直接相加的表達(dá)式進(jìn)行優(yōu)化，不必要等到運(yùn)行期去進(jìn)行加法運(yùn)算處理，而是在編譯時去掉其中的加號，直接將其編譯成一個這些常量相連的結(jié)果。

題目中的第一行代碼被編譯器在編譯時優(yōu)化后，相當(dāng)于直接定義了一個”abcd”的字符串，所以，上面的代碼應(yīng)該只創(chuàng)建了一個String對象。寫如下兩行代碼，

        String s = "a" + "b" + "c" + "d";
        System.out.println(s == "abcd");

最終打印的結(jié)果應(yīng)該為true。

38、try {}里有一個return語句，那么緊跟在這個try后的finally {}里的code會不會被執(zhí)行，什么時候被執(zhí)行，在return前還是后?

也許你的答案是在return之前，但往更細(xì)地說，我的答案是在return中間執(zhí)行，請看下面程序代碼的運(yùn)行結(jié)果：

public  class Test {

    /**
     * @param args add by zxx ,Dec 9, 2008
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        System.out.println(new Test().test());;
    }

    static int test()
    {
        int x = 1;
        try
        {
            return x;
        }
        finally
        {
            ++x;
        }
    }

}

---------執(zhí)行結(jié)果 ---------
1

運(yùn)行結(jié)果是1，為什么呢？主函數(shù)調(diào)用子函數(shù)并得到結(jié)果的過程，好比主函數(shù)準(zhǔn)備一個空罐子，當(dāng)子函數(shù)要返回結(jié)果時，先把結(jié)果放在罐子里，然后再將程序邏輯返回到主函數(shù)。所謂返回，就是子函數(shù)說，我不運(yùn)行了，你主函數(shù)繼續(xù)運(yùn)行吧，這沒什么結(jié)果可言，結(jié)果是在說這話之前放進(jìn)罐子里的。

39、下面的程序代碼輸出的結(jié)果是多少？

public class  smallT
{
    public static void  main(String args[])
    {
        smallT t  = new  smallT();
        int  b  =  t.get();
        System.out.println(b);
    }

    public int  get()
    {
        try
        {
            return 1 ;
        }
        finally
        {
            return 2 ;
        }
    }
}

返回的結(jié)果是2。

我可以通過下面一個例子程序來幫助我解釋這個答案，從下面例子的運(yùn)行結(jié)果中可以發(fā)現(xiàn)，try中的return語句調(diào)用的函數(shù)先于finally中調(diào)用的函數(shù)執(zhí)行，也就是說return語句先執(zhí)行，finally語句后執(zhí)行，所以，返回的結(jié)果是2。Return并不是讓函數(shù)馬上返回，而是return語句執(zhí)行后，將把返回結(jié)果放置進(jìn)函數(shù)棧中，此時函數(shù)并不是馬上返回，它要執(zhí)行finally語句后才真正開始返回。

在講解答案時可以用下面的程序來幫助分析：

public  class Test {

    /**
     * @param args add by zxx ,Dec 9, 2008
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        System.out.println(new Test().test());;
    }

    int test()
    {
        try
        {
            return func1();
        }
        finally
        {
            return func2();
        }
    }

    int func1()
    {
        System.out.println("func1");
        return 1;
    }
    int func2()
    {
        System.out.println("func2");
        return 2;
    }   
}
-----------執(zhí)行結(jié)果-----------------

func1
func2
2

結(jié)論：finally中的代碼比return 和break語句后執(zhí)行

40、final, finally, finalize的區(qū)別

final 用于聲明屬性，方法和類，分別表示屬性不可變，方法不可覆蓋，類不可繼承。
內(nèi)部類要訪問局部變量，局部變量必須定義成final類型，例如，一段代碼……

finally是異常處理語句結(jié)構(gòu)的一部分，表示總是執(zhí)行。

finalize是Object類的一個方法，在垃圾收集器執(zhí)行的時候會調(diào)用被回收對象的此方法，可以覆蓋此方法提供垃圾收集時的其他資源回收，例如關(guān)閉文件等。JVM不保證此方法總被調(diào)用

41、運(yùn)行時異常與一般異常有何異同？

異常表示程序運(yùn)行過程中可能出現(xiàn)的非正常狀態(tài)，運(yùn)行時異常表示虛擬機(jī)的通常操作中可能遇到的異常，是一種常見運(yùn)行錯誤。java編譯器要求方法必須聲明拋出可能發(fā)生的非運(yùn)行時異常，但是并不要求必須聲明拋出未被捕獲的運(yùn)行時異常。

因文章篇幅的問題，本文分（一）（二）兩篇進(jìn)行講解，知識點(diǎn)很詳細(xì)，可盡情享受，另外我這邊也整理了一些知識點(diǎn)筆記及對應(yīng)的面試題，有需要的可以進(jìn)我的Java學(xué)習(xí)交流群：909666042免費(fèi)獲取

部分資料圖分享

更多筆記分享

向AI問一下細(xì)節(jié)