JAVA面試問題

JAVA面試問題匯總

　　JAVA面試問題的過程中會遇到什么問題?下面是yjbys匯總的關于JAVA面試問題大全，希望對你有幫助!

　　1、一個".java"源文件中是否可以包括多個類(不是內部類)?有什么限制?

　　可以有多個類，但只能有一個public的類，并且public的類名必須與文件名相一致。

　　2、Java有沒有goto?

　　java中的保留字，現在沒有在java中使用。

　　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。

　　備注：這道題先說兩者的共同點，再說出&&和&的特殊之處，并列舉一些經典的例子來表明自己理解透徹深入、實際經驗豐富。 f

　　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

　　for(int j=0;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語句中。

　　另外由于在JDK7.0中引入了新特性，所以witch語句可以接收一個String類型的值，String可以作用在switch語句上

　　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億的大小，所以，要實現一

　　個一百億的計算器，我們得自己設計一個類可以用于表示很大的整數，并且提供了與另外一個整數進行加減乘除的功能，大概功能如下：

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

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

　　()提供加減乘除的功能

　　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 =

　　newObject();變量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”){}

　　2. int x = 1;

　　return x==1?true:false;

　　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可以翻譯為

　　覆蓋，從字面就可以知道，它是覆蓋了一個方法并且對其重寫，以求達到不同的作用。對我們來說最熟悉的覆蓋就是對接口方法的實現，在接口中一般只是對方法進

　　行了聲明，而我們在實現時，就需要實現接口聲明的所有方法。除了這個典型的用法以外，我們在繼承中也可能會在子類覆蓋父類中的方法。在覆蓋要注意以下的幾

　　點：

　　1、覆蓋的方法的標志必須要和被覆蓋的方法的標志完全匹配，才能達到覆蓋的效果;

　　2、覆蓋的方法的返回值必須和被覆蓋的方法的返回一致;

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

　　4、被覆蓋的方法不能為private，否則在其子類中只是新定義了一個方法，并沒有對其進行覆蓋。

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

　　1、在使用重載時只能通過不同的參數樣式。例如，不同的參數類型，不同的參數個數，不同的參數順序(當然，同一方法內的幾個參數類型必須不一樣，例如可以是fun(int,float)，但是不能為fun(int,int));

　　2、不能通過訪問權限、返回類型、拋出的異常進行重載;

　　3、方法的異常類型和數目不會對重載造成影響;

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

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

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

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

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

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

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

　　21、寫clone()方法時，通常都有一行代碼，是什么?

　　clone 有缺省行為，super.clone();因為首先要把父類中的成員復制到位，然后才是復制自己的成員。

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

　　計

　　算機軟件系統是現實生活中的業務在計算機中的映射，而現實生活中的業務其實就是一個個對象協作的過程。面向對象編程就是按現實業務一樣的方式將程序代碼按

　　一個個對象進行組織和編寫，讓計算機系統能夠識別和理解用對象方式組織和編寫的程序代碼，這樣就可以把現實生活中的業務對象映射到計算機系統中。

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

　　1封裝：

　　封

　　裝是保證軟件部件具有優良的模塊性的基礎，封裝的目標就是要實現軟件部件的“高內聚、低耦合”，防止程序相互依賴性而帶來的變動影響。在面向對象的編程語

　　言中，對象是封裝的最基本單位，面向對象的封裝比傳統語言的封裝更為清晰、更為有力。面向對象的封裝就是把描述一個對象的屬性和行為的代碼封裝在一個“模

　　塊”中，也就是一個類中，屬性用變量定義，行為用方法進行定義，方法可以直接訪問同一個對象中的屬性。通常情況下，只要記住讓變量和訪問這個變量的方法放

　　在一起，將一個類中的成員變量全部定義成私有的，只有這個類自己的方法才可以訪問到這些成員變量，這就基本上實現對象的封裝，就很容易找出要分配到這個類

　　上的方法了，就基本上算是會面向對象的編程了。把握一個原則：把對同一事物進行操作的方法和相關的方法放在同一個類中，把方法和它操作的數據放在同一個類

　　中。

　　例如，人要在黑板上畫圓，這一共涉及三個對象：人、黑板、圓，畫圓的方法要分配給哪個對象呢?由于畫圓需要使用到圓心和半徑，圓心和

　　半徑顯然是圓的屬性，如果將它們在類中定義成了私有的成員變量，那么，畫圓的方法必須分配給圓，它才能訪問到圓心和半徑這兩個屬性，人以后只是調用圓的畫

　　圓方法、表示給圓發給消息而已，畫圓這個方法不應該分配在人這個對象上，這就是面向對象的封裝性，即將對象封裝成一個高度自治和相對封閉的個體，對象狀態

　　(屬性)由這個對象自己的行為(方法)來讀取和改變。一個更便于理解的例子就是，司機將火車剎住了，剎車的動作是分配給司機，還是分配給火車，顯然，應該

　　分配給火車，因為司機自身是不可能有那么大的力氣將一個火車給停下來的，只有火車自己才能完成這一動作，火車需要調用內部的離合器和剎車片等多個器件協作

　　才能完成剎車這個動作，司機剎車的過程只是給火車發了一個消息，通知火車要執行剎車動作而已。

　　抽象：

　　抽

　　象就是找出一些事物的相似和共性之處，然后將這些事物歸為一個類，這個類只考慮這些事物的相似和共性之處，并且會忽略與當前主題和目標無關的那些方面，將

　　注意力集中在與當前目標有關的方面。例如，看到一只螞蟻和大象，你能夠想象出它們的相同之處，那就是抽象。抽象包括行為抽象和狀態抽象兩個方面。例如，定

　　義一個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.newInnner1();

　　在

　　方法內部定義的內部類前面不能有訪問類型修飾符，就好像方法中定義的局部變量一樣，但這種內部類的前面可以使用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 classTestextends Date{

　　public static voidmain(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類

【JAVA面試問題匯總】相關文章：

java面試常見問題12-09

java面試最常見問題10-27

java招聘面試常見問題10-27

Java編程常見問題匯總08-22

高級Java面試題匯總09-12

面試時會遇到的一些JAVA問題01-30

常見的Java多線程面試問題及解答07-05

JAVA經典面試題目匯總10-12

Java開發崗位面試題「匯總」09-16

java求職面試經驗01-23