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操作的時間戳
