Android知識架構 · Java的編程思想上 [復制鏈接]

2018-11-9 09:59
James1991 閱讀:827 評論:1 贊:0
Tag:  

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

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

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

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

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

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

2、訪問修飾符public,private,protected,以及不寫(默認)時的區別?

答:

修飾符當前類同包子類其他類
public
protected×
default××
private×××

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,從Java 5開始引入了自動裝箱/拆箱機制,使得二者可以相互轉換。 
Java 為每個原始類型提供了包裝類型: 
- 原始類型: boolean,char,byte,short,int,long,float,double 
- 包裝類型:Boolean,Character,Byte,Short,Integer,Long,Float,Double

  1. class AutoUnboxingTest {
  2. public static void main(String[] args) {
  3. Integer a = new Integer(3);
  4. Integer b = 3; // 將3自動裝箱成Integer類型
  5. int c = 3;
  6. System.out.println(a == b); // false 兩個引用沒有引用同一對象
  7. System.out.println(a == c); // true a自動拆箱成int類型再和c比較
  8. }
  9. }
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10

最近還遇到一個面試題,也是和自動裝箱和拆箱有點關系的,代碼如下所示:

  1. public class Test03 {
  2. public static void main(String[] args) {
  3. Integer f1 = 100, f2 = 100, f3 = 150, f4 = 150;
  4. System.out.println(f1 == f2);
  5. System.out.println(f3 == f4);
  6. }
  7. }
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9

如果不明就里很容易認為兩個輸出要么都是true要么都是false。首先需要注意的是f1、f2、f3、f4四個變量都是Integer對象引用,所以下面的==運算比較的不是值而是引用。裝箱的本質是什么呢?當我們給一個Integer對象賦一個int值的時候,會調用Integer類的靜態方法valueOf,如果看看valueOf的源代碼就知道發生了什么。

  1. public static Integer valueOf(int i) {
  2. if (i >= IntegerCache.low && i <= IntegerCache.high)
  3. return IntegerCache.cache[i + (-IntegerCache.low)];
  4. return new Integer(i);
  5. }
  • 1
  • 2
  • 3
  • 4
  • 5

IntegerCache是Integer的內部類,其代碼如下所示:

  1. /**
  2. * Cache to support the object identity semantics of autoboxing for values between
  3. * -128 and 127 (inclusive) as required by JLS.
  4. *
  5. * The cache is initialized on first usage. The size of the cache
  6. * may be controlled by the {@code -XX:AutoBoxCacheMax=<size>} option.
  7. * During VM initialization, java.lang.Integer.IntegerCache.high property
  8. * may be set and saved in the private system properties in the
  9. * sun.misc.VM class.
  10. */
  11. private static class IntegerCache {
  12. static final int low = -128;
  13. static final int high;
  14. static final Integer cache[];
  15. static {
  16. // high value may be configured by property
  17. int h = 127;
  18. String integerCacheHighPropValue =
  19. sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
  20. if (integerCacheHighPropValue != null) {
  21. try {
  22. int i = parseInt(integerCacheHighPropValue);
  23. i = Math.max(i, 127);
  24. // Maximum array size is Integer.MAX_VALUE
  25. h = Math.min(i, Integer.MAX_VALUE - (-low) -1);
  26. } catch( NumberFormatException nfe) {
  27. // If the property cannot be parsed into an int, ignore it.
  28. }
  29. }
  30. high = h;
  31. cache = new Integer[(high - low) + 1];
  32. int j = low;
  33. for(int k = 0; k < cache.length; k++)
  34. cache[k] = new Integer(j++);
  35. // range [-128, 127] must be interned (JLS7 5.1.7)
  36. assert IntegerCache.high >= 127;
  37. }
  38. private IntegerCache() {}
  39. }
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44

簡單的說,如果整型字面量的值在-128到127之間,那么不會new新的Integer對象,而是直接引用常量池中的Integer對象,所以上面的面試題中f1==f2的結果是true,而f3==f4的結果是false。

提醒:越是貌似簡單的面試題其中的玄機就越多,需要面試者有相當深厚的功力。

    8、&和&&的區別?

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

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

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

    答:通常我們定義一個基本數據類型的變量,一個對象的引用,還有就是函數調用的現場保存都使用內存中的棧空間;而通過new關鍵字和構造器創建的對象放在堆空間;程序中的字面量(literal)如直接書寫的100、”hello”和常量都是放在靜態區中。棧空間操作起來最快但是棧很小,通常大量的對象都是放在堆空間,理論上整個內存沒有被其他進程使用的空間甚至硬盤上的虛擬內存都可以被當成堆空間來使用。

    String str = new String("hello");
    • 1

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

    1. 補充:較新版本的Java(從Java 6的某個更新開始)中使用了一項叫"逃逸分析"的技術,可以將一些局部對象放
    2. 在棧上以提升對象的操作性能。
    • 1

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

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

    11、switch 是否能作用在byte 上,是否能作用在long 上,是否能作用在String上?

    答:在Java 5以前,switch(expr)中,expr只能是byte、short、char、int。從Java 5開始,Java中引入了枚舉類型,expr也可以是enum類型,從Java 7開始,expr還可以是字符串(String),但是長整型(long)在目前所有的版本中都是不可以的。

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

    答: 2 << 3(左移3位相當于乘以2的3次方,右移3位相當于除以2的3次方)。

    補充:我們為編寫的類重寫hashCode方法時,可能會看到如下所示的代碼,其實我們不太理解為什么要使用這樣的乘法運算來產生哈希碼(散列碼),而且為什么這個數是個素數,為什么通常選擇31這個數?前兩個問題的答案你可以自己百度一下,選擇31是因為可以用移位和減法運算來代替乘法,從而得到更好的性能。說到這里你可能已經想到了:31 * num 等價于(num << 5) - num,左移5位相當于乘以2的5次方再減去自身就相當于乘以31,現在的VM都能自動完成這個優化。

    1. public class PhoneNumber {
    2. private int areaCode;
    3. private String prefix;
    4. private String lineNumber;
    5. @Override
    6. public int hashCode() {
    7. final int prime = 31;
    8. int result = 1;
    9. result = prime * result + areaCode;
    10. result = prime * result
    11. + ((lineNumber == null) ? 0 : lineNumber.hashCode());
    12. result = prime * result + ((prefix == null) ? 0 : prefix.hashCode());
    13. return result;
    14. }
    15. @Override
    16. public boolean equals(Object obj) {
    17. if (this == obj)
    18. return true;
    19. if (obj == null)
    20. return false;
    21. if (getClass() != obj.getClass())
    22. return false;
    23. PhoneNumber other = (PhoneNumber) obj;
    24. if (areaCode != other.areaCode)
    25. return false;
    26. if (lineNumber == null) {
    27. if (other.lineNumber != null)
    28. return false;
    29. } else if (!lineNumber.equals(other.lineNumber))
    30. return false;
    31. if (prefix == null) {
    32. if (other.prefix != null)
    33. return false;
    34. } else if (!prefix.equals(other.prefix))
    35. return false;
    36. return true;
    37. }
    38. }
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41

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

    答:數組沒有length()方法,有length 的屬性。String 有length()方法。JavaScript中,獲得字符串的長度是通過length屬性得到的,這一點容易和Java混淆。

    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)和依賴關系(Use-A)而不是繼承關系(Is-A)。

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

    答:是值傳遞。Java語言的方法調用只支持參數的值傳遞。當一個對象實例作為一個參數被傳遞到方法中時,參數的值就是對該對象的引用。對象的屬性可以在被調用過程中被改變,但對對象引用的改變是不會影響到調用者的。C++和C#中可以通過傳引用或傳輸出參數來改變傳入的參數的值。在C#中可以編寫如下所示的代碼,但是在Java中卻做不到。

    1. using System;
    2. namespace CS01 {
    3. class Program {
    4. public static void swap(ref int x, ref int y) {
    5. int temp = x;
    6. x = y;
    7. y = temp;
    8. }
    9. public static void Main (string[] args) {
    10. int a = 5, b = 10;
    11. swap (ref a, ref b);
    12. // a = 10, b = 5;
    13. Console.WriteLine ("a = {0}, b = {1}", a, b);
    14. }
    15. }
    16. }
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19

    說明:Java中沒有傳引用實在是非常的不方便,這一點在Java 8中仍然沒有得到改進,正是如此在Java編寫的代碼中才會出現大量的Wrapper類(將需要通過方法調用修改的引用置于一個Wrapper類中,再將Wrapper對象傳入方法),這樣的做法只會讓代碼變得臃腫,尤其是讓從C和C++轉型為Java程序員的開發者無法容忍。

    19、String和StringBuilder、StringBuffer的區別?

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

    面試題1 - 什么情況下用+運算符進行字符串連接比調用StringBuffer/StringBuilder對象的append方法連接字符串性能更好?

    面試題2 - 請說出下面程序的輸出。

    1. class StringEqualTest {
    2. public static void main(String[] args) {
    3. String s1 = "Programming";
    4. String s2 = new String("Programming");
    5. String s3 = "Program" + "ming";
    6. System.out.println(s1 == s2);
    7. System.out.println(s1 == s3);
    8. System.out.println(s1 == s1.intern());
    9. }
    10. }
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11

    補充:String對象的intern方法會得到字符串對象在常量池中對應的版本的引用(如果常量池中有一個字符串與String對象的equals結果是true),如果常量池中沒有對應的字符串,則該字符串將被添加到常量池中,然后返回常量池中字符串的引用。

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

    答:方法的重載和重寫都是實現多態的方式,區別在于前者實現的是編譯時的多態性,而后者實現的是運行時的多態性。重載發生在一個類中,同名的方法如果有不同的參數列表(參數類型不同、參數個數不同或者二者都不同)則視為重載;重寫發生在子類與父類之間,重寫要求子類被重寫方法與父類被重寫方法有相同的返回類型,比父類被重寫方法更好訪問,不能比父類被重寫方法聲明更多的異常(里氏代換原則)。重載對返回類型沒有特殊的要求。

    面試題:華為的面試題中曾經問過這樣一個問題 - “為什么不能根據返回類型來區分重載”,快說出你的答案吧!

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

    答:JVM中類的裝載是由類加載器(ClassLoader)和它的子類來實現的,Java中的類加載器是一個重要的Java運行時系統組件,它負責在運行時查找和裝入類文件中的類。 
    由于Java的跨平臺性,經過編譯的Java源程序并不是一個可執行程序,而是一個或多個類文件。當Java程序需要使用某個類時,JVM會確保這個類已經被加載、連接(驗證、準備和解析)和初始化。類的加載是指把類的.class文件中的數據讀入到內存中,通常是創建一個字節數組讀入.class文件,然后產生與所加載類對應的Class對象。加載完成后,Class對象還不完整,所以此時的類還不可用。當類被加載后就進入連接階段,這一階段包括驗證、準備(為靜態變量分配內存并設置默認的初始值)和解析(將符號引用替換為直接引用)三個步驟。最后JVM對類進行初始化,包括:1)如果類存在直接的父類并且這個類還沒有被初始化,那么就先初始化父類;2)如果類中存在初始化語句,就依次執行這些初始化語句。 
    類的加載是由類加載器完成的,類加載器包括:根加載器(BootStrap)、擴展加載器(Extension)、系統加載器(System)和用戶自定義類加載器(java.lang.ClassLoader的子類)。從Java 2(JDK 1.2)開始,類加載過程采取了父親委托機制(PDM)。PDM更好的保證了Java平臺的安全性,在該機制中,JVM自帶的Bootstrap是根加載器,其他的加載器都有且僅有一個父類加載器。類的加載首先請求父類加載器加載,父類加載器無能為力時才由其子類加載器自行加載。JVM不會向Java程序提供對Bootstrap的引用。下面是關于幾個類加載器的說明:

    • Bootstrap:一般用本地代碼實現,負責加載JVM基礎核心類庫(rt.jar);
    • Extension:從java.ext.dirs系統屬性所指定的目錄中加載類庫,它的父加載器是Bootstrap;
    • System:又叫應用類加載器,其父類是Extension。它是應用最廣泛的類加載器。它從環境變量classpath或者系統屬性java.class.path所指定的目錄中記載類,是用戶自定義加載器的默認父加載器。

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

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

    補充:使用Unicode意味著字符在JVM內部和外部有不同的表現形式,在JVM內部都是Unicode,當這個字符被從JVM內部轉移到外部時(例如存入文件系統中),需要進行編碼轉換。所以Java中有字節流和字符流,以及在字符流和字節流之間進行轉換的轉換流,如InputStreamReader和OutputStreamReader,這兩個類是字節流和字符流之間的適配器類,承擔了編碼轉換的任務;對于C程序員來說,要完成這樣的編碼轉換恐怕要依賴于union(聯合體/共用體)共享內存的特征來實現了。

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

    答:抽象類和接口都不能夠實例化,但可以定義抽象類和接口類型的引用。一個類如果繼承了某個抽象類或者實現了某個接口都需要對其中的抽象方法全部進行實現,否則該類仍然需要被聲明為抽象類。接口比抽象類更加抽象,因為抽象類中可以定義構造器,可以有抽象方法和具體方法,而接口中不能定義構造器而且其中的方法全部都是抽象方法。抽象類中的成員可以是private、默認、protected、public的,而接口中的成員全都是public的。抽象類中可以定義成員變量,而接口中定義的成員變量實際上都是常量。有抽象方法的類必須被聲明為抽象類,而抽象類未必要有抽象方法。

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

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

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

    測試代碼:

    1. class PokerTest {
    2. public static void main(String[] args) {
    3. Poker poker = new Poker();
    4. poker.shuffle(); // 洗牌
    5. Poker.Card c1 = poker.deal(0); // 發第一張牌
    6. // 對于非靜態內部類Card
    7. // 只有通過其外部類Poker對象才能創建Card對象
    8. Poker.Card c2 = poker.new Card("紅心", 1); // 自己創建一張牌
    9. System.out.println(c1); // 洗牌后的第一張
    10. System.out.println(c2); // 打印: 紅心A
    11. }
    12. }
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14

    面試題 - 下面的代碼哪些地方會產生編譯錯誤?

    1. class Outer {
    2. class Inner {}
    3. public static void foo() { new Inner(); }
    4. public void bar() { new Inner(); }
    5. public static void main(String[] args) {
    6. new Inner();
    7. }
    8. }
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12

    注意:Java中非靜態內部類對象的創建要依賴其外部類對象,上面的面試題中foo和main方法都是靜態方法,靜態方法中沒有this,也就是說沒有所謂的外部類對象,因此無法創建內部類對象,如果要在靜態方法中創建內部類對象,可以這樣做:

    new Outer().new Inner();
    • 1

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

    答:理論上Java因為有垃圾回收機制(GC)不會存在內存泄露問題(這也是Java被廣泛使用于服務器端編程的一個重要原因);然而在實際開發中,可能會存在無用但可達的對象,這些對象不能被GC回收,因此也會導致內存泄露的發生。例如Hibernate的Session(一級緩存)中的對象屬于持久態,垃圾回收器是不會回收這些對象的,然而這些對象中可能存在無用的垃圾對象,如果不及時關閉(close)或清空(flush)一級緩存就可能導致內存泄露。下面例子中的代碼也會導致內存泄露。

    1. import java.util.Arrays;
    2. import java.util.EmptyStackException;
    3. public class MyStack<T> {
    4. private T[] elements;
    5. private int size = 0;
    6. private static final int INIT_CAPACITY = 16;
    7. public MyStack() {
    8. elements = (T[]) new Object[INIT_CAPACITY];
    9. }
    10. public void push(T elem) {
    11. ensureCapacity();
    12. elements[size++] = elem;
    13. }
    14. public T pop() {
    15. if(size == 0)
    16. throw new EmptyStackException();
    17. return elements[--size];
    18. }
    19. private void ensureCapacity() {
    20. if(elements.length == size) {
    21. elements = Arrays.copyOf(elements, 2 * size + 1);
    22. }
    23. }
    24. }
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30

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

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

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

    27、闡述靜態變量和實例變量的區別。

    答:靜態變量是被static修飾符修飾的變量,也稱為類變量,它屬于類,不屬于類的任何一個對象,一個類不管創建多少個對象,靜態變量在內存中有且僅有一個拷貝;實例變量必須依存于某一實例,需要先創建對象然后通過對象才能訪問到它。靜態變量可以實現讓多個對象共享內存。

    補充:在Java開發中,上下文類和工具類中通常會有大量的靜態成員。

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

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

    29、如何實現對象克隆?

    答:有兩種方式:

    • 實現Cloneable接口并重寫Object類中的clone()方法; 
      ??
    • 實現Serializable接口,通過對象的序列化和反序列化實現克隆,可以實現真正的深度克隆,代碼如下。
    1. import java.io.ByteArrayInputStream;
    2. import java.io.ByteArrayOutputStream;
    3. import java.io.ObjectInputStream;
    4. import java.io.ObjectOutputStream;
    5. public class MyUtil {
    6. private MyUtil() {
    7. throw new AssertionError();
    8. }
    9. public static <T> T clone(T obj) throws Exception {
    10. ByteArrayOutputStream bout = new ByteArrayOutputStream();
    11. ObjectOutputStream oos = new ObjectOutputStream(bout);
    12. oos.writeObject(obj);
    13. ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
    14. ObjectInputStream ois = new ObjectInputStream(bin);
    15. return (T) ois.readObject();
    16. // 說明:調用ByteArrayInputStream或ByteArrayOutputStream對象的close方法沒有任何意義
    17. // 這兩個基于內存的流只要垃圾回收器清理對象就能夠釋放資源,這一點不同于對外部資源(如文件流)的釋放
    18. }
    19. }
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24

    下面是測試代碼:

    1. import java.io.Serializable;
    2. /**
    3. * 人類
    4. * @author 駱昊
    5. *
    6. */
    7. class Person implements Serializable {
    8. private static final long serialVersionUID = -9102017020286042305L;
    9. private String name; // 姓名
    10. private int age; // 年齡
    11. private Car car; // 座駕
    12. public Person(String name, int age, Car car) {
    13. this.name = name;
    14. this.age = age;
    15. this.car = car;
    16. }
    17. public String getName() {
    18. return name;
    19. }
    20. public void setName(String name) {
    21. this.name = name;
    22. }
    23. public int getAge() {
    24. return age;
    25. }
    26. public void setAge(int age) {
    27. this.age = age;
    28. }
    29. public Car getCar() {
    30. return car;
    31. }
    32. public void setCar(Car car) {
    33. this.car = car;
    34. }
    35. @Override
    36. public String toString() {
    37. return "Person [name=" + name + ", age=" + age + ", car=" + car + "]";
    38. }
    39. }
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    1. /**
    2. * 小汽車類
    3. * @author 駱昊
    4. *
    5. */
    6. class Car implements Serializable {
    7. private static final long serialVersionUID = -5713945027627603702L;
    8. private String brand; // 品牌
    9. private int maxSpeed; // 最高時速
    10. public Car(String brand, int maxSpeed) {
    11. this.brand = brand;
    12. this.maxSpeed = maxSpeed;
    13. }
    14. public String getBrand() {
    15. return brand;
    16. }
    17. public void setBrand(String brand) {
    18. this.brand = brand;
    19. }
    20. public int getMaxSpeed() {
    21. return maxSpeed;
    22. }
    23. public void setMaxSpeed(int maxSpeed) {
    24. this.maxSpeed = maxSpeed;
    25. }
    26. @Override
    27. public String toString() {
    28. return "Car [brand=" + brand + ", maxSpeed=" + maxSpeed + "]";
    29. }
    30. }
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    1. class CloneTest {
    2. public static void main(String[] args) {
    3. try {
    4. Person p1 = new Person("Hao LUO", 33, new Car("Benz", 300));
    5. Person p2 = MyUtil.clone(p1); // 深度克隆
    6. p2.getCar().setBrand("BYD");
    7. // 修改克隆的Person對象p2關聯的汽車對象的品牌屬性
    8. // 原來的Person對象p1關聯的汽車不會受到任何影響
    9. // 因為在克隆Person對象時其關聯的汽車對象也被克隆了
    10. System.out.println(p1);
    11. } catch (Exception e) {
    12. e.printStackTrace();
    13. }
    14. }
    15. }
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16

    注意:基于序列化和反序列化實現的克隆不僅僅是深度克隆,更重要的是通過泛型限定,可以檢查出要克隆的對象是否支持序列化,這項檢查是編譯器完成的,不是在運行時拋出異常,這種是方案明顯優于使用Object類的clone方法克隆對象。讓問題在編譯的時候暴露出來總是優于把問題留到運行時。

    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:+PrintGCDetails — 打印GC的細節
    • -XX:+PrintGCDateStamps — 打印GC操作的時間戳
    • -XX:NewSize / XX:MaxNewSize — 設置新生代大小/新生代最大大小
    • -XX:NewRatio — 可以設置老生代和新生代的比例
    • -XX:PrintTenuringDistribution — 設置每次新生代GC后輸出幸存者樂園中對象年齡的分布
    • -XX:InitialTenuringThreshold / -XX:MaxTenuringThreshold:設置老年代閥值的初始值和最大值
    • -XX:TargetSurvivorRatio:設置幸存區的目標使用率

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

    答:兩個對象,一個是靜態區的”xyz”,一個是用new創建在堆上的對象。

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

    答:接口可以繼承接口,而且支持多重繼承。抽象類可以實現(implements)接口,抽象類可繼承具體類也可以繼承抽象類。

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

    答:可以,但一個源文件中最多只能有一個公開類(public class)而且文件名必須和公開類的類名完全保持一致。

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

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

    35、內部類可以引用它的包含類(外部類)的成員嗎?有沒有什么限制?

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

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

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

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

    1. class A {
    2. static {
    3. System.out.print("1");
    4. }
    5. public A() {
    6. System.out.print("2");
    7. }
    8. }
    9. class B extends A{
    10. static {
    11. System.out.print("a");
    12. }
    13. public B() {
    14. System.out.print("b");
    15. }
    16. }
    17. public class Hello {
    18. public static void main(String[] args) {
    19. A ab = new B();
    20. ab = new B();
    21. }
    22. }
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30

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

    提示:如果不能給出此題的正確答案,說明之前第21題Java類加載機制還沒有完全理解,趕緊再看看吧。

    38、數據類型之間的轉換: 
    - 如何將字符串轉換為基本數據類型? 
    - 如何將基本數據類型轉換為字符串?

    答:

    • 調用基本數據類型對應的包裝類中的方法parseXXX(String)或valueOf(String)即可返回相應基本類型;
    • 一種方法是將基本數據類型與空字符串(”“)連接(+)即可獲得其所對應的字符串;另一種方法是調用String 類中的valueOf()方法返回相應字符串

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

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

    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. }
    • 1
    • 2
    • 3
    • 4
    • 5

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

    答:代碼如下所示:

    1. String s1 = "你好";
    2. String s2 = new String(s1.getBytes("GB2312"), "ISO-8859-1");
    • 1
    • 2

    41、日期和時間: 
    - 如何取得年月日、小時分鐘秒? 
    - 如何取得從1970年1月1日0時0分0秒到現在的毫秒數? 
    - 如何取得某月的最后一天? 
    - 如何格式化日期?

    答: 
    問題1:創建java.util.Calendar 實例,調用其get()方法傳入不同的參數即可獲得參數所對應的值。Java 8中可以使用java.time.LocalDateTimel來獲取,代碼如下所示。

    1. public class DateTimeTest {
    2. public static void main(String[] args) {
    3. Calendar cal = Calendar.getInstance();
    4. System.out.println(cal.get(Calendar.YEAR));
    5. System.out.println(cal.get(Calendar.MONTH)); // 0 - 11
    6. System.out.println(cal.get(Calendar.DATE));
    7. System.out.println(cal.get(Calendar.HOUR_OF_DAY));
    8. System.out.println(cal.get(Calendar.MINUTE));
    9. System.out.println(cal.get(Calendar.SECOND));
    10. // Java 8
    11. LocalDateTime dt = LocalDateTime.now();
    12. System.out.println(dt.getYear());
    13. System.out.println(dt.getMonthValue()); // 1 - 12
    14. System.out.println(dt.getDayOfMonth());
    15. System.out.println(dt.getHour());
    16. System.out.println(dt.getMinute());
    17. System.out.println(dt.getSecond());
    18. }
    19. }
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20

    問題2:以下方法均可獲得該毫秒數。

    1. Calendar.getInstance().getTimeInMillis();
    2. System.currentTimeMillis();
    3. Clock.systemDefaultZone().millis(); // Java 8
    • 1
    • 2
    • 3

    問題3:代碼如下所示。

    1. Calendar time = Calendar.getInstance();
    2. time.getActualMaximum(Calendar.DAY_OF_MONTH);
    • 1
    • 2

    問題4:利用java.text.DataFormat 的子類(如SimpleDateFormat類)中的format(Date)方法可將日期格式化。Java 8中可以用java.time.format.DateTimeFormatter來格式化時間日期,代碼如下所示。

    1. import java.text.SimpleDateFormat;
    2. import java.time.LocalDate;
    3. import java.time.format.DateTimeFormatter;
    4. import java.util.Date;
    5. class DateFormatTest {
    6. public static void main(String[] args) {
    7. SimpleDateFormat oldFormatter = new SimpleDateFormat("yyyy/MM/dd");
    8. Date date1 = new Date();
    9. System.out.println(oldFormatter.format(date1));
    10. // Java 8
    11. DateTimeFormatter newFormatter = DateTimeFormatter.ofPattern("yyyy/MM/dd");
    12. LocalDate date2 = LocalDate.now();
    13. System.out.println(date2.format(newFormatter));
    14. }
    15. }
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18

    補充:Java的時間日期API一直以來都是被詬病的東西,為了解決這一問題,Java 8中引入了新的時間日期API,其中包括LocalDate、LocalTime、LocalDateTime、Clock、Instant等類,這些的類的設計都使用了不變模式,因此是線程安全的設計。如果不理解這些內容,可以參考我的另一篇文章《關于Java并發編程的總結和思考》(http://blog.csdn.net/jackfrued/article/details/44499227)。

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

    答:

    1. import java.util.Calendar;
    2. class YesterdayCurrent {
    3. public static void main(String[] args){
    4. Calendar cal = Calendar.getInstance();
    5. cal.add(Calendar.DATE, -1);
    6. System.out.println(cal.getTime());
    7. }
    8. }
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9

    在Java 8中,可以用下面的代碼實現相同的功能。

    1. import java.time.LocalDateTime;
    2. class YesterdayCurrent {
    3. public static void main(String[] args) {
    4. LocalDateTime today = LocalDateTime.now();
    5. LocalDateTime yesterday = today.minusDays(1);
    6. System.out.println(yesterday);
    7. }
    8. }
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11

    43、比較一下Java和JavaSciprt。

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

    • 基于對象和面向對象:Java是一種真正的面向對象的語言,即使是開發簡單的程序,必須設計對象;JavaScript是種腳本語言,它可以用來制作與網絡無關的,與用戶交互作用的復雜軟件。它是一種基于對象(Object-Based)和事件驅動(Event-Driven)的編程語言,因而它本身提供了非常豐富的內部對象供設計人員使用。
    • 解釋和編譯:Java的源代碼在執行之前,必須經過編譯。JavaScript是一種解釋性編程語言,其源代碼不需經過編譯,由瀏覽器解釋執行。(目前的瀏覽器幾乎都使用了JIT(即時編譯)技術來提升JavaScript的運行效率)
    • 強類型變量和類型弱變量:Java采用強類型變量檢查,即所有變量在編譯之前必須作聲明;JavaScript中變量是弱類型的,甚至在使用變量前可以不作聲明,JavaScript的解釋器在運行時檢查推斷其數據類型。
    • 代碼格式不一樣。

      補充:上面列出的四點是網上流傳的所謂的標準答案。其實Java和JavaScript最重要的區別是一個是靜態語言,一個是動態語言。目前的編程語言的發展趨勢是函數式語言和動態語言。在Java中類(class)是一等公民,而JavaScript中函數(function)是一等公民,因此JavaScript支持函數式編程,可以使用Lambda函數和閉包(closure),當然Java 8也開始支持函數式編程,提供了對Lambda表達式以及函數式接口的支持。對于這類問題,在面試的時候最好還是用自己的語言回答會更加靠譜,不要背網上所謂的標準答案。

    44、什么時候用斷言(assert)?

    答:斷言在軟件開發中是一種常用的調試方式,很多開發語言中都支持這種機制。一般來說,斷言用于保證程序最基本、關鍵的正確性。斷言檢查通常在開發和測試時開啟。為了保證程序的執行效率,在軟件發布后斷言檢查通常是關閉的。斷言是一個包含布爾表達式的語句,在執行這個語句時假定該表達式為true;如果表達式的值為false,那么系統會報告一個AssertionError。斷言的使用如下面的代碼所示:

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

    斷言可以有兩種形式: 
    assert Expression1; 
    assert Expression1 : Expression2 ; 
    Expression1 應該總是產生一個布爾值。 
    Expression2 可以是得出一個值的任意表達式;這個值用于生成顯示更多調試信息的字符串消息。

    要在運行時啟用斷言,可以在啟動JVM時使用-enableassertions或者-ea標記。要在運行時選擇禁用斷言,可以在啟動JVM時使用-da或者-disableassertions標記。要在系統類中啟用或禁用斷言,可使用-esa或-dsa標記。還可以在包的基礎上啟用或者禁用斷言。

    注意:斷言不應該以任何方式改變程序的狀態。簡單的說,如果希望在不滿足某些條件時阻止代碼的執行,就可以考慮用斷言來阻止它。

    45、Error和Exception有什么區別?

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

    面試題:2005年摩托羅拉的面試中曾經問過這么一個問題“If a process reports a stack overflow run-time error, what’s the most possible cause?”,給了四個選項a. lack of memory; b. write on an invalid memory space; c. recursive function calling; d. array index out of boundary. Java程序在運行時也可能會遭遇StackOverflowError,這是一個無法恢復的錯誤,只能重新修改代碼了,這個面試題的答案是c。如果寫了不能迅速收斂的遞歸,則很有可能引發棧溢出的錯誤,如下所示:
      1. class StackOverflowErrorTest {
      2. public static void main(String[] args) {
      3. main(null);
      4. }
      5. }
      • 1
      • 2
      • 3
      • 4
      • 5
      • 6

      提示:用遞歸編寫程序時一定要牢記兩點:1. 遞歸公式;2. 收斂條件(什么時候就不再繼續遞歸)。

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

      答:會執行,在方法返回調用者前執行。

      注意:在finally中改變返回值的做法是不好的,因為如果存在finally代碼塊,try中的return語句不會立馬返回調用者,而是記錄下返回值待finally代碼塊執行完畢之后再向調用者返回其值,然后如果在finally中修改了返回值,就會返回修改后的值。顯然,在finally中返回或者修改返回值會對程序造成很大的困擾,C#中直接用編譯錯誤的方式來阻止程序員干這種齷齪的事情,Java中也可以通過提升編譯器的語法檢查級別來產生警告或錯誤,Eclipse中可以在如圖所示的地方進行設置,強烈建議將此項設置為編譯錯誤。

      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語句或者最終將異常拋給JVM。

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

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

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

      49、列出一些你常見的運行時異常? 
      答:

      • ArithmeticException(算術異常)
      • ClassCastException (類轉換異常)
      • IllegalArgumentException (非法參數異常)
      • IndexOutOfBoundsException (下標越界異常)
      • NullPointerException (空指針異常)
      • SecurityException (安全異常)

      50、闡述final、finally、finalize的區別。 
      答:

      • final:修飾符(關鍵字)有三種用法:如果一個類被聲明為final,意味著它不能再派生出新的子類,即不能被繼承,因此它和abstract是反義詞。將變量聲明為final,可以保證它們在使用中不被改變,被聲明為final的變量必須在聲明時給定初值,而在以后的引用中只能讀取不可修改。被聲明為final的方法也同樣只能使用,不能在子類中被重寫。
      • finally:通常放在try…catch…的后面構造總是執行代碼塊,這就意味著程序無論正常執行還是發生異常,這里的代碼只要JVM不關閉都能執行,可以將釋放外部資源的代碼寫在finally塊中。
      • finalize:Object類中定義的方法,Java中允許使用finalize()方法在垃圾收集器將對象從內存中清除出去之前做必要的清理工作。這個方法是由垃圾收集器在銷毀對象時調用的,通過重寫finalize()方法可以整理系統資源或者執行其他清理工作。

      我來說兩句
      您需要登錄后才可以評論 登錄 | 立即注冊
      facelist
      所有評論(1)
      聞代碼識大神 2018-11-13 10:36
      贊一個
      回復
      領先的中文移動開發者社區
      18620764416
      7*24全天服務
      意見反饋:[email protected]

      掃一掃關注我們

      Powered by Discuz! X3.2© 2001-2019 Comsenz Inc.( 粵ICP備15117877號 )

      两码中特期期