Sun Java認證分爲兩個級別：Sun 認證Java程序員和Sun 認證Java開發員。下面是小編整理的關於java程序員考試試題，歡迎大家參考!
1、是否可以繼承String 類?
答：String 類是final類，不可以被繼承。
補充：繼承String本身就是一個錯誤的行爲，對String類型最好的重用方式是關聯(HAS-A)而不是繼承(IS-A)。
2、當一個對象被當作參數傳遞到一個方法後，此方法可改變這個對象的屬性，並可返回變化後的結果，那麼這裏到底是值傳遞還是引用傳遞?
答：是值傳遞。Java 編程語言只有值傳遞參數。當一個對象實例作爲一個參數被傳遞到方法中時，參數的值就是對該對象的引用。對象的屬性可以在被調用過程中被改變，但對象的引用是永遠不會改變的。C++和C#中可以通過傳引用或傳輸出參數來改變傳入的參數的值。
補充：Java中沒有傳引用實在是非常的不方便，這一點在Java 8中仍然沒有得到改進，正是如此在Java編寫的代碼中才會出現大量的Wrapper類(將需要通過方法調用修改的引用置於一個Wrapper類中，再將Wrapper對象傳入方法)，這樣的做法只會讓代碼變得臃腫，尤其是讓從C和C++轉型爲Java程序員的開發者無法容忍。
3、String 和StringBuilder、StringBuffer 的區別?
答：Java 平臺提供了兩種類型的字符串：String和StringBuffer / StringBuilder，它們可以儲存和操作字符串。其中String是隻讀字符串，也就意味着String引用的字符串內容是不能被改變的。而StringBuffer和StringBuilder類表示的字符串對象可以直接進行修改。StringBuilder是JDK 1.5中引入的，它和StringBuffer的方法完全相同，區別在於它是在單線程環境下使用的，因爲它的所有方面都沒有被synchronized修飾，因此它的效率也比StringBuffer略高。
補充1：有一個面試題問：有沒有哪種情況用+做字符串連接比調用StringBuffer / StringBuilder對象的append方法性能更好?如果連接後得到的字符串在靜態存儲區中是早已存在的，那麼用+做字符串連接是優於StringBuffer / StringBuilder的append方法的。
補充2：下面也是一個面試題，問程序的輸出，看看自己能不能說出正確答案。
package ;
public class StringEqualTest {
public static void main(String[] args) {
String a = "Programming";
String b = new String("Programming");
String c = "Program" + "ming";
tln(a == b);
tln(a == c);
tln(ls(b));
tln(ls(c));
tln(rn() == rn());
}
}
4、重載(Overload)和重寫(Override)的區別。重載的方法能否根據返回類型進行區分?
答：方法的重載和重寫都是實現多態的方式，區別在於前者實現的是編譯時的多態性，而後者實現的是運行時的多態性。重載發生在一個類中，同名的方法如果有不同的參數列表(參數類型不同、參數個數不同或者二者都不同)則視爲重載;重寫發生在子類與父類之間，重寫要求子類被重寫方法與父類被重寫方法有相同的返回類型，比父類被重寫方法更好訪問，不能比父類被重寫方法聲明更多的異常(里氏代換原則)。重載對返回類型沒有特殊的要求。
補充：華爲的面試題中曾經問過這樣一個問題：爲什麼不能根據返回類型來區分重載，說出你的答案吧!吐舌頭
5、描述一下JVM 加載class文件的原理機制?
答：JVM 中類的裝載是由類加載器(ClassLoader) 和它的子類來實現的，Java中的類加載器是一個重要的Java 運行時系統組件，它負責在運行時查找和裝入類文件中的類。
補充：
1.由於Java的跨平臺性，經過編譯的Java源程序並不是一個可執行程序，而是一個或多個類文件。當Java程序需要使用某個類時，JVM會確保這個類已經被加載、連接(驗證、準備和解析)和初始化。類的加載是指把類的s文件中的數據讀入到內存中，通常是創建一個字節數組讀入s文件，然後產生與所加載類對應的Class對象。加載完成後，Class對象還不完整，所以此時的類還不可用。當類被加載後就進入連接階段，這一階段包括驗證、準備(爲靜態變量分配內存並設置默認的初始值)和解析(將符號引用替換爲直接引用)三個步驟。最後JVM對類進行初始化，包括：1如果類存在直接的父類並且這個類還沒有被初始化，那麼就先初始化父類;2如果類中存在初始化語句，就依次執行這些初始化語句。
2.類的加載是由類加載器完成的，類加載器包括：根加載器(BootStrap)、擴展加載器(Extension)、系統加載器(System)和用戶自定義類加載器(sLoader的子類)。從JDK 1.2開始，類加載過程採取了父親委託機制(PDM)。PDM更好的保證了Java平臺的安全性，在該機制中，JVM自帶的Bootstrap是根加載器，其他的加載器都有且僅有一個父類加載器。類的加載首先請求父類加載器加載，父類加載器無能爲力時才由其子類加載器自行加載。JVM不會向Java程序提供對Bootstrap的引用。下面是關於幾個類加載器的說明：
a)Bootstrap：一般用本地代碼實現，負責加載JVM基礎核心類庫();
b)Extension：從系統屬性所指定的目錄中加載類庫，它的父加載器是Bootstrap;
c)System：又叫應用類加載器，其父類是Extension。它是應用最廣泛的類加載器。它從環境變量classpath或者系統屬性所指定的目錄中記載類，是用戶自定義加載器的默認父加載器。
6、char 型變量中能不能存貯一箇中文漢字?爲什麼?
答：char類型可以存儲一箇中文漢字，因爲Java中使用的編碼是Unicode(不選擇任何特定的編碼，直接使用字符在字符集中的編號，這是統一的唯一方法)，一個char類型佔2個字節(16bit)，所以放一箇中文是沒問題的。
補充：使用Unicode意味着字符在JVM內部和外部有不同的表現形式，在JVM內部都是Unicode，當這個字符被從JVM內部轉移到外部時(例如存入文件系統中)，需要進行編碼轉換。所以Java中有字節流和字符流，以及在字符流和字節流之間進行轉換的轉換流，如InputStreamReader和OutputStreamReader，這兩個類是字節流和字符流之間的適配器類，承擔了編碼轉換的任務;對於C程序員來說，要完成這樣的編碼轉換恐怕要依賴於union(聯合體/共用體)共享內存的特徵來實現了。
7、抽象類(abstract class)和接口(interface)有什麼異同?
答：抽象類和接口都不能夠實例化，但可以定義抽象類和接口類型的引用。一個類如果繼承了某個抽象類或者實現了某個接口都需要對其中的抽象方法全部進行實現，否則該類仍然需要被聲明爲抽象類。接口比抽象類更加抽象，因爲抽象類中可以定義構造器，可以有抽象方法和具體方法，而接口中不能定義構造器而且其中的方法全部都是抽象方法。抽象類中的成員可以是private、默認、protected、public的，而接口中的'成員全都是public的。抽象類中可以定義成員變量，而接口中定義的成員變量實際上都是常量。有抽象方法的類必須被聲明爲抽象類，而抽象類未必要有抽象方法。
8、靜態嵌套類(Static Nested Class)和內部類(Inner Class)的不同?
答：Static Nested Class是被聲明爲靜態(static)的內部類，它可以不依賴於外部類實例被實例化。而通常的內部類需要在外部類實例化後才能實例化，其語法看起來挺詭異的，如下所示。
package ;
/**
* 撲克類(一副撲克)
* @author 駱昊
*
*/
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;
/**
* 構造器
*
*/
public Poker() {
cards = new Card[52];
for(int i = 0; i < th; i++) {
for(int j = 0; j < th; j++) {
cards[i * 13 + j] = new Card(suites[i], faces[j]);
}
}
}
/**
* 洗牌 (隨機亂序)
*
*/
public void shuffle() {
for(int i = 0, len = th; i < len; i++) {
int index = (int) (om() * len);
Card temp = cards[index];
cards[index] = cards[i];
cards[i] = temp;
}
}
/**
* 發牌
* @param index 發牌的位置
*
*/
public Card deal(int index) {
return cards[index];
}
/**
* 卡片類(一張撲克)
* [內部類]
* @author 駱昊
*
*/
public class Card {
private String suite; // 花色
private int face; // 點數
public Card(String suite, int face) {
e = suite;
= 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 = eOf(face);
}
return suite + faceStr;
}
}
}
測試類：
package ;
class PokerTest {
public static void main(String[] args) {
Poker poker = new Poker();
fle(); // 洗牌
c1 = (0); // 發第一張牌
// 對於非靜態內部類Card
// 只有通過其外部類Poker對象才能創建Card對象
c2 = Card("紅心", 1); // 自己創建一張牌
tln(c1); // 洗牌後的第一張
tln(c2); // 打印: 紅心A
}
}
9、Java 中會存在內存泄漏嗎，請簡單描述。
答：理論上Java因爲有垃圾回收機制(GC)不會存在內存泄露問題(這也是Java被廣泛使用於服務器端編程的一個重要原因);然而在實際開發中，可能會存在無用但可達的對象，這些對象不能被GC回收也會發生內存泄露。一個例子就是Hibernate的Session(一級緩存)中的對象屬於持久態，垃圾回收器是不會回收這些對象的，然而這些對象中可能存在無用的垃圾對象。下面的例子也展示了Java中發生內存泄露的情況：
package ;
import ys;
import yStackException;
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(th == size) {
elements = Of(elements, 2 * size + 1);
}
}
}
上面的代碼實現了一個棧(先進後出(FILO))結構，乍看之下似乎沒有什麼明顯的問題，它甚至可以通過你編寫的各種單元測試。然而其中的pop方法卻存在內存泄露的問題，當我們用pop方法彈出棧中的對象時，該對象不會被當作垃圾回收，即使使用棧的程序不再引用這些對象，因爲棧內部維護着對這些對象的過期引用(obsolete reference)。在支持垃圾回收的語言中，內存泄露是很隱蔽的，這種內存泄露其實就是無意識的對象保持。如果一個對象引用被無意識的保留起來了，那麼垃圾回收器不會處理這個對象，也不會處理該對象引用的其他對象，即使這樣的對象只有少數幾個，也可能會導致很多的對象被排除在垃圾回收之外，從而對性能造成重大影響，極端情況下會引發Disk Paging(物理內存與硬盤的虛擬內存交換數據)，甚至造成OutOfMemoryError。
10、抽象的(abstract)方法是否可同時是靜態的(static),是否可同時是本地方法(native)，是否可同時被synchronized修飾?
答：都不能。抽象方法需要子類重寫，而靜態的方法是無法被重寫的，因此二者是矛盾的。本地方法是由本地代碼(如C代碼)實現的方法，而抽象方法是沒有實現的，也是矛盾的。synchronized和方法的實現細節有關，抽象方法不涉及實現細節，因此也是相互矛盾的。
11、靜態變量和實例變量的區別?
答：靜態變量是被static修飾符修飾的變量，也稱爲類變量，它屬於類，不屬於類的任何一個對象，一個類不管創建多少個對象，靜態變量在內存中有且僅有一個拷貝;實例變量必須依存於某一實例，需要先創建對象然後通過對象才能訪問到它。靜態變量可以實現讓多個對象共享內存。在Java開發中，上下文類和工具類中通常會有大量的靜態成員。
12、是否可以從一個靜態(static)方法內部發出對非靜態(non-static)方法的調用?
答：不可以，靜態方法只能訪問靜態成員，因爲非靜態方法的調用要先創建對象，因此在調用靜態方法時可能對象並沒有被初始化。
13、如何實現對象克隆?
答：有兩種方式：
1.實現Cloneable接口並重寫Object類中的clone()方法;
2.實現Serializable接口，通過對象的序列化和反序列化實現克隆，可以實現真正的深度克隆，代碼如下。
package ;
import ArrayInputStream;
import ArrayOutputStream;
import ctInputStream;
import ctOutputStream;
public class MyUtil {
private MyUtil() {
throw new AssertionError();
}
public static
ByteArrayOutputStream bout = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(bout);
eObject(obj);
ByteArrayInputStream bin = new ByteArrayInputStream(teArray());
ObjectInputStream ois = new ObjectInputStream(bin);
return (T) Object();
// 說明：調用ByteArrayInputStream或ByteArrayOutputStream對象的close方法沒有任何意義
// 這兩個基於內存的流只要垃圾回收器清理對象就能夠釋放資源
}
}
下面是測試代碼：
package ;
import alizable;
/**
* 人類
* @author 駱昊
*
*/
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) {
= name;
= age;
= car;
}
public String getName() {
return name;
}
public void setName(String name) {
= name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
= age;
}
public Car getCar() {
return car;
}
public void setCar(Car car) {
= car;
}
@Override
public String toString() {
return "Person [name=" + name + ", age=" + age + ", car=" + car + "]";
}
}
/**
* 小汽車類
* @author 駱昊
*
*/
class Car implements Serializable {
private static final long serialVersionUID = -5713945027627603702L;
private String brand; // 品牌
private int maxSpeed; // 最高時速
public Car(String brand, int maxSpeed) {
d = brand;
peed = maxSpeed;
}
public String getBrand() {
return brand;
}
public void setBrand(String brand) {
d = brand;
}
public int getMaxSpeed() {
return maxSpeed;
}
public void setMaxSpeed(int maxSpeed) {
peed = 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 = e(p1); // 深度克隆
ar()rand("BYD");
// 修改克隆的Person對象p2關聯的汽車對象的品牌屬性
// 原來的Person對象p1關聯的汽車不會受到任何影響
// 因爲在克隆Person對象時其關聯的汽車對象也被克隆了
tln(p1);
} catch (Exception e) {
tStackTrace();
}
}
}
注意：基於序列化和反序列化實現的克隆不僅僅是深度克隆，更重要的是通過泛型限定，可以檢查出要克隆的對象是否支持序列化，這項檢查是編譯器完成的，不是在運行時拋出異常，這種是方案明顯優於使用Object類的clone方法克隆對象。
14、GC 是什麼?爲什麼要有GC?
答：GC是垃圾收集的意思，內存處理是編程人員容易出現問題的地方，忘記或者錯誤的內存回收會導致程序或系統的不穩定甚至崩潰，Java提供的GC功能可以自動監測對象是否超過作用域從而達到自動回收內存的目的，Java語言沒有提供釋放已分配內存的顯示操作方法。Java程序員不用擔心內存管理，因爲垃圾收集器會自動進行管理。要請求垃圾收集，可以調用下面的方法之一：() 或untime()() ，但JVM可以屏蔽掉顯示的垃圾回收調用。
垃圾回收可以有效的防止內存泄露，有效的使用可以使用的內存。垃圾回收器通常是作爲一個單獨的低優先級的線程運行，不可預知的情況下對內存堆中已經死亡的或者長時間沒有使用的對象進行清除和回收，程序員不能實時的調用垃圾回收器對某個對象或所有對象進行垃圾回收。在Java誕生初期，垃圾回收是Java最大的亮點之一，因爲服務器端的編程需要有效的防止內存泄露問題，然而時過境遷，如今Java的垃圾回收機制已經成爲被詬病的東西。移動智能終端用戶通常覺得iOS的系統比Android系統有更好的用戶體驗，其中一個深層次的原因就在於Android系統中垃圾回收的不可預知性。
補充：垃圾回收機制有很多種，包括：分代複製垃圾回收、標記垃圾回收、增量垃圾回收等方式。標準的Java進程既有棧又有堆。棧保存了原始型局部變量，堆保存了要創建的對象。Java平臺對堆內存回收和再利用的基本算法被稱爲標記和清除，但是Java對其進行了改進，採用“分代式垃圾收集”。這種方法會跟Java對象的生命週期將堆內存劃分爲不同的區域，在垃圾收集過程中，可能會將對象移動到不同區域：
伊甸園(Eden)：這是對象最初誕生的區域，並且對大多數對象來說，這裏是它們唯一存在過的區域。
倖存者樂園(Survivor)：從伊甸園倖存下來的對象會被挪到這裏。
終身頤養園(Tenured)：這是足夠老的倖存對象的歸宿。年輕代收集(Minor-GC)過程是不會觸及這個地方的。當年輕代收集不能把對象放進終身頤養園時，就會觸發一次完全收集(Major-GC)，這裏可能還會牽扯到壓縮，以便爲大對象騰出足夠的空間。
與垃圾回收相關的JVM參數：
-Xms / -Xmx --- 堆的初始大小 / 堆的最大大小
-Xmn --- 堆中年輕代的大小
-XX:-DisableExplicitGC --- 讓()不產生任何作用
-XX:+PrintGCDetail --- 打印GC的細節
-XX:+PrintGCDateStamps --- 打印GC操作的時間戳
