JAVA面試精選【Java基礎第一部分】

時間 2019-12-11

原文原文鏈接

　　這個系列面試題主要目的是幫助你拿輕鬆到offer，同時還能開個好價錢。只要可以搞明白這個系列的絕大多數題目，在面試過程當中，你就能輕輕鬆鬆的把面試官給忽悠了。對於那些正打算找工做JAVA軟件開發工做的童鞋們來講，當你看到這份題目的時候，你應該感動很幸運，由於，只要你把題目中的內容都搞懂了，在筆試的時候就能夠遊刃有餘，經過面試只有半步之遙了，筆試只能反映你的JAVA技能。無論你是面試各個級別的JAVA工程師、架構師、仍是項目經理，這個系列文章都是你最寶貴的資源，裏面包括整個JAVA體系的知識，總會有你須要的內容。我會將這些面試題目經過文章的形式不斷完善，若是你有更好的資料也能夠共享出來，分享給碼農大衆們，作程序猿不容易，特別是在當今社會，沒房，沒車，沒票子，就等於沒女人，苦逼的程序猿，要想得到一份好工做，還得過三關斬六將。java

　　因爲JAVA面試試題涉及的範圍很泛，很廣，很雜，並且JAVA技術也在不斷的更新換代，因此咱們將不定時的對文章進行完善，就目前這些題目，不可能一天兩天就看完和學完這套面試寶典，即便你已經學過了有關的技術，那麼至少也須要一段時間才能消化和掌握這套面試題目，因此，你們應該早做準備，天天看一點，不斷的積累，從打算找工做之日起，就要堅持在天天閒暇之餘學習其中幾道題目，日積月累，等到出去面試時，一切都水到渠成，面試時就天然會遊刃有餘了。程序員

　　答題時，先答是什麼，再答有什麼做用和要注意什麼，這裏給人的感受作事有條理，理解東西比較透徹，答案的段落分別，井井有條，條理清晰都很是重要，從這些表面的東西也能夠看出一我的的習慣、辦事風格、條理等。要講你作出答案的思路過程，或者說你記住答案的思想都寫下來。把答題想着是辯論賽。答題就是給別人講道理、擺事實。答題不侷限於什麼格式和形式，就是要將本身的學識展示出來！別由於人家題目原本就模棱兩可，你就內心膽怯和沒底氣了，不敢回答了。你要大膽地指出對方題目很模糊和你的觀點，不要把面試官想得有多高，其實他和你就是差很少的，你想一想，若是他把你招進去了，大家之後就是同事了，可不是差很少的嗎？web

　　關於就業薪水，若是你是應屆生，那不能要高工資，比如大餅的故事，沒有文憑還想拿高工資，就去中關村缺什麼補什麼吧！少數人基礎確實很好，在校期間確實又作過一些項目，那仍然是能夠要到相對高的工資的。面試

　　Java基礎部分正則表達式

　　基礎部分的順序：基本語法，類相關的語法，內部類的語法，繼承相關的語法，異常的語法，線程的語法，集合的語法，io的語法，虛擬機方面的語法。算法

1、一個".java"源文件中是否能夠包括多個類（不是內部類）？有什麼限制？編程

能夠有多個類，但只能有一個public的類，而且public的類名必須與文件名相一致。windows

2、Java有沒有goto?設計模式

java中的保留字，如今沒有在java中使用。api

3、說說&和&&的區別。

&和&&均可以用做邏輯與的運算符，表示邏輯與（and），當運算符兩邊的表達式的結果都爲true時，整個運算結果才爲true，不然，只要有一方爲false，則結果爲false。

&&還具備短路的功能，即若是第一個表達式爲false，則再也不計算第二個表達式，例如，對於if(str != null&& !str.equals(「」))表達式，當str爲null時，後面的表達式不會執行，因此不會出現NullPointerException若是將&&改成&，則會拋出NullPointerException異常。If(x==33 &++y>0) y會增加，If(x==33 && ++y>0)不會增加

&還能夠用做位運算符，當&操做符兩邊的表達式不是boolean類型時，&表示按位與操做，咱們一般使用0x0f來與一個整數進行&運算，來獲取該整數的最低4個bit位，例如，0x31 & 0x0f的結果爲0x01。

備註：這道題先說二者的共同點，再說出&&和&的特殊之處，並列舉一些經典的例子來代表本身理解透徹深刻、實際經驗豐富。

4、在JAVA中如何跳出當前的多重嵌套循環？

在Java中，要想跳出多重循環，能夠在外面的循環語句前定義一個標號，而後在裏層循環體的代碼中使用帶有標號的break語句，便可跳出外層循環。例如，

ok:

for(int i=0;i<10;i++) {

for(int j=0;j<10;j++) {

System.out.println(「i=」 + i + 「,j=」 + j);

if(j == 5) break ok;

}

另外，我我的一般並不使用標號這種方式，而是讓外層的循環條件表達式的結果能夠受到裏層循環體代碼的控制，例如，要在二維數組中查找到某個數字。

int arr[][] ={{1,2,3},{4,5,6,7},{9}};

boolean found = false;

for(int i=0;i<arr.length&& !found;i++) {

for(int j=0;j<arr[i].length;j++){

System.out.println(「i=」 + i + 「,j=」 + j);

if(arr[i][j] ==5) {

found = true;

break;

}

5、switch語句可否做用在byte上，可否做用在long上，可否做用在String上?

在switch（expr1）中，expr1只能是一個整數表達式或者枚舉常量（更大字體），整數表達式能夠是int基本類型或Integer包裝類型，因爲，byte,short,char均可以隱含轉換爲int，因此，這些類型以及這些類型的包裝類型也是能夠的。顯然，long和String類型都不符合switch的語法規定，而且不能被隱式轉換成int類型，因此，它們不能做用於swtich語句中。

6、short s1 = 1; s1 = s1 + 1;有什麼錯? short s1 = 1; s1 += 1;有什麼錯?

對於short s1 = 1; s1 = s1 + 1;因爲s1+1運算時會自動提高表達式的類型，因此結果是int型，再賦值給short類型s1時，編譯器將報告須要強制轉換類型的錯誤。

對於short s1 = 1; s1 += 1;因爲 +=是java語言規定的運算符，java編譯器會對它進行特殊處理，所以能夠正確編譯。

7、char型變量中能不能存貯一箇中文漢字?爲何?

char型變量是用來存儲Unicode編碼的字符的，unicode編碼字符集中包含了漢字，因此，char型變量中固然能夠存儲漢字啦。不過，若是某個特殊的漢字沒有被包含在unicode編碼字符集中，那麼，這個char型變量中就不能存儲這個特殊漢字。補充說明：unicode編碼佔用兩個字節，因此，char類型的變量也是佔用兩個字節。

備註：後面一部分回答雖然不是在正面回答題目，可是，爲了展示本身的學識和表現本身對問題理解的透徹深刻，能夠回答一些相關的知識，作到知無不言，言無不盡。

8、用最有效率的方法算出2乘以8等於幾?

2 << 3，

由於將一個數左移n位，就至關於乘以了2的n次方，那麼，一個數乘以8只要將其左移3位便可，而位運算cpu直接支持的，效率最高，因此，2乘以8等於幾的最效率的方法是2 << 3。

9、請設計一個一百億的計算器

首先要明白這道題目的考查點是什麼，一是你們首先要對計算機原理的底層細節要清楚、要知道加減法的位運算原理和知道計算機中的算術運算會發生越界的狀況，二是要具有必定的面向對象的設計思想。

首先，計算機中用固定數量的幾個字節來存儲的數值，因此計算機中可以表示的數值是有必定的範圍的，爲了便於講解和理解，咱們先以byte類型的整數爲例，它用1個字節進行存儲，表示的最大數值範圍爲-128到+127。-1在內存中對應的二進制數據爲11111111，若是兩個-1相加，不考慮Java運算時的類型提高，運算後會產生進位，二進制結果爲1,11111110，因爲進位後超過了byte類型的存儲空間，因此進位部分被捨棄，即最終的結果爲11111110，也就是-2，這正好利用溢位的方式實現了負數的運算。-128在內存中對應的二進制數據爲10000000，若是兩個-128相加，不考慮Java運算時的類型提高，運算後會產生進位，二進制結果爲1,00000000，因爲進位後超過了byte類型的存儲空間，因此進位部分被捨棄，即最終的結果爲00000000，也就是0，這樣的結果顯然不是咱們指望的，這說明計算機中的算術運算是會發生越界狀況的，兩個數值的運算結果不能超過計算機中的該類型的數值範圍。因爲Java中涉及表達式運算時的類型自動提高，咱們沒法用byte類型來作演示這種問題和現象的實驗，你們能夠用下面一個使用整數作實驗的例子程序體驗一下：

int a = Integer.MAX_VALUE;

int b = Integer.MAX_VALUE;

int sum = a + b;

System.out.println(「a=」+a+」,b=」+b+」,sum=」+sum);

先不考慮long類型，因爲int的正數範圍爲2的31次方，表示的最大數值約等於2*1000*1000*1000，也就是20億的大小，因此，要實現一個一百億的計算器，咱們得本身設計一個類能夠用於表示很大的整數，而且提供了與另一個整數進行加減乘除的功能，大概功能以下：

（1）這個類內部有兩個成員變量，一個表示符號，另外一個用字節數組表示數值的二進制數

（2）有一個構造方法，把一個包含有多位數值的字符串轉換到內部的符號和字節數組中

（3）提供加減乘除的功能

public class BigInteger{

int sign;

byte[] val;

public Biginteger(String val) {

sign = ;

val = ;

}

public BigInteger add(BigInteger other) {

}

public BigInteger subtract(BigInteger other) {

}

public BigInteger multiply(BigInteger other){

}

public BigInteger divide(BigInteger other){

}

備註：要想寫出這個類的完整代碼，是很是複雜的，若是有興趣的話，能夠參看jdk中自帶的java.math.BigInteger類的源碼。面試的人也知道誰都不可能在短期內寫出這個類的完整代碼的，他要的是你是否有這方面的概念和意識，他最重要的仍是考查你的能力，因此，你不要由於本身沒法寫出完整的最終結果就放棄答這道題，你要作的就是你比別人寫得多，證實你比別人強，你有這方面的思想意識就能夠了，畢竟別人可能連題目的意思都看不懂，什麼都沒寫，你要勇於答這道題，即便只答了一部分，那也與那些什麼都不懂的人區別出來，拉開了距離，算是矮子中的高個，機會固然就屬於你了。另外，答案中的框架代碼也很重要，體現了一些面向對象設計的功底，特別是其中的方法命名很專業，用的英文單詞很精準，這也是能力、經驗、專業性、英語水平等多個方面的體現，會給人留下很好的印象，在編程能力和其餘方面條件差很少的狀況下，英語好除了能夠使你得到更多機會外，薪水能夠高出一千元。

10、使用final關鍵字修飾一個變量時，是引用不能變，仍是引用的對象不能變？

使用final關鍵字修飾一個變量時，是指引用變量不能變，引用變量所指向的對象中的內容仍是能夠改變的。例如，對於以下語句：

final StringBuffer a=new StringBuffer("immutable");
執行以下語句將報告編譯期錯誤：

a=new StringBuffer("");
可是，執行以下語句則能夠經過編譯：

a.append(" broken!");

有人在定義方法的參數時，可能想採用以下形式來阻止方法內部修改傳進來的參數對象：

public void method(final StringBuffer param){

}

實際上，這是辦不到的，在該方法內部仍然能夠增長以下代碼來修改參數對象：

param.append("a");

11、"=="和equals方法究竟有什麼區別？

（單獨把一個東西說清楚，而後再說清楚另外一個，這樣，它們的區別天然就出來了，混在一塊兒說，則很難說清楚）

==操做符專門用來比較兩個變量的值是否相等，也就是用於比較變量所對應的內存中所存儲的數值是否相同，要比較兩個基本類型的數據或兩個引用變量是否相等，只能用==操做符。

若是一個變量指向的數據是對象類型的，那麼，這時候涉及了兩塊內存，對象自己佔用一塊內存（堆內存），變量也佔用一塊內存，例如Objet obj = new Object();變量obj是一個內存，new Object()是另外一個內存，此時，變量obj所對應的內存中存儲的數值就是對象佔用的那塊內存的首地址。對於指向對象類型的變量，若是要比較兩個變量是否指向同一個對象，即要看這兩個變量所對應的內存中的數值是否相等，這時候就須要用==操做符進行比較。

equals方法是用於比較兩個獨立對象的內容是否相同，就比如去比較兩我的的長相是否相同，它比較的兩個對象是獨立的。例如，對於下面的代碼：

String a=new String("foo");

String b=new String("foo");

兩條new語句建立了兩個對象，而後用a/b這兩個變量分別指向了其中一個對象，這是兩個不一樣的對象，它們的首地址是不一樣的，即a和b中存儲的數值是不相同的，因此，表達式a==b將返回false，而這兩個對象中的內容是相同的，因此，表達式a.equals(b)將返回true。

在實際開發中，咱們常常要比較傳遞進行來的字符串內容是否等，例如，String input = …;input.equals(「quit」)，許多人稍不注意就使用==進行比較了，這是錯誤的，隨便從網上找幾個項目實戰的教學視頻看看，裏面就有大量這樣的錯誤。記住，字符串的比較基本上都是使用equals方法。

若是一個類沒有本身定義equals方法，那麼它將繼承Object類的equals方法，Object類的equals方法的實現代碼以下：

boolean equals(Object o){

return this==o;

}

這說明，若是一個類沒有本身定義equals方法，它默認的equals方法（從Object類繼承的）就是使用==操做符，也是在比較兩個變量指向的對象是不是同一對象，這時候使用equals和使用==會獲得一樣的結果，若是比較的是兩個獨立的對象則總返回false。若是你編寫的類但願可以比較該類建立的兩個實例對象的內容是否相同，那麼你必須覆蓋equals方法，由你本身寫代碼來決定在什麼狀況便可認爲兩個對象的內容是相同的。

12、靜態變量和實例變量的區別？

在語法定義上的區別：靜態變量前要加static關鍵字，而實例變量前則不加。

在程序運行時的區別：實例變量屬於某個對象的屬性，必須建立了實例對象，其中的實例變量纔會被分配空間，才能使用這個實例變量。靜態變量不屬於某個實例對象，而是屬於類，因此也稱爲類變量，只要程序加載了類的字節碼，不用建立任何實例對象，靜態變量就會被分配空間，靜態變量就能夠被使用了。總之，實例變量必須建立對象後才能夠經過這個對象來使用，靜態變量則能夠直接使用類名來引用。

例如，對於下面的程序，不管建立多少個實例對象，永遠都只分配了一個staticVar變量，而且每建立一個實例對象，這個staticVar就會加1；可是，每建立一個實例對象，就會分配一個instanceVar，便可能分配多個instanceVar，而且每一個instanceVar的值都只自加了1次。

public class VariantTest{

public static int staticVar = 0;

public int instanceVar = 0;

public VariantTest(){

staticVar++;

instanceVar++;

System.out.println(「staticVar=」 + staticVar + 」,instanceVar=」+ instanceVar);

}

備註：這個解答除了說清楚二者的區別外，最後還用一個具體的應用例子來講明二者的差別，體現了本身有很好的解說問題和設計案例的能力，思惟敏捷，超過通常程序員，有寫做能力！

13、是否能夠從一個static方法內部發出對非static方法的調用？

不能夠。由於非static方法是要與對象關聯在一塊兒的，必須建立一個對象後，才能夠在該對象上進行方法調用，而static方法調用時不須要建立對象，能夠直接調用。也就是說，當一個static方法被調用時，可能尚未建立任何實例對象，若是從一個static方法中發出對非static方法的調用，那個非static方法是關聯到哪一個對象上的呢？這個邏輯沒法成立，因此，一個static方法內部發出對非static方法的調用。

14、Integer與int的區別

int是java提供的8種原始數據類型之一。Java爲每一個原始類型提供了封裝類，Integer是java爲int提供的封裝類。int的默認值爲0，而Integer的默認值爲null，即Integer能夠區分出未賦值和值爲0的區別，int則沒法表達出未賦值的狀況，例如，要想表達出沒有參加考試和考試成績爲0的區別，則只能使用Integer。在JSP開發中，Integer的默認爲null，因此用el表達式在文本框中顯示時，值爲空白字符串，而int默認的默認值爲0，因此用el表達式在文本框中顯示時，結果爲0，因此，int不適合做爲web層的表單數據的類型。

在Hibernate中，若是將OID定義爲Integer類型，那麼Hibernate就能夠根據其值是否爲null而判斷一個對象是不是臨時的，若是將OID定義爲了int類型，還須要在hbm映射文件中設置其unsaved-value屬性爲0。

另外，Integer提供了多個與整數相關的操做方法，例如，將一個字符串轉換成整數，Integer中還定義了表示整數的最大值和最小值的常量。

15、Math.round(11.5)等於多少? Math.round(-11.5)等於多少?

Math類中提供了三個與取整有關的方法：ceil、floor、round，這些方法的做用與它們的英文名稱的含義相對應，例如，ceil的英文意義是天花板，該方法就表示向上取整，Math.ceil(11.3)的結果爲12,Math.ceil(-11.3)的結果是-11；floor的英文意義是地板，該方法就表示向下取整，Math.ceil(11.6)的結果爲11,Math.ceil(-11.6)的結果是-12；最難掌握的是round方法，它表示「四捨五入」，算法爲Math.floor(x+0.5)，即將原來的數字加上0.5後再向下取整，因此，Math.round(11.5)的結果爲12，Math.round(-11.5)的結果爲-11。

16、下面的代碼有什麼不妥之處?

1. if(username.equals(「zxx」){}

username可能爲NULL,會報空指針錯誤；改成"zxx".equals(username)

2. int x = 1;

return x==1?true:false; 這個改爲return x==1;就能夠!

17、請說出做用域public，private，protected，以及不寫時的區別

這四個做用域的可見範圍以下表所示。

說明：若是在修飾的元素上面沒有寫任何訪問修飾符，則表示friendly。

做用域當前類同一package 子孫類其餘package

public √ √ √ √

protected √ √ √ ×

friendly √ √ × ×

private √ × × ×

備註：只要記住了有4種訪問權限，4個訪問範圍，而後將全選和範圍在水平和垂直方向上分別按排從小到大或從大到小的順序排列，就很容易畫出上面的圖了。

18、Overload和Override的區別。Overloaded的方法是否能夠改變返回值的類型?

Overload是重載的意思，Override是覆蓋的意思，也就是重寫。

重載Overload表示同一個類中能夠有多個名稱相同的方法，但這些方法的參數列表各不相同（即參數個數或類型不一樣）。

重寫Override表示子類中的方法能夠與父類中的某個方法的名稱和參數徹底相同，經過子類建立的實例對象調用這個方法時，將調用子類中的定義方法，這至關於把父類中定義的那個徹底相同的方法給覆蓋了，這也是面向對象編程的多態性的一種表現。子類覆蓋父類的方法時，只能比父類拋出更少的異常，或者是拋出父類拋出的異常的子異常，由於子類能夠解決父類的一些問題，不能比父類有更多的問題。子類方法的訪問權限只能比父類的更大，不能更小。若是父類的方法是private類型，那麼，子類則不存在覆蓋的限制，至關於子類中增長了一個全新的方法。

至於Overloaded的方法是否能夠改變返回值的類型這個問題，要看你倒底想問什麼呢？這個題目很模糊。若是幾個Overloaded的方法的參數列表不同，它們的返回者類型固然也能夠不同。但我估計你想問的問題是：若是兩個方法的參數列表徹底同樣，是否可讓它們的返回值不一樣來實現重載Overload。這是不行的，咱們能夠用反證法來講明這個問題，由於咱們有時候調用一個方法時也能夠不定義返回結果變量，即不要關心其返回結果，例如，咱們調用map.remove(key)方法時，雖然remove方法有返回值，可是咱們一般都不會定義接收返回結果的變量，這時候假設該類中有兩個名稱和參數列表徹底相同的方法，僅僅是返回類型不一樣，java就沒法肯定編程者倒底是想調用哪一個方法了，由於它沒法經過返回結果類型來判斷。

override能夠翻譯爲覆蓋，從字面就能夠知道，它是覆蓋了一個方法而且對其重寫，以求達到不一樣的做用。對咱們來講最熟悉的覆蓋就是對接口方法的實現，在接口中通常只是對方法進行了聲明，而咱們在實現時，就須要實現接口聲明的全部方法。除了這個典型的用法之外，咱們在繼承中也可能會在子類覆蓋父類中的方法。在覆蓋要注意如下的幾點：

一、覆蓋的方法的標誌必需要和被覆蓋的方法的標誌徹底匹配，才能達到覆蓋的效果；

二、覆蓋的方法的返回值必須和被覆蓋的方法的返回一致；

三、覆蓋的方法所拋出的異常必須和被覆蓋方法的所拋出的異常一致，或者是其子類；

四、被覆蓋的方法不能爲private，不然在其子類中只是新定義了一個方法，並無對其進行覆蓋。

overload對咱們來講可能比較熟悉，能夠翻譯爲重載，它是指咱們能夠定義一些名稱相同的方法，經過定義不一樣的輸入參數來區分這些方法，而後再調用時，VM就會根據不一樣的參數樣式，來選擇合適的方法執行。在使用重載要注意如下的幾點：

一、在使用重載時只能經過不一樣的參數樣式。例如，不一樣的參數類型，不一樣的參數個數，不一樣的參數順序（固然，同一方法內的幾個參數類型必須不同，例如能夠是fun(int,float)，可是不能爲fun(int,int)）；

二、不能經過訪問權限、返回類型、拋出的異常進行重載；

三、方法的異常類型和數目不會對重載形成影響；

四、對於繼承來講，若是某一方法在父類中是訪問權限是priavte，那麼就不能在子類對其進行重載，若是定義的話，也只是定義了一個新方法，而不會達到重載的效果。

19、構造器Constructor是否可被override?

構造器Constructor不能被繼承，所以不能重寫Override，但能夠被重載Overload。

20、接口是否可繼承接口?抽象類是否可實現(implements)接口?抽象類是否可繼承具體類(concrete class)?抽象類中是否能夠有靜態的main方法？

接口能夠繼承接口。抽象類能夠實現(implements)接口，抽象類能夠繼承具體類。抽象類中能夠有靜態的main方法。

備註：只要明白了接口和抽象類的本質和做用，這些問題都很好回答，你想一想，若是你是java語言的設計者，你是否會提供這樣的支持，若是不提供的話，有什麼理由嗎？若是你沒有道理不提供，那答案就是確定的了。

只有記住抽象類與普通類的惟一區別：就是不能建立實例對象和容許有abstract方法。

21、寫clone()方法時，一般都有一行代碼，是什麼？

clone 有缺省行爲，

super.clone();

由於首先要把父類中的成員複製到位，而後纔是複製本身的成員。

22、面向對象的特徵有哪些方面

計算機軟件系統是現實生活中的業務在計算機中的映射，而現實生活中的業務其實就是一個個對象協做的過程。面向對象編程就是按現實業務同樣的方式將程序代碼按一個個對象進行組織和編寫，讓計算機系統可以識別和理解用對象方式組織和編寫的程序代碼，這樣就能夠把現實生活中的業務對象映射到計算機系統中。

面向對象的編程語言有，嗎等4個主要的特徵。

封裝：

封裝是保證軟件部件具備優良的模塊性的基礎，封裝的目標就是要實現軟件部件的「高內聚、低耦合」，防止程序相互依賴性而帶來的變更影響。在面向對象的編程語言中，對象是封裝的最基本單位，面向對象的封裝比傳統語言的封裝更爲清晰、更爲有力。面向對象的封裝就是把描述一個對象的屬性和行爲的代碼封裝在一個「模塊」中，也就是一個類中，屬性用變量定義，行爲用方法進行定義，方法能夠直接訪問同一個對象中的屬性。一般狀況下，只要記住讓變量和訪問這個變量的方法放在一塊兒，將一個類中的成員變量所有定義成私有的，只有這個類本身的方法才能夠訪問到這些成員變量，這就基本上實現對象的封裝，就很容易找出要分配到這個類上的方法了，就基本上算是會面向對象的編程了。把握一個原則：把對同一事物進行操做的方法和相關的方法放在同一個類中，把方法和它操做的數據放在同一個類中。

例如，人要在黑板上畫圓，這一共涉及三個對象：人、黑板、圓，畫圓的方法要分配給哪一個對象呢？因爲畫圓須要使用到圓心和半徑，圓心和半徑顯然是圓的屬性，若是將它們在類中定義成了私有的成員變量，那麼，畫圓的方法必須分配給圓，它才能訪問到圓心和半徑這兩個屬性，人之後只是調用圓的畫圓方法、表示給圓發給消息而已，畫圓這個方法不該該分配在人這個對象上，這就是面向對象的封裝性，即將對象封裝成一個高度自治和相對封閉的個體，對象狀態（屬性）由這個對象本身的行爲（方法）來讀取和改變。一個更便於理解的例子就是，司機將火車剎住了，剎車的動做是分配給司機，仍是分配給火車，顯然，應該分配給火車，由於司機自身是不可能有那麼大的力氣將一個火車給停下來的，只有火車本身才能完成這一動做，火車須要調用內部的離合器和剎車片等多個器件協做才能完成剎車這個動做，司機剎車的過程只是給火車發了一個消息，通知火車要執行剎車動做而已。

抽象：

抽象就是找出一些事物的類似和共性之處，而後將這些事物歸爲一個類，這個類只考慮這些事物的類似和共性之處，而且會忽略與當前主題和目標無關的那些方面，將注意力集中在與當前目標有關的方面。例如，看到一隻螞蟻和大象，你可以想象出它們的相同之處，那就是抽象。抽象包括行爲抽象和狀態抽象兩個方面。例如，定義一個Person類，以下：

classPerson{

String name;

int age;

}

人原本是很複雜的事物，有不少方面，但由於當前系統只須要了解人的姓名和年齡，因此上面定義的類中只包含姓名和年齡這兩個屬性，這就是一種抽像，使用抽象能夠避免考慮一些與目標無關的細節。我對抽象的理解就是不要用顯微鏡去看一個事物的全部方面，這樣涉及的內容就太多了，而是要善於劃分問題的邊界，當前系統須要什麼，就只考慮什麼。

繼承：

在定義和實現一個類的時候，能夠在一個已經存在的類的基礎之上來進行，把這個已經存在的類所定義的內容做爲本身的內容，並能夠加入若干新的內容，或修改原來的方法使之更適合特殊的須要，這就是繼承。繼承是子類自動共享父類數據和方法的機制，這是類之間的一種關係，提升了軟件的可重用性和可擴展性。

多態：

多態是指程序中定義的引用變量所指向的具體類型和經過該引用變量發出的方法調用在編程時並不肯定，而是在程序運行期間才肯定，即一個引用變量倒底會指向哪一個類的實例對象，該引用變量發出的方法調用究竟是哪一個類中實現的方法，必須在由程序運行期間才能決定。由於在程序運行時才肯定具體的類，這樣，不用修改源程序代碼，就可讓引用變量綁定到各類不一樣的類實現上，從而致使該引用調用的具體方法隨之改變，即不修改程序代碼就能夠改變程序運行時所綁定的具體代碼，讓程序能夠選擇多個運行狀態，這就是多態性。多態性加強了軟件的靈活性和擴展性。例如，下面代碼中的UserDao是一個接口，它定義引用變量userDao指向的實例對象由daofactory.getDao()在執行的時候返回，有時候指向的是UserJdbcDao這個實現，有時候指向的是UserHibernateDao這個實現，這樣，不用修改源代碼，就能夠改變userDao指向的具體類實現，從而致使userDao.insertUser()方法調用的具體代碼也隨之改變，即有時候調用的是UserJdbcDao的insertUser方法，有時候調用的是UserHibernateDao的insertUser方法：

UserDao userDao =daofactory.getDao();

userDao.insertUser(user);

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

23、java中實現多態的機制是什麼？

靠的是父類或接口定義的引用變量能夠指向子類或具體實現類的實例對象，而程序調用的方法在運行期才動態綁定，就是引用變量所指向的具體實例對象的方法，也就是內存里正在運行的那個對象的方法，而不是引用變量的類型中定義的方法。

24、abstract class和interface有什麼區別?

含有abstract修飾符的class即爲抽象類，abstract類不能建立的實例對象。含有abstract方法的類必須定義爲abstract class，abstract class類中的方法沒必要是抽象的。abstract class類中定義抽象方法必須在具體(Concrete)子類中實現，因此，不能有抽象構造方法或抽象靜態方法。若是的子類沒有實現抽象父類中的全部抽象方法，那麼子類也必須定義爲abstract類型。

接口（interface）能夠說成是抽象類的一種特例，接口中的全部方法都必須是抽象的。接口中的方法定義默認爲public abstract類型，接口中的成員變量類型默認爲public static final。

下面比較一下二者的語法區別：

1.抽象類能夠有構造方法，接口中不能有構造方法。

2.抽象類中能夠有普通成員變量，接口中沒有普通成員變量

3.抽象類中能夠包含非抽象的普通方法，接口中的全部方法必須都是抽象的，不能有非抽象的普通方法。

4. 抽象類中的抽象方法的訪問類型能夠是public，protected和（默認類型,雖然

eclipse下不報錯，但應該也不行），但接口中的抽象方法只能是public類型的，而且默認即爲public abstract類型。

5. 抽象類中能夠包含靜態方法，接口中不能包含靜態方法

6. 抽象類和接口中均可以包含靜態成員變量，抽象類中的靜態成員變量的訪問類型能夠任意，但接口中定義的變量只能是public static final類型，而且默認即爲public static final類型。

7. 一個類能夠實現多個接口，但只能繼承一個抽象類。

下面接着再說說二者在應用上的區別：

接口更多的是在系統架構設計方法發揮做用，主要用於定義模塊之間的通訊契約。而抽象類在代碼實現方面發揮做用，能夠實現代碼的重用，例如，模板方法設計模式是抽象類的一個典型應用，假設某個項目的全部Servlet類都要用相同的方式進行權限判斷、記錄訪問日誌和處理異常，那麼就能夠定義一個抽象的基類，讓全部的Servlet都繼承這個抽象基類，在抽象基類的service方法中完成權限判斷、記錄訪問日誌和處理異常的代碼，在各個子類中只是完成各自的業務邏輯代碼，僞代碼以下：

public abstract classBaseServlet extends HttpServlet{

public final void service(HttpServletRequest request,HttpServletResponse response) throws IOExcetion,ServletException {

記錄訪問日誌

進行權限判斷

if(具備權限){

try{

doService(request,response);

}

catch(Excetpion e) {

記錄異常信息

}

protected abstract void doService(HttpServletRequest request,HttpServletResponse response) throws IOExcetion,ServletException;

//注意訪問權限定義成protected，顯得既專業，又嚴謹，由於它是專門給子類用的

}

public class MyServlet1 extendsBaseServlet

{

protected voiddoService(HttpServletRequest request, HttpServletResponse response) throwsIOExcetion,ServletException

{

本Servlet只處理的具體業務邏輯代碼

}

父類方法中間的某段代碼不肯定，留給子類幹，就用模板方法設計模式。

備註：這道題的思路是先從整體解釋抽象類和接口的基本概念，而後再比較二者的語法細節，最後再說二者的應用區別。比較二者語法細節區別的條理是：先從一個類中的構造方法、普通成員變量和方法（包括抽象方法），靜態變量和方法，繼承性等6個方面逐一去比較回答，接着從第三者繼承的角度的回答，特別是最後用了一個典型的例子來展示本身深厚的技術功底。

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

abstract的method不能夠是static的，由於抽象的方法是要被子類實現的，而static與子類扯不上關係！

native方法表示該方法要用另一種依賴平臺的編程語言實現的，不存在着被子類實現的問題，因此，它也不能是抽象的，不能與abstract混用。例如，FileOutputSteam類要硬件打交道，底層的實現用的是操做系統相關的api實現，例如，在windows用c語言實現的，因此，查看jdk的源代碼，能夠發現FileOutputStream的open方法的定義以下：

private native void open(Stringname) throws FileNotFoundException;

若是咱們要用java調用別人寫的c語言函數，咱們是沒法直接調用的，咱們須要按照java的要求寫一個c語言的函數，又咱們的這個c語言函數去調用別人的c語言函數。因爲咱們的c語言函數是按java的要求來寫的，咱們這個c語言函數就能夠與java對接上，java那邊的對接方式就是定義出與咱們這個c函數相對應的方法，java中對應的方法不須要寫具體的代碼，但須要在前面聲明native。

關於synchronized與abstract合用的問題，我以爲也不行，由於在我幾年的學習和開發中，歷來沒見到過這種狀況，而且我以爲synchronized應該是做用在一個具體的方法上纔有意義。並且，方法上的synchronized同步所使用的同步鎖對象是this，而抽象方法上沒法肯定this是什麼。

26、什麼是內部類？Static Nested Class和Inner Class的不一樣。

內部類就是在一個類的內部定義的類，內部類中不能定義靜態成員（靜態成員不是對象的特性，只是爲了找一個容身之處，因此須要放到一個類中而已，這麼一點小事，你還要把它放到類內部的一個類中，過度了啊！提供內部類，不是爲讓你幹這種事情，無聊，不讓你幹。我想多是既然靜態成員相似c語言的全局變量，而內部類一般是用於建立內部對象用的，因此，把「全局變量」放在內部類中就是毫無心義的事情，既然是毫無心義的事情，就應該被禁止），內部類能夠直接訪問外部類中的成員變量，內部類能夠定義在外部類的方法外面，也能夠定義在外部類的方法體中，以下所示：

public class Outer

{

int out_x = 0;

public void method()
{

Inner1 inner1 = new Inner1();

public class Inner2 //在方法體內部定義的內部類

{

public method()

{

out_x = 3;

}

Inner2 inner2 = new Inner2();

}

public class Inner1 //在方法體外面定義的內部類

{

}

在方法體外面定義的內部類的訪問類型能夠是public,protecte,默認的，private等4種類型，這就好像類中定義的成員變量有4種訪問類型同樣，它們決定這個內部類的定義對其餘類是否可見；對於這種狀況，咱們也能夠在外面建立內部類的實例對象，建立內部類的實例對象時，必定要先建立外部類的實例對象，而後用這個外部類的實例對象去建立內部類的實例對象，代碼以下：

Outer outer = new Outer();

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

在方法內部定義的內部類前面不能有訪問類型修飾符，就好像方法中定義的局部變量同樣，但這種內部類的前面能夠使用final或abstract修飾符。這種內部類對其餘類是不可見的其餘類沒法引用這種內部類，可是這種內部類建立的實例對象能夠傳遞給其餘類訪問。這種內部類必須是先定義，後使用，即內部類的定義代碼必須出如今使用該類以前，這與方法中的局部變量必須先定義後使用的道理也是同樣的。這種內部類能夠訪問方法體中的局部變量，可是，該局部變量前必須加final修飾符。

對於這些細節，只要在eclipse寫代碼試試，根據開發工具提示的各種錯誤信息就能夠立刻了解到。

在方法體內部還能夠採用以下語法來建立一種匿名內部類，即定義某一接口或類的子類的同時，還建立了該子類的實例對象，無需爲該子類定義名稱：

public class Outer

{

public void start()

{

new Thread(

new Runable(){

public void run(){};

}

).start();

}

最後，在方法外部定義的內部類前面能夠加上static關鍵字，從而成爲Static Nested Class，它再也不具備內部類的特性，全部，從狹義上講，它不是內部類。Static Nested Class與普通類在運行時的行爲和功能上沒有什麼區別，只是在編程引用時的語法上有一些差異，它能夠定義成public、protected、默認的、private等多種類型，而普通類只能定義成public和默認的這兩種類型。在外面引用Static Nested Class類的名稱爲「外部類名.內部類名」。在外面不須要建立外部類的實例對象，就能夠直接建立Static Nested Class，例如，假設Inner是定義在Outer類中的Static Nested Class，那麼能夠使用以下語句建立Inner類：

Outer.Inner inner = newOuter.Inner();

因爲static Nested Class不依賴於外部類的實例對象，因此，static Nested Class能訪問外部類的非static成員變量(不能直接訪問，須要建立外部類實例才能訪問非靜態變量)。當在外部類中訪問Static Nested Class時，能夠直接使用Static Nested Class的名字，而不須要加上外部類的名字了，在Static Nested Class中也能夠直接引用外部類的static的成員變量，不須要加上外部類的名字。

在靜態方法中定義的內部類也是Static Nested Class，這時候不能在類前面加static關鍵字，靜態方法中的Static Nested Class與普通方法中的內部類的應用方式很類似，它除了能夠直接訪問外部類中的static的成員變量，還能夠訪問靜態方法中的局部變量，可是，該局部變量前必須加final修飾符。

備註：首先根據你的印象說出你對內部類的整體方面的特色：例如，在兩個地方能夠定義，能夠訪問外部類的成員變量，不能定義靜態成員，這是大的特色。而後再說一些細節方面的知識，例如，幾種定義方式的語法區別，靜態內部類，以及匿名內部類。

27、內部類能夠引用它的包含類的成員嗎？有沒有什麼限制？

徹底能夠。若是不是靜態內部類，那沒有什麼限制！

若是你把靜態嵌套類看成內部類的一種特例，那在這種狀況下不能夠訪問外部類的普通成員變量，而只能訪問外部類中的靜態成員，例如，下面的代碼：

class Outer

{

static int x;

static class Inner

{

void test()

{

syso(x);

}

答題時，也要能察言觀色，揣摩提問者的心思，顯然人家但願你說的是靜態內部類不能訪問外部類的成員，但你一上來就頂牛，這很差，要先順着人家，讓人家滿意，而後再說特殊狀況，讓人家吃驚。

28、Anonymous Inner Class (匿名內部類)是否能夠extends(繼承)其它類，是否能夠implements(實現)interface(接口)?

能夠繼承其餘類或實現其餘接口。不只是能夠，而是必須!

29、super.getClass()方法調用

下面程序的輸出結果是多少？

importjava.util.Date;

public class Test extends Date{

public static void main(String[] args) {

new Test().test();

}

public void test(){

System.out.println(super.getClass().getName());

}

很奇怪，結果是Test

這屬於腦筋急轉彎的題目，在一個qq羣有個網友正好問過這個問題，我以爲挺有趣，就研究了一下，沒想到今天還被你面到了，哈哈。

在test方法中，直接調用getClass().getName()方法，返回的是Test類名

因爲getClass()在Object類中定義成了final，子類不能覆蓋該方法，因此，在

test方法中調用getClass().getName()方法，其實就是在調用從父類繼承的getClass()方法，等效於調用super.getClass().getName()方法，因此，super.getClass().getName()方法返回的也應該是Test。

若是想獲得父類的名稱，應該用以下代碼：

getClass().getSuperClass().getName();

30、String是最基本的數據類型嗎?

基本數據類型包括byte、int、char、long、float、double、boolean和short。

java.lang.String類是final類型的，所以不能夠繼承這個類、不能修改這個類。爲了提升效率節省空間，咱們應該用StringBuffer類

31、String s = "Hello";s = s + " world!";這兩行代碼執行後，原始的String對象中的內容到底變了沒有？

沒有。由於String被設計成不可變(immutable)類，因此它的全部對象都是不可變對象。在這段代碼中，s原先指向一個String對象，內容是 "Hello"，而後咱們對s進行了+操做，那麼s所指向的那個對象是否發生了改變呢？答案是沒有。這時，s不指向原來那個對象了，而指向了另外一個 String對象，內容爲"Hello world!"，原來那個對象還存在於內存之中，只是s這個引用變量再也不指向它了。

經過上面的說明，咱們很容易導出另外一個結論，若是常常對字符串進行各類各樣的修改，或者說，不可預見的修改，那麼使用String來表明字符串的話會引發很大的內存開銷。由於 String對象創建以後不能再改變，因此對於每個不一樣的字符串，都須要一個String對象來表示。這時，應該考慮使用StringBuffer類，它容許修改，而不是每一個不一樣的字符串都要生成一個新的對象。而且，這兩種類的對象轉換十分容易。
同時，咱們還能夠知道，若是要使用內容相同的字符串，沒必要每次都new一個String。例如咱們要在構造器中對一個名叫s的String引用變量進行初始化，把它設置爲初始值，應當這樣作：
public class Demo {
private String s;
...
public Demo {
s = "Initial Value";
}
...
}
而非
s = new String("Initial Value");
後者每次都會調用構造器，生成新對象，性能低下且內存開銷大，而且沒有意義，由於String對象不可改變，因此對於內容相同的字符串，只要一個String對象來表示就能夠了。也就說，屢次調用上面的構造器建立多個對象，他們的String類型屬性s都指向同一個對象。
上面的結論還基於這樣一個事實：對於字符串常量，若是內容相同，Java認爲它們表明同一個String對象。而用關鍵字new調用構造器，老是會建立一個新的對象，不管內容是否相同。
至於爲何要把String類設計成不可變類，是它的用途決定的。其實不僅String，不少Java標準類庫中的類都是不可變的。在開發一個系統的時候，咱們有時候也須要設計不可變類，來傳遞一組相關的值，這也是面向對象思想的體現。不可變類有一些優勢，好比由於它的對象是隻讀的，因此多線程併發訪問也不會有任何問題。固然也有一些缺點，好比每一個不一樣的狀態都要一個對象來表明，可能會形成性能上的問題。因此Java標準類庫還提供了一個可變版本，即 StringBuffer。

32、是否能夠繼承String類?

String類是final類故不能夠繼承。

33、String s = new String("xyz");建立了幾個String Object?兩者之間有什麼區別？

兩個或一個，」xyz」對應一個對象，這個對象放在字符串常量緩衝區，常量」xyz」無論出現多少遍，都是緩衝區中的那一個。New String每寫一遍，就建立一個新的對象，它一句那個常量」xyz」對象的內容來建立出一個新String對象。若是之前就用過’xyz’，這句表明就不會建立」xyz」本身了，直接從緩衝區拿。

34、String和StringBuffer的區別

JAVA平臺提供了兩個類：String和StringBuffer，它們能夠儲存和操做字符串，即包含多個字符的字符數據。這個String類提供了數值不可改變的字符串。而這個StringBuffer類提供的字符串進行修改。當你知道字符數據要改變的時候你就能夠使用StringBuffer。典型地，你能夠使用StringBuffers來動態構造字符數據。另外，String實現了equals方法，new String(「abc」).equals(newString(「abc」)的結果爲true,而StringBuffer沒有實現equals方法，因此，new StringBuffer(「abc」).equals(newStringBuffer(「abc」)的結果爲false。

接着要舉一個具體的例子來講明，咱們要把1到100的全部數字拼起來，組成一個串。

StringBuffer sbf = new StringBuffer();

for(int i=0;i<100;i++)

{

sbf.append(i);

}

上面的代碼效率很高，由於只建立了一個StringBuffer對象，而下面的代碼效率很低，由於建立了101個對象。

String str = new String();

for(int i=0;i<100;i++)

{

str = str + i;

}