碼上快樂

相關內容    簡體    繁體

Java程序員面試題集（1-50）(轉）

本文轉載自   查看原文   2014-10-11 21:43   5067 

轉：http://blog.csdn.net/jackfrued/article/details/17339393

下面的內容是對網上原有的Java面試題集及答案進行了全面修訂之后給出的負責任的題目和答案，原來的題目中有很多重復題目和無價值的題目，還有不少的參考答案也是錯誤的，修改后的Java面試題集參照了JDK最新版本，去掉了EJB 2.x等無用內容，補充了數據結構和算法相關的題目、經典面試編程題、大型網站技術架構、操作系統、數據庫、軟件測試、設計模式、UML等內容，同時還對很多知識點進行了深入的剖析，例如hashCode方法的設計、垃圾收集的堆和代、Java新的並發編程、NIO.2等，相信對准備入職的Java程序員一定有所裨益。

Java程序員面試題集（1-50）

一、Java基礎部分

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

答：面向對象的特征主要有以下幾個方面：

1)抽象：抽象是將一類對象的共同特征總結出來構造類的過程，包括數據抽象和行為抽象兩方面。抽象只關注對象有哪些屬性和行為，並不關注這些行為的細節是什么。

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

3)封裝：通常認為封裝是把過程和數據包圍起來，對數據的訪問只能通過已定義的界面。面向對象的本質就是將現實世界描繪成一系列完全自治、封閉的對象。我們在類中編寫的方法就是對實現細節的一種封裝；我們編寫一個類就是對數據和數據操作的封裝。可以說，封裝就是隱藏一切可隱藏的東西，只向外界提供最簡單的編程接口（可以想想普通洗衣機和全自動洗衣機的差別，明顯全自動洗衣機封裝更好因此操作起來更簡單；我們現在使用的智能手機也是封裝得足夠好的，因為幾個按鍵就搞定了所有的事情）。

4)多態性：多態性是指允許不同子類型的對象對同一消息作出不同的響應。簡單的說就是用同樣的對象引用調用同樣的方法但是做了不同的事情。多態性分為編譯時的多態性和運行時的多態性。如果將對象的方法視為對象向外界提供的服務，那么運行時的多態性可以解釋為：當A系統訪問B系統提供的服務時，B系統有多種提供服務的方式，但一切對A系統來說都是透明的（就像電動剃須刀是B系統，它的供電系統是B系統，B系統可以使用電池供電或者用交流電，甚至還有可能是太陽能，A系統只會通過B類對象調用供電的方法，但並不知道供電系統的底層實現是什么，究竟通過何種方式獲得了動力）。方法重載（overload）實現的是編譯時的多態性（也稱為前綁定），而方法重寫（override）實現的是運行時的多態性（也稱為后綁定）。運行時的多態是面向對象最精髓的東西，要實現多態需要做兩件事：1. 方法重寫（子類繼承父類並重寫父類中已有的或抽象的方法）；2. 對象造型（用父類型引用引用子類型對象，這樣同樣的引用調用同樣的方法就會根據子類對象的不同而表現出不同的行為）。

 

2、作用域public,private,protected,以及不寫時的區別？

答：區別如下：

作用域    當前類  同包 子類 其他

public        √        √       √      √

protected  √        √       √      ×

default       √       √       ×      ×

private       √        ×      ×      ×

類的成員不寫訪問修飾時默認為default。默認對於同一個包中的其他類相當於公開（public），對於不是同一個包中的其他類相當於私有（private）。受保護（protected）對子類相當於公開，對不是同一包中的沒有父子關系的類相當於私有。

 

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

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

 

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

答:不正確。3.4是雙精度數，將雙精度型（double）賦值給浮點型（float）屬於下轉型（down-casting，也稱為窄化）會造成精度損失，因此需要強制類型轉換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運算結果也是int 型，需要強制轉換類型才能賦值給short型。而short s1 = 1; s1 += 1;可以正確編譯，因為s1+= 1;相當於s1 = (short)(s1 + 1);其中有隱含的強制類型轉換。

 

6、Java 有沒有goto?

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

 

7、int 和Integer 有什么區別?

答：Java是一個近乎純潔的面向對象編程語言，但是為了編程的方便還是引入不是對象的基本數據類型，但是為了能夠將這些基本數據類型當成對象操作，Java為每一個基本數據類型都引入了對應的包裝類型（wrapper class），int的封裝類就是Integer，從JDK 1.5開始引入了自動封箱/解封箱機制，使得二者可以相互轉換。

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

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

封裝類型：Boolean，Character，Byte，Short，Integer，Long，Float，Double

 

8、&和&&的區別？

答：&運算符有兩種用法：(1)按位與；(2)邏輯與。&&運算符是短路與運算。邏輯與跟短路與的差別是非常巨大的，雖然二者都要求運算符左右兩端的布爾值都是true整個表達式的值才是true。&&之所以稱為短路運算是因為，如果&&左邊的表達式的值是false，右邊的表達式會被直接短路掉，不會進行運算。很多時候我們可能都需要用&&而不是&，例如在驗證用戶登錄時判定用戶名不是null而且不是空字符串，應當寫為：username != null &&!username.equals(“”)，二者的順序不能交換，更不能用&運算符，因為第一個條件如果不成立，根本不能進行字符串的equals比較，否則會產生NullPointerException異常。注意：邏輯或運算符（|）和短路或運算符（||）的差別也是如此。

補充：如果你熟悉JavaScript，那你可能更能感受到短路運算的強大，想成為JavaScript的高手就先從玩轉短路運算開始吧。

 

9、解釋內存中的棧（stack）、堆(heap)和靜態存儲區的用法。

答：

通常我們定義一個基本數據類型的變量，一個對象的引用，還有就是函數調用的現場保存都使用內存中的棧空間；

而通過new關鍵字和構造器創建的對象放在堆空間；

程序中的字面量（literal）如直接書寫的100、“hello”和常量都是放在靜態存儲區中。

棧空間操作最快但是也很小，通常大量的對象都是放在堆空間，整個內存包括硬盤上的虛擬內存都可以被當成堆空間來使用。

String str = new String(“hello”);

上面的語句中str放在棧上，用new創建出來的字符串對象放在堆上，而“hello”這個字面量放在靜態存儲區。

補充：較新版本的Java中使用了一項叫“逃逸分析“的技術，可以將一些局部對象放在棧上以提升對象的操作性能。

 

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

答：Math.round(11.5)的返回值是12，Math.round(-11.5)的返回值是-11。四舍五入的原理是在參數上加0.5然后進行下取整。

 

11、swtich 是否能作用在byte 上，是否能作用在long 上，是否能作用在String上?

答：早期的JDK中，switch（expr）中，expr可以是byte、short、char、int。從1.5版開始，Java中引入了枚舉類型（enum），expr也可以是枚舉，從JDK 1.7版開始，還可以是字符串（String）。長整型（long）是不可以的。

 

12、用最有效率的方法計算2乘以8?

答： 2 << 3（左移3位相當於乘以2的3次方，右移3位相當於除以2的3次方）。

 

13、數組有沒有length()方法?String 有沒有length()方法？

答：數組沒有length()方法，有length 的屬性。String 有length()方法。

 

14、在Java 中，如何跳出當前的多重嵌套循環？

答：在最外層循環前加一個標記如A，然后用break A;可以跳出多重循環。（Java中支持帶標簽的break和continue語句，作用有點類似於C和C++中的goto語句，但是就像要避免使用goto一樣，應該避免使用帶標簽的break和continue，因為它不會讓你的程序變得更優雅，很多時候甚至有相反的作用，所以這種語法其實不知道更好）

 

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

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

 

16、兩個對象值相同(x.equals(y) == true)，但卻可有不同的hash code，這句話對不對？

答：不對，如果兩個對象x和y滿足x.equals(y) == true，它們的哈希碼（hash code）應當相同。Java對於eqauls方法和hashCode方法是這樣規定的：(1)如果兩個對象相同（equals方法返回true），那么它們的hashCode值一定要相同；(2)如果兩個對象的hashCode相同，它們並不一定相同。當然，你未必要按照要求去做，但是如果你違背了上述原則就會發現在使用容器時，相同的對象可以出現在Set集合中，同時增加新元素的效率會大大下降（對於使用哈希存儲的系統，如果哈希碼頻繁的沖突將會造成存取性能急劇下降）。

補充：關於equals和hashCode方法，很多Java程序都知道，但很多人也就是僅僅知道而已，在Joshua Bloch的大作《Effective Java》（很多軟件公司，《Effective Java》、《Java編程思想》以及《重構：改善既有代碼質量》是Java程序員必看書籍，如果你還沒看過，那就趕緊去亞馬遜買一本吧）中是這樣介紹equals方法的：首先equals方法必須滿足自反性（x.equals(x)必須返回true）、對稱性（x.equals(y)返回true時，y.equals(x)也必須返回true）、傳遞性（x.equals(y)和y.equals(z)都返回true時，x.equals(z)也必須返回true）和一致性（當x和y引用的對象信息沒有被修改時，多次調用x.equals(y)應該得到同樣的返回值），而且對於任何非null值的引用x，x.equals(null)必須返回false。實現高質量的equals方法的訣竅包括：1. 使用==操作符檢查“參數是否為這個對象的引用”；2. 使用instanceof操作符檢查“參數是否為正確的類型”；3. 對於類中的關鍵屬性，檢查參數傳入對象的屬性是否與之相匹配；4. 編寫完equals方法后，問自己它是否滿足對稱性、傳遞性、一致性；5. 重寫equals時總是要重寫hashCode；6. 不要將equals方法參數中的Object對象替換為其他的類型，在重寫時不要忘掉@Override注解。

 

17、是否可以繼承String 類?

答：String 類是final類，不可以被繼承。

補充：繼承String本身就是一個錯誤的行為，對String類型最好的重用方式是關聯（HAS-A）而不是繼承（IS-A）。

 

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

答：是值傳遞。Java 編程語言只有值傳遞參數。當一個對象實例作為一個參數被傳遞到方法中時，參數的值就是對該對象的引用。對象的屬性可以在被調用過程中被改變，但對象的引用是永遠不會改變的。C++和C#中可以通過傳引用或傳輸出參數來改變傳入的參數的值。

 

19、String 和StringBuilder、StringBuffer 的區別?

答：Java 平台提供了兩種類型的字符串：String和StringBuffer / StringBuilder，它們可以儲存和操作字符串。其中String是只讀字符串，也就意味着String引用的字符串內容是不能被改變的。而StringBuffer和StringBuilder類表示的字符串對象可以直接進行修改。StringBuilder是JDK 1.5中引入的，它和StringBuffer的方法完全相同，區別在於它是在單線程環境下使用的，因為它的所有方面都沒有被synchronized修飾，因此它的效率也比StringBuffer略高。

 

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

答：

方法的重載和重寫都是實現多態的方式，區別在於前者實現的是編譯時的多態性，而后者實現的是運行時的多態性。

重載發生在一個類中，同名的方法如果有不同的參數列表（參數類型不同、參數個數不同或者二者都不同）則視為重載；

重寫發生在子類與父類之間，重寫要求子類被重寫方法與父類被重寫方法有相同的返回類型，比父類被重寫方法更好訪問，不能比父類被重寫方法聲明更多的異常（里氏代換原則）。重載對返回類型沒有特殊的要求。

補充：華為的面試題中曾經問過這樣一個問題：為什么不能根據返回類型來區分重載，說出你的答案吧！吐舌頭

 

21、描述一下JVM 加載class文件的原理機制?

答：JVM 中類的裝載是由類加載器（ClassLoader） 和它的子類來實現的，Java中的類加載器是一個重要的Java 運行時系統組件，它負責在運行時查找和裝入類文件中的類。

 

補充：

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

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

a)Bootstrap：一般用本地代碼實現，負責加載JVM基礎核心類庫（rt.jar）；

b)Extension：從java.ext.dirs系統屬性所指定的目錄中加載類庫，它的父加載器是Bootstrap；

c)System：又叫應用類加載器，其父類是Extension。它是應用最廣泛的類加載器。它從環境變量classpath或者系統屬性java.class.path所指定的目錄中記載類，是用戶自定義加載器的默認父加載器。

 

 

22、char 型變量中能不能存貯一個中文漢字?為什么?

答：char類型可以存儲一個中文漢字，因為Java中使用的編碼是Unicode（不選擇任何特定的編碼，直接使用字符在字符集中的編號，這是統一的唯一方法），一個char類型占2個字節（16bit），所以放一個中文是沒問題的。

補充：使用Unicode意味着字符在JVM內部和外部有不同的表現形式，在JVM內部都是Unicode，當這個字符被從JVM內部轉移到外部時（例如存入文件系統中），需要進行編碼轉換。所以Java中有字節流和字符流，以及在字符流和字節流之間進行轉換的轉換流，如InputStreamReader和OutputStreamReader，這兩個類是字節流和字符流之間的適配器類，承擔了編碼轉換的任務。

 

23、抽象類（abstract class）和接口（interface）有什么異同?

答：

抽象類和接口都不能夠實例化，但可以定義抽象類和接口類型的引用。

一個類如果繼承了某個抽象類或者實現了某個接口都需要對其中的抽象方法全部進行實現，否則該類仍然需要被聲明為抽象類。

接口比抽象類更加抽象，因為抽象類中可以定義構造器，可以有抽象方法和具體方法，而接口中不能定義構造器而且其中的方法全部都是抽象方法。

抽象類中的成員可以是private、默認、protected、public的，而接口中的成員全都是public的。抽

象類中可以定義成員變量，而接口中定義的成員變量實際上都是常量。

有抽象方法的類必須被聲明為抽象類，而抽象類未必要有抽象方法。

 

24、靜態嵌套類(Static Nested Class)和內部類（Inner Class）的不同？

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

 

[java]  view plain copy 在CODE上查看代碼片 派生到我的代碼片
  1. package com.lovo;  
  2.   
  3. /** 
  4.  * 撲克類（一副撲克） 
  5.  * @author 駱昊 
  6.  * 
  7.  */  
  8. public class Poker {  
  9.     private static String[] suites = {"黑桃", "紅桃", "草花", "方塊"};  
  10.     private static int[] faces = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13};  
  11.       
  12.     private Card[] cards;  
  13.       
  14.     /** 
  15.      * 構造器 
  16.      *  
  17.      */  
  18.     public Poker() {  
  19.         cards = new Card[52];  
  20.         for(int i = 0; i < suites.length; i++) {  
  21.             for(int j = 0; j < faces.length; j++) {  
  22.                 cards[i * 13 + j] = new Card(suites[i], faces[j]);  
  23.             }  
  24.         }  
  25.     }  
  26.       
  27.     /** 
  28.      * 洗牌 （隨機亂序） 
  29.      *  
  30.      */  
  31.     public void shuffle() {  
  32.         for(int i = 0, len = cards.length; i < len; i++) {  
  33.             int index = (int) (Math.random() * len);  
  34.             Card temp = cards[index];  
  35.             cards[index] = cards[i];  
  36.             cards[i] = temp;  
  37.         }  
  38.     }  
  39.       
  40.     /** 
  41.      * 發牌 
  42.      * @param index 發牌的位置 
  43.      *  
  44.      */  
  45.     public Card deal(int index) {  
  46.         return cards[index];  
  47.     }  
  48.       
  49.     /** 
  50.      * 卡片類（一張撲克） 
  51.      * [內部類] 
  52.      * @author 駱昊 
  53.      * 
  54.      */  
  55.     public class Card {  
  56.         private String suite;   // 花色  
  57.         private int face;       // 點數  
  58.   
  59.         public Card(String suite, int face) {  
  60.             this.suite = suite;  
  61.             this.face = face;  
  62.         }  
  63.           
  64.         @Override  
  65.         public String toString() {  
  66.             String faceStr = "";  
  67.             switch(face) {  
  68.             case 1: faceStr = "A"; break;  
  69.             case 11: faceStr = "J"; break;  
  70.             case 12: faceStr = "Q"; break;  
  71.             case 13: faceStr = "K"; break;  
  72.             default: faceStr = String.valueOf(face);  
  73.             }  
  74.             return suite + faceStr;  
  75.         }  
  76.     }  
  77. }  

測試類：

 

 

[java]  view plain copy 在CODE上查看代碼片 派生到我的代碼片
  1. package com.lovo;  
  2.   
  3. class PokerTest {  
  4.   
  5.     public static void main(String[] args) {  
  6.         Poker poker = new Poker();  
  7.         poker.shuffle();            // 洗牌  
  8.         Poker.Card c1 = poker.deal(0);  // 發第一張牌  
  9.         // 對於非靜態內部類Card  
  10.         // 只有通過其外部類Poker對象才能創建Card對象  
  11.         Poker.Card c2 = poker.new Card("紅心", 1);    // 自己創建一張牌  
  12.           
  13.         System.out.println(c1);     // 洗牌后的第一張  
  14.         System.out.println(c2);     // 打印: 紅心A  
  15.     }  
  16. }  

 

 

25、Java 中會存在內存泄漏嗎，請簡單描述。

答：理論上Java因為有垃圾回收機制（GC）不會存在內存泄露問題（這也是Java被廣泛使用於服務器端編程的一個重要原因）；然而在實際開發中，可能會存在無用但可達的對象，這些對象不能被GC回收也會發生內存泄露。一個例子就是Hibernate的Session（一級緩存）中的對象屬於持久態，垃圾回收器是不會回收這些對象的，然而這些對象中可能存在無用的垃圾對象。下面的例子也展示了Java中發生內存泄露的情況：

 

[java]  view plain copy 在CODE上查看代碼片 派生到我的代碼片
  1. package com.lovo;  
  2.   
  3. import java.util.Arrays;  
  4. import java.util.EmptyStackException;  
  5.   
  6. public class MyStack<T> {  
  7.     private T[] elements;  
  8.     private int size = 0;  
  9.       
  10.     private static final int INIT_CAPACITY = 16;  
  11.       
  12.     public MyStack() {  
  13.         elements = (T[]) new Object[INIT_CAPACITY];  
  14.     }  
  15.       
  16.     public void push(T elem) {  
  17.         ensureCapacity();  
  18.         elements[size++] = elem;  
  19.     }  
  20.       
  21.     public T pop() {  
  22.         if(size == 0)   
  23.             throw new EmptyStackException();  
  24.         return elements[--size];  
  25.     }  
  26.       
  27.     private void ensureCapacity() {  
  28.         if(elements.length == size) {  
  29.             elements = Arrays.copyOf(elements, 2 * size + 1);  
  30.         }  
  31.     }  
  32. }  


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

 

 

26、抽象的（abstract）方法是否可同時是靜態的（static）,是否可同時是本地方法（native），是否可同時被synchronized修飾?

答：都不能。抽象方法需要子類重寫，而靜態的方法是無法被重寫的，因此二者是矛盾的。本地方法是由本地代碼（如C代碼）實現的方法，而抽象方法是沒有實現的，也是矛盾的。synchronized和方法的實現細節有關，抽象方法不涉及實現細節，因此也是相互矛盾的。

 

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

答：靜態變量也稱為類變量，屬於類，不屬於類的任何一個對象，一個類不管創建多少個對象，靜態變量在內存中有且僅有一個拷貝；實例變量必須依存於某一實例，需要先創建對象然后通過對象才能訪問到它。

 

28、是否可以從一個靜態（static）方法內部發出對非靜態（non-static）方法的調用？

答：不可以，靜態方法只能訪問靜態成員，因為非靜態方法的調用要先創建對象，然后在調用靜態方法時可能對象並沒有被初始化。

 

29、如何實現對象克隆？

答：有兩種方式：

1.實現Cloneable接口並重寫Object類中的clone()方法；

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

 

[java]  view plain copy 在CODE上查看代碼片 派生到我的代碼片
  1. package com.lovo;  
  2.   
  3. import java.io.ByteArrayInputStream;  
  4. import java.io.ByteArrayOutputStream;  
  5. import java.io.ObjectInputStream;  
  6. import java.io.ObjectOutputStream;  
  7.   
  8. public class MyUtil {  
  9.   
  10.     private MyUtil() {  
  11.         throw new AssertionError();  
  12.     }  
  13.   
  14.     public static <T> T clone(T obj) throws Exception {  
  15.         ByteArrayOutputStream bout = new ByteArrayOutputStream();  
  16.         ObjectOutputStream oos = new ObjectOutputStream(bout);  
  17.         oos.writeObject(obj);  
  18.   
  19.         ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());  
  20.         ObjectInputStream ois = new ObjectInputStream(bin);  
  21.         return (T) ois.readObject();  
  22.           
  23.         // 說明：調用ByteArrayInputStream或ByteArrayOutputStream對象的close方法沒有任何意義  
  24.         // 這兩個基於內存的流只要垃圾回收器清理對象就能夠釋放資源  
  25.     }  
  26. }  

 

下面是測試代碼：

 

[java]  view plain copy 在CODE上查看代碼片 派生到我的代碼片
  1. package com.lovo;  
  2.   
  3. import java.io.Serializable;  
  4.   
  5. /** 
  6.  * 人類 
  7.  * @author 駱昊 
  8.  * 
  9.  */  
  10. class Person implements Serializable {  
  11.     private static final long serialVersionUID = -9102017020286042305L;  
  12.   
  13.     private String name;    // 姓名  
  14.     private int age;        // 年齡  
  15.     private Car car;        // 座駕  
  16.   
  17.     public Person(String name, int age, Car car) {  
  18.         this.name = name;  
  19.         this.age = age;  
  20.         this.car = car;  
  21.     }  
  22.   
  23.     public String getName() {  
  24.         return name;  
  25.     }  
  26.   
  27.     public void setName(String name) {  
  28.         this.name = name;  
  29.     }  
  30.   
  31.     public int getAge() {  
  32.         return age;  
  33.     }  
  34.   
  35.     public void setAge(int age) {  
  36.         this.age = age;  
  37.     }  
  38.   
  39.     public Car getCar() {  
  40.         return car;  
  41.     }  
  42.   
  43.     public void setCar(Car car) {  
  44.         this.car = car;  
  45.     }  
  46.   
  47.     @Override  
  48.     public String toString() {  
  49.         return "Person [name=" + name + ", age=" + age + ", car=" + car + "]";  
  50.     }  
  51.   
  52. }  
  53.   
  54. /** 
  55.  * 小汽車類 
  56.  * @author 駱昊 
  57.  * 
  58.  */  
  59. class Car implements Serializable {  
  60.     private static final long serialVersionUID = -5713945027627603702L;  
  61.   
  62.     private String brand;       // 品牌  
  63.     private int maxSpeed;       // 最高時速  
  64.   
  65.     public Car(String brand, int maxSpeed) {  
  66.         this.brand = brand;  
  67.         this.maxSpeed = maxSpeed;  
  68.     }  
  69.   
  70.     public String getBrand() {  
  71.         return brand;  
  72.     }  
  73.   
  74.     public void setBrand(String brand) {  
  75.         this.brand = brand;  
  76.     }  
  77.   
  78.     public int getMaxSpeed() {  
  79.         return maxSpeed;  
  80.     }  
  81.   
  82.     public void setMaxSpeed(int maxSpeed) {  
  83.         this.maxSpeed = maxSpeed;  
  84.     }  
  85.   
  86.     @Override  
  87.     public String toString() {  
  88.         return "Car [brand=" + brand + ", maxSpeed=" + maxSpeed + "]";  
  89.     }  
  90.   
  91. }  
  92.   
  93. class CloneTest {  
  94.   
  95.     public static void main(String[] args) {  
  96.         try {  
  97.             Person p1 = new Person("Hao LUO", 33, new Car("Benz", 300));  
  98.             Person p2 = MyUtil.clone(p1);   // 深度克隆  
  99.             p2.getCar().setBrand("BYD");  
  100.             // 修改克隆的Person對象p2關聯的汽車對象的品牌屬性  
  101.             // 原來的Person對象p1關聯的汽車不會受到任何影響  
  102.             // 因為在克隆Person對象時其關聯的汽車對象也被克隆了  
  103.             System.out.println(p1);  
  104.         } catch (Exception e) {  
  105.             e.printStackTrace();  
  106.         }  
  107.     }  
  108. }  



 

30、GC 是什么？為什么要有GC？

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

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

 

補充：垃圾回收機制有很多種，包括：分代復制垃圾回收、標記垃圾回收、增量垃圾回收等方式。標准的Java進程既有棧又有堆。棧保存了原始型局部變量，堆保存了要創建的對象。Java平台對堆內存回收和再利用的基本算法被稱為標記和清除，但是Java對其進行了改進，采用“分代式垃圾收集”。這種方法會跟Java對象的生命周期將堆內存划分為不同的區域，在垃圾收集過程中，可能會將對象移動到不同區域：

 

  • 伊甸園（Eden）：這是對象最初誕生的區域，並且對大多數對象來說，這里是它們唯一存在過的區域。
  • 幸存者樂園（Survivor）：從伊甸園幸存下來的對象會被挪到這里。
  • 終身頤養園（Tenured）：這是足夠老的幸存對象的歸宿。年輕代收集（Minor-GC）過程是不會觸及這個地方的。當年輕代收集不能把對象放進終身頤養園時，就會觸發一次完全收集（Major-GC），這里可能還會牽扯到壓縮，以便為大對象騰出足夠的空間。

 

與垃圾回收相關的JVM參數：

 

  • -Xms / -Xmx --- 堆的初始大小 / 堆的最大大小
  • -Xmn --- 堆中年輕代的大小
  • -XX:-DisableExplicitGC --- 讓System.gc()不產生任何作用
  • -XX:+PrintGCDetail --- 打印GC的細節
  • -XX:+PrintGCDateStamps --- 打印GC操作的時間戳

 

 

31、String s=new String(“xyz”);創建了幾個字符串對象？

答：兩個對象，一個是靜態存儲區的"xyx",一個是用new創建在堆上的對象。

 

32、接口是否可繼承（extends）接口? 抽象類是否可實現（implements）接口? 抽象類是否可繼承具體類（concrete class）?

答：接口可以繼承接口。抽象類可以實現(implements)接口，抽象類可繼承具體類，但前提是具體類必須有明確的構造函數。

 

33、一個“.java”源文件中是否可以包含多個類（不是內部類）？有什么限制？

答：可以，但一個源文件中最多只能有一個公開類而且文件名必須和公開類的類名完全保持一致。

 

34、Anonymous Inner Class(匿名內部類)是否可以繼承其它類？是否可以實現接口？

答：可以繼承其他類或實現其他接口，在Swing編程中常用此方式來實現事件監聽和回調。

 

35、內部類可以引用它的包含類（外部類）的成員嗎？有沒有什么限制？

答：一個內部類對象可以訪問創建它的外部類對象的成員，包括私有成員。

 

36、Java 中的final關鍵字有哪些用法？

 

答：(1)修飾類：表示該類不能被繼承；(2)修飾方法：表示方法不能被重寫；(3)修飾變量：表示變量只能一次賦值以后值不能被修改（常量）。

 

37、指出下面程序的運行結果:

 

[java]  view plain copy 在CODE上查看代碼片 派生到我的代碼片
  1. class A{  
  2.   
  3.     static{  
  4.         System.out.print("1");  
  5.     }  
  6.   
  7.     public A(){  
  8.         System.out.print("2");  
  9.     }  
  10. }  
  11.   
  12. class B extends A{  
  13.   
  14.     static{  
  15.         System.out.print("a");  
  16.     }  
  17.   
  18.     public B(){  
  19.         System.out.print("b");  
  20.     }  
  21. }  
  22.   
  23. public class Hello{  
  24.   
  25.     public static void main(String[] args){  
  26.         A ab = new B();  
  27.         ab = new B();  
  28.     }  
  29.   
  30. }  


答：執行結果：1a2b2b。創建對象時構造器的調用順序是：先初始化靜態成員，然后調用父類構造器，再初始化非靜態成員，最后調用自身構造器。

 

 

38、數據類型之間的轉換:

1)如何將字符串轉換為基本數據類型？

2)如何將基本數據類型轉換為字符串？

答：

1)調用基本數據類型對應的包裝類中的方法parseXXX(String)或valueOf(String)即可返回相應基本類型；

2)一種方法是將基本數據類型與空字符串（””）連接（+）即可獲得其所對應的字符串；另一種方法是調用String 類中的valueOf(…)方法返回相應字符串

package temp;

public class test {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO 自動生成的方法存根
        
        int b=Integer.getInteger("11");
        int c=Integer.parseInt("111");
        
        String sb=b+"";
        String sc=String.valueOf(c);

    }
    
}

 

 

 

39、如何實現字符串的反轉及替換？

答：方法很多，可以自己寫實現也可以使用String或StringBuffer / StringBuilder中的方法。有一道很常見的面試題是用遞歸實現字符串反轉，代碼如下所示：

 

[java]  view plain copy 在CODE上查看代碼片 派生到我的代碼片
  1. public static String reverse(String originStr) {  
  2.         if(originStr == null || originStr.length() <= 1)   
  3.             return originStr;  
  4.         return reverse(originStr.substring(1)) + originStr.charAt(0);  
  5.     }  

 

 

40、怎樣將GB2312編碼的字符串轉換為ISO-8859-1編碼的字符串？

答：代碼如下所示:

String s1 = "你好";

String s2 = newString(s1.getBytes("GB2312"), "ISO-8859-1");

 

41、日期和時間：

1)如何取得年月日、小時分鍾秒？

2)如何取得從1970年1月1日0時0分0秒到現在的毫秒數？

3)如何取得某月的最后一天？

4)如何格式化日期？

答：操作方法如下所示：

1)創建java.util.Calendar 實例，調用其get()方法傳入不同的參數即可獲得參數所對應的值

2)以下方法均可獲得該毫秒數:

 

[java]  view plain copy 在CODE上查看代碼片 派生到我的代碼片
  1. Calendar.getInstance().getTimeInMillis();  
  2. System.currentTimeMillis();  

3)示例代碼如下:

 

 

[java]  view plain copy 在CODE上查看代碼片 派生到我的代碼片
  1. Calendar time = Calendar.getInstance();  
  2. time.getActualMaximum(Calendar.DAY_OF_MONTH);  

 

4)利用java.text.DataFormat 的子類（如SimpleDateFormat類）中的format(Date)方法可將日期格式化。

 

42、打印昨天的當前時刻。

答：

 

[java]  view plain copy 在CODE上查看代碼片 派生到我的代碼片
  1. public class YesterdayCurrent {  
  2.     public static void main(String[] args){  
  3.         Calendar cal = Calendar.getInstance();  
  4.         cal.add(Calendar.DATE, -1);  
  5.         System.out.println(cal.getTime());  
  6.     }  
  7. }  

 

 

43、比較一下Java 和JavaSciprt。

答：JavaScript 與Java是兩個公司開發的不同的兩個產品。Java 是原Sun 公司推出的面向對象的程序設計語言，特別適合於互聯網應用程序開發；而JavaScript是Netscape公司的產品，為了擴展Netscape瀏覽器的功能而開發的一種可以嵌入Web頁面中運行的基於對象和事件驅動的解釋性語言，它的前身是LiveScript；而Java 的前身是Oak語言。

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

1）基於對象和面向對象：Java是一種真正的面向對象的語言，即使是開發簡單的程序，必須設計對象；JavaScript是種腳本語言，它可以用來制作與網絡無關的，與用戶交互作用的復雜軟件。它是一種基於對象（Object-Based）和事件驅動（Event-Driven）的編程語言。因而它本身提供了非常豐富的內部對象供設計人員使用；

2）解釋和編譯：Java 的源代碼在執行之前，必須經過編譯；JavaScript 是一種解釋性編程語言，其源代碼不需經過編譯，由瀏覽器解釋執行；

3）強類型變量和類型弱變量：Java采用強類型變量檢查，即所有變量在編譯之前必須作聲明；JavaScript中變量聲明，采用其弱類型。即變量在使用前不需作聲明，而是解釋器在運行時檢查其數據類型；

4）代碼格式不一樣。

補充：上面列出的四點是原來所謂的標准答案中給出的。其實Java和JavaScript最重要的區別是一個是靜態語言，一個是動態語言。目前的編程語言的發展趨勢是函數式語言和動態語言。在Java中類（class）是一等公民，而JavaScript中函數（function）是一等公民。對於這種問題，在面試時還是用自己的語言回答會更加靠譜。吐舌頭

 

44、什么時候用assert？

答：assertion(斷言)在軟件開發中是一種常用的調試方式，很多開發語言中都支持這種機制。一般來說，assertion用於保證程序最基本、關鍵的正確性。assertion檢查通常在開發和測試時開啟。為了提高性能，在軟件發布后， assertion檢查通常是關閉的。在實現中，斷言是一個包含布爾表達式的語句，在執行這個語句時假定該表達式為true；如果表達式計算為false，那么系統會報告一個AssertionError。

斷言用於調試目的：

assert(a > 0); // throws an AssertionError if a <= 0

斷言可以有兩種形式：

assert Expression1;

assert Expression1 : Expression2 ;

Expression1 應該總是產生一個布爾值。

Expression2 可以是得出一個值的任意表達式；這個值用於生成顯示更多調試信息的字符串消息。

斷言在默認情況下是禁用的，要在編譯時啟用斷言，需使用source 1.4 標記：

javac -source 1.4 Test.java

要在運行時啟用斷言，可使用-enableassertions 或者-ea 標記。

要在運行時選擇禁用斷言，可使用-da 或者-disableassertions 標記。

要在系統類中啟用斷言，可使用-esa 或者-dsa 標記。還可以在包的基礎上啟用或者禁用斷言。可以在預計正常情況下不會到達的任何位置上放置斷言。斷言可以用於驗證傳遞給私有方法的參數。不過，斷言不應該用於驗證傳遞給公有方法的參數，因為不管是否啟用了斷言，公有方法都必須檢查其參數。不過，既可以在公有方法中，也可以在非公有方法中利用斷言測試后置條件。另外，斷言不應該以任何方式改變程序的狀態。

 

45、Error 和Exception 有什么區別?

答：Error 表示系統級的錯誤和程序不必處理的異常，是恢復不是不可能但很困難的情況下的一種嚴重問題；比如內存溢出，不可能指望程序能處理這樣的情況；Exception 表示需要捕捉或者需要程序進行處理的異常，是一種設計或實現問題；也就是說，它表示如果程序運行正常，從不會發生的情況。

 

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

答：會執行，在方法返回調用者前執行。Java允許在finally中改變返回值的做法是不好的，因為如果存在finally代碼塊，try中的return語句不會立馬返回調用者，而是記錄下返回值待finally代碼塊執行完畢之后再向調用者返回其值，然后如果在finally中修改了返回值，這會對程序造成很大的困擾，C#中就從語法上規定不能做這樣的事。

package temp;

public class finally_test {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO 自動生成的方法存根
        
        System.out.println("in return b is:"+test());

    }
    
    public static int test(){
        
        int b=12;
        
        try
        {
            System.out.println("yes");
            return b+=88;
        }catch(Exception e)
        {
            System.out.println("error:"+e);
        }finally
        {
            if(b>25)
            {
                System.out.println("b>25:"+b);
            }
            System.out.println("finally");
            
            return 200;
        }
        

        
    }
    
    

}

 

 

47、Java 語言如何進行異常處理，關鍵字：throws、throw、try、catch、finally分別如何使用？

答：Java 通過面向對象的方法進行異常處理，把各種不同的異常進行分類，並提供了良好的接口。在Java 中，每個異常都是一個對象，它是Throwable 類或其子類的實例。當一個方法出現異常后便拋出一個異常對象，該對象中包含有異常信息，調用這個對象的方法可以捕獲到這個異常並進行處理。Java 的異常處理是通過5 個關鍵詞來實現的：try、catch、throw、throws和finally。一般情況下是用try來執行一段程序，如果出現異常，系統會拋出（throw）一個異常，這時候你可以通過它的類型來捕捉（catch）它，或最后（finally）由缺省處理器來處理；try用來指定一塊預防所有“異常”的程序；catch 子句緊跟在try塊后面，用來指定你想要捕捉的“異常”的類型；throw 語句用來明確地拋出一個“異常”；throws用來標明一個成員函數可能拋出的各種“異常”；finally 為確保一段代碼不管發生什么“異常”都被執行一段代碼；可以在一個成員函數調用的外面寫一個try語句，在這個成員函數內部寫另一個try語句保護其他代碼。每當遇到一個try 語句，“異常”的框架就放到棧上面，直到所有的try語句都完成。如果下一級的try語句沒有對某種“異常”進行處理，棧就會展開，直到遇到有處理這種“異常”的try 語句。

 

48、運行時異常與受檢異常有何異同？

答：異常表示程序運行過程中可能出現的非正常狀態，運行時異常表示虛擬機的通常操作中可能遇到的異常，是一種常見運行錯誤，只要程序設計得沒有問題通常就不會發生。受檢異常跟程序運行的上下文環境有關，即使程序設計無誤，仍然可能因使用的問題而引發。Java編譯器要求方法必須聲明拋出可能發生的受檢異常，但是並不要求必須聲明拋出未被捕獲的運行時異常。異常和繼承一樣，是面向對象程序設計中經常被濫用的東西，神作《Effective Java》中對異常的使用給出了以下指導原則：

 

  • 不要將異常處理用於正常的控制流（設計良好的API不應該強迫它的調用者為了正常的控制流而使用異常）
  • 對可以恢復的情況使用受檢異常，對編程錯誤使用運行時異常
  • 避免不必要的使用受檢異常（可以通過一些狀態檢測手段來避免異常的發生）
  • 優先使用標准的異常
  • 每個方法拋出的異常都要有文檔
  • 保持異常的原子性
  • 不要在catch中忽略掉捕獲到的異常

 

 

49、列出一些你常見的運行時異常？

答：

ArithmeticException（算術異常）

ClassCastException （類轉換異常）

IllegalArgumentException （非法參數異常）

IndexOutOfBoundsException （下表越界異常）

NullPointerException （空指針異常）

SecurityException （安全異常）

 

50、final, finally, finalize 的區別?

答：

final：修飾符（關鍵字）有三種用法：

  1. 修飾類，final，只讀，不能被繼承，因此它和abstract是反義詞。
  2. 變量聲明，final，只讀，保證不可改變。
  3. 聲明方法，final，只讀，不能在子類中被重寫。

finally：通常放在try…catch的后面構造總是執行代碼塊，這就意味着程序無論正常執行還是發生異常，這里的代碼只要JVM不關閉都能執行，可以將釋放外部資源的代碼寫在finally塊中。

finalize：Object類中定義的方法，Java中允許使用finalize() 方法在垃圾收集器將對象從內存中清除出去之前做必要的清理工作。這個方法是由垃圾收集器在銷毀對象時調用的，通過重寫finalize() 方法可以整理系統資源或者執行其他清理工作。


免責聲明！

本站轉載的文章為個人學習借鑒使用，本站對版權不負任何法律責任。如果侵犯了您的隱私權益，請聯系本站郵箱yoyou2525@163.com刪除。



猜您在找 Java程序員面試題集（1-50 Java面試題集（1-50） 轉 Java高級程序員面試題 程序員面試題100題（一）(轉) Java程序員經典面試題+答案（全） java程序員常見面試題 Java高級程序員面試題 java程序員常見面試題目 Java程序員筆試、面試題目 php程序員面試題
 
粵ICP備18138465號   © 2018-2025 CODEPRJ.COM