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