Java回顧之一些基礎概念

　　第一篇：Java回顧之I/O

　　第二篇：Java回顧之網絡通信

　　第三篇：Java回顧之多線程

　　第四篇：Java回顧之多線程同步

　　第五篇：Java回顧之集合

　　第六篇：Java回顧之序列化

　　第七篇：Java回顧之反射

 

　　這兩天，無意間在網上翻到一本關於Java面試解惑的文章集，里面提到了很多基礎的概念，但一不留神，還是可能會“掉到坑里”。里面的文章寫的很不錯，大家可以通過下面的地址下載：http://zangweiren.iteye.com/blog/241218

　　在看上述文章的時候，隨手寫了一些測試代碼，以便加深理解。這也就是這篇文章的來源了。

　　類的初始化順序

　　在Java中，類里面可能包含：靜態變量，靜態初始化塊，成員變量，初始化塊，構造函數。在類之間可能存在着繼承關系，那么當我們實例化一個對象時，上述各部分的加載順序是怎樣的？

　　首先來看代碼：

class Parent
{
    public static StaticVarible staticVarible= new StaticVarible("父類-靜態變量1");    
    public StaticVarible instVarible= new StaticVarible("父類-成員變量1");
    
    static
    {
        System.out.println("父類-靜態塊");
    }
    
    {
        System.out.println("父類-初始化塊");
    }
    
    public static StaticVarible staticVarible2= new StaticVarible("父類-靜態變量2");    
    public StaticVarible instVarible2= new StaticVarible("父類-成員變量2");
    
    public Parent()
    {
        System.out.println("父類-實例構造函數");
    }
}

class Child extends Parent
{
    public static StaticVarible staticVarible= new StaticVarible("子類-靜態變量1");    
    public StaticVarible instVarible= new StaticVarible("子類-成員變量1");
    
    static
    {
        System.out.println("子類-靜態塊");
    }
    
    public Child()
    {
        System.out.println("子類-實例構造函數");
    }
    
    {
        System.out.println("子類-初始化塊");
    }
    
    public static StaticVarible staticVarible2= new StaticVarible("子類-靜態變量2");    
    public StaticVarible instVarible2= new StaticVarible("子類-成員變量2");
    
    
}

class StaticVarible
{
    public StaticVarible(String info)
    {
        System.out.println(info);
    }
}

　　然后執行下面的語句：

Child child = new Child();

　　輸出結果如下：

父類-靜態變量1
父類-靜態塊
父類-靜態變量2
子類-靜態變量1
子類-靜態塊
子類-靜態變量2
父類-成員變量1
父類-初始化塊
父類-成員變量2
父類-實例構造函數
子類-成員變量1
子類-初始化塊
子類-成員變量2
子類-實例構造函數

　　結論　　

　　從上述結果可以看出，在實例化一個對象時，各部分的加載順序如下：

　　父類靜態成員/父類靜態初始化塊 -> 子類靜態成員/子類靜態初始化塊 -> 父類成員變量/父類初始化塊 -> 父類構造函數 -> 子類成員變量/子類初始化塊 -> 子類構造函數

　　和String相關的一些事兒

　　首先，我們聊一聊Java中堆和棧的事兒。

• 棧：存放基本類型，包括char/byte/short/int/long/float/double/boolean
• 堆：存放引用類型，同時一般會在棧中保留一個指向它的指針，垃圾回收判斷一個對象是否可以回收，就是判斷棧中是否有指針指向堆中的對象。

　　String作為一種特殊的數據類型，它不完全等同於基本類型，也不是全部的引用類型，許多面試題都有它的身影。

　　String類型變量的存儲結構

　　String的存儲結構分為兩部分，我們以String a = "abc";為例，描述String類型的存儲方式：

　　1）在棧中創建一個char數組，值分為是'a'，'b'，'c'。

　　2）在堆中創建一個String對象。

　　Java中的字符串池

　　為了節省空間和資源，JVM會維護一個字符串池，或者說會緩存一部分曾經出現過的字符串。

　　例如下面的代碼：

String v1 = "ab";
String v2 = "ab";

　　實際上，v1==v2，因為JVM在v1聲明后，已經對“ab”進行了緩存。

　　那么JVM對字符串進行緩存的依據是什么？我們來看下面的代碼，非常有意思：

public class StringTest {
    public static final String constValue = "ab";
    public static final String staticValue;
    
    static
    {
        staticValue="ab";
    }
    
    public static void main(String[] args)
    {
        String v1 = "ab";
        String v2 = "ab";
        System.out.println("v1 == v2 : " + (v1 == v2));
        String v3 = new String("ab");
        System.out.println("v1 == v3 : " + (v1 == v3));
        String v4 = "abcd";
        String v5 = "ab" + "cd";
        System.out.println("v4 == v5 : " + (v4 == v5));
        String v6 = v1 + "cd";
        System.out.println("v4 == v6 : " + (v4 == v6));
        String v7 = constValue + "cd";
        System.out.println("v4 == v7 : " + (v4 == v7));
        String v8 = staticValue + "cd";
        System.out.println("v4 == v8 : " + (v4 == v8));
        String v9 = v4.intern();
        System.out.println("v4 == v9 :" + (v4 == v9));
        String v10 = new String(new char[]{'a','b','c','d'});
        String v11 = v10.intern();
        System.out.println("v4 == v11 :" + (v4 == v11));
        System.out.println("v10 == v11 :" + (v10 == v11));
    }
}

　　請注意它的輸出結果：

v1 == v2 : true
v1 == v3 : false
v4 == v5 : true
v4 == v6 : false
v4 == v7 : true
v4 == v8 : false
v4 == v9 :true
v4 == v11 :true
v10 == v11 :false

　　我們會發現，並不是所有的判斷都返回true，這似乎和我們上面的說法有矛盾了。其實不然，因為

　　結論

　　1. JVM只能緩存那些在編譯時可以確定的常量，而非運行時常量。

　　　　上述代碼中的constValue屬於編譯時常量，而staticValue則屬於運行時常量。

　　2. 通過使用 new方式創建出來的字符串，JVM緩存的方式是不一樣的。

　　　　所以上述代碼中，v1不等同於v3。

　　String的這種設計屬於享元模式嗎？

　　這個話題比較有意思，大部分講設計模式的文章，在談到享元時，一般就會拿String來做例子，但它屬於享元模式嗎？

　　字符串與享元的關系，大家可以參考下面的文章：http://www.cnblogs.com/winter-cn/archive/2012/01/21/2328388.html

　　字符串的反轉輸出

　　這種情況下，一般會將字符串看做是字符數組，然后利用反轉數組的方式來反轉字符串。

　　眼花繚亂的方法調用

　　有繼承關系結構中的方法調用

　　繼承是面向對象設計中的常見方式，它可以有效的實現”代碼復用“，同時子類也有重寫父類方法的自由，這就對到底是調用父類方法還是子類方法帶來了麻煩。

　　來看下面的代碼：

public class PropertyTest {

    public static void main(String[] args)
    {
        ParentDef v1 = new ParentDef();
        ParentDef v2 = new ChildDef();
        ChildDef v3 = new ChildDef();
        System.out.println("=====v1=====");
        System.out.println("staticValue:" + v1.staticValue);
        System.out.println("value:" + v1.value);
        System.out.println("=====v2=====");
        System.out.println("staticValue:" + v2.staticValue);
        System.out.println("value:" + v2.value);
        System.out.println("=====v3=====");
        System.out.println("staticValue:" + v3.staticValue);
        System.out.println("value:" + v3.value);
    }
}

class ParentDef
{
    public static final String staticValue = "父類靜態變量";
    public String value = "父類實例變量";
}

class ChildDef extends ParentDef
{
    public static final String staticValue = "子類靜態變量";
    public String value = "子類實例變量";
}

　　輸出結果如下：

=====v1=====
staticValue:父類靜態變量
value:父類實例變量
=====v2=====
staticValue:父類靜態變量
value:父類實例變量
=====v3=====
staticValue:子類靜態變量
value:子類實例變量

　　結論

　　對於調用父類方法還是子類方法，只與變量的聲明類型有關系，與實例化的類型沒有關系。

　　到底是值傳遞還是引用傳遞

　　對於這個話題，我的觀點是值傳遞，因為傳遞的都是存儲在棧中的內容，無論是基本類型的值，還是指向堆中對象的指針，都是值而非引用。並且在值傳遞的過程中，JVM會將值復制一份，然后將復制后的值傳遞給調用方法。

　　按照這種方式，我們來看下面的代碼：

public class ParamTest {

    public void change(int value)
    {
        value = 10;
    }
    
    public void change(Value value)
    {
        Value temp = new Value();
        temp.value = 10;
        value = temp;
    }
    
    public void add(int value)
    {
        value += 10;
    }
    
    public void add(Value value)
    {
        value.value += 10;
    }
    
    public static void main(String[] args)
    {
        ParamTest test = new ParamTest();
        Value value = new Value();
        int v = 0;
        System.out.println("v:" + v);
        System.out.println("value.value:" + value.value);
        System.out.println("=====change=====");
        test.change(v);
        test.change(value);
        System.out.println("v:" + v);
        System.out.println("value.value:" + value.value);
        value = new Value();
        v = 0;
        System.out.println("=====add=====");
        test.add(v);
        test.add(value);
        System.out.println("v:" + v);
        System.out.println("value.value:" + value.value);
    }
}

class Value
{
    public int value;
}

　　它的輸出結果：

v:0
value.value:0
=====change=====
v:0
value.value:0
=====add=====
v:0
value.value:10

　　我們看到，在調用change方法時，即使我們傳遞進去的是指向對象的指針，但最終對象的屬性也沒有變，這是因為在change方法體內，我們新建了一個對象，然后將”復制過的指向原對象的指針“指向了“新對象”，並且對新對象的屬性進行了調整。但是“復制前的指向原對象的指針”依然是指向“原對象”，並且屬性沒有任何變化。

　　final/finally/finalize的區別

　　final可以修飾類、成員變量、方法以及方法參數。使用final修飾的類是不可以被繼承的，使用final修飾的方法是不可以被重寫的，使用final修飾的變量，只能被賦值一次。

　　使用final聲明變量的賦值時機：

　　1）定義聲明時賦值

　　2）初始化塊或靜態初始化塊中

　　3）構造函數

　　來看下面的代碼：

class FinalTest
{
    public static final String staticValue1 = "靜態變量1";
    public static final String staticValue2;
    
    static
    {
        staticValue2 = "靜態變量2";
    }
    
    public final String value1 = "實例變量1";
    public final String value2;
    public final String value3;
    
    {
        value2 = "實例變量2";
    }
    
    public FinalTest()
    {
        value3 = "實例變量3";
    }
}

　　finally一般是和try...catch放在一起使用，主要用來釋放一些資源。

　　我們來看下面的代碼：

public class FinallyTest {

    public static void main(String[] args)
    {
        finallyTest1();
        finallyTest2();
        finallyTest3();
    }
    
    private static String finallyTest1()
    {
        try
        {
            throw new RuntimeException();
        }
        catch(Exception ex)
        {
            ex.printStackTrace();
        }
        finally
        {
            System.out.println("Finally語句被執行");
        }
        try
        {
            System.out.println("Hello World");
            return "Hello World";
        }
        catch(Exception ex)
        {
            ex.printStackTrace();
        }
        finally
        {
            System.out.println("Finally語句被執行");
        }
        return null;
    }
    
    private static void finallyTest2()
    {
        int i = 0;
        for (i = 0; i < 3; i++)
        {
            try
            {
                if (i == 2) break;
                System.out.println(i);
            }
            finally
            {
                System.out.println("Finally語句被執行");
            }
        }
    }
    
    private static Test finallyTest3()
    {
        try
        {
            return new Test();
        }
        finally
        {
            System.out.println("Finally語句被執行");
        }
    }
}

　　執行結果如下：

java.lang.RuntimeException
    at sample.interview.FinallyTest.finallyTest1(FinallyTest.java:16)
    at sample.interview.FinallyTest.main(FinallyTest.java:7)
Finally語句被執行
Hello World
Finally語句被執行
0
Finally語句被執行
1
Finally語句被執行
Finally語句被執行
Test實例被創建
Finally語句被執行

　　注意在循環的過程中，對於某一次循環，即使調用了break或者continue，finally也會執行。

　　finalize則主要用於釋放資源，在調用GC方法時，該方法就會被調用。

　　來看下面的示例：

class FinalizeTest
{
    protected void finalize()
    {
        System.out.println("finalize方法被調用");
    }
    
    public static void main(String[] args)
    {
        FinalizeTest test = new FinalizeTest();
        test = null;
        Runtime.getRuntime().gc();
    }
}

　　執行結果如下：

finalize方法被調用

　　關於基本類型的一些事兒

　　基本類型供分為9種，包括byte/short/int/long/float/double/boolean/void，每種基本類型都對應一個“包裝類”，其他一些基本信息如下：

1. 基本類型：byte 二進制位數：8
2. 包裝類：java.lang.Byte
3. 最小值：Byte.MIN_VALUE=-128
4. 最大值：Byte.MAX_VALUE=127
5. 基本類型：short 二進制位數：16
6. 包裝類：java.lang.Short
7. 最小值：Short.MIN_VALUE=-32768
8. 最大值：Short.MAX_VALUE=32767
9. 基本類型：int 二進制位數：32
10. 包裝類：java.lang.Integer
11. 最小值：Integer.MIN_VALUE=-2147483648
12. 最大值：Integer.MAX_VALUE=2147483647
13. 基本類型：long 二進制位數：64
14. 包裝類：java.lang.Long
15. 最小值：Long.MIN_VALUE=-9223372036854775808
16. 最大值：Long.MAX_VALUE=9223372036854775807
17. 基本類型：float 二進制位數：32
18. 包裝類：java.lang.Float
19. 最小值：Float.MIN_VALUE=1.4E-45
20. 最大值：Float.MAX_VALUE=3.4028235E38
21. 基本類型：double 二進制位數：64
22. 包裝類：java.lang.Double
23. 最小值：Double.MIN_VALUE=4.9E-324
24. 最大值：Double.MAX_VALUE=1.7976931348623157E308
25. 基本類型：char 二進制位數：16
26. 包裝類：java.lang.Character
27. 最小值：Character.MIN_VALUE=0
28. 最大值：Character.MAX_VALUE=65535

　　關於基本類型的一些結論（來自《Java面試解惑》）

• 未帶有字符后綴標識的整數默認為int類型；未帶有字符后綴標識的浮點數默認為double類型。
• 如果一個整數的值超出了int類型能夠表示的范圍，則必須增加后綴“L”（不區分大小寫，建議用大寫，因為小寫的L與阿拉伯數字1很容易混淆），表示為long型。
• 帶有“F”（不區分大小寫）后綴的整數和浮點數都是float類型的；帶有“D”（不區分大小寫）后綴的整數和浮點數都是double類型的。
• 編譯器會在編譯期對byte、short、int、long、float、double、char型變量的值進行檢查，如果超出了它們的取值范圍就會報錯。
• int型值可以賦給所有數值類型的變量；long型值可以賦給long、float、double類型的變量；float型值可以賦給float、double類型的變量；double型值只能賦給double類型變量。

　　關於基本類型之間的轉換

　　下面的轉換是無損精度的轉換：

• byte->short
• short->int
• char->int
• int->long
• float->double

　　下面的轉換是會損失精度的：

• int->float
• long->float
• long->double

　　除此之外的轉換，是非法的。

　　和日期相關的一些事兒

　　Java中，有兩個類和日期相關，一個是Date，一個是Calendar。我們來看下面的示例：

public class DateTest {

    public static void main(String[] args) throws ParseException
    {
        test1();
        test2();
        test3();
    }
    
    private static void test1() throws ParseException
    {
        Date date = new Date();
        System.out.println(date);
        DateFormat sf = new SimpleDateFormat("yyyy-MM-dd");
        System.out.println(sf.format(date));
        String formatString = "2013-05-12";
        System.out.println(sf.parse(formatString));
    }
    
    private static void test2()
    {
        Date date = new Date();
        System.out.println("Year:" + date.getYear());
        System.out.println("Month:" + date.getMonth());
        System.out.println("Day:" + date.getDate());
        System.out.println("Hour:" + date.getHours());
        System.out.println("Minute:" + date.getMinutes());
        System.out.println("Second:" + date.getSeconds());
        System.out.println("DayOfWeek:" + date.getDay());
    }
    
    private static void test3()
    {
        Calendar c = Calendar.getInstance();
        System.out.println(c.getTime());
        System.out.println(c.getTimeZone());
        System.out.println("Year:" + c.get(Calendar.YEAR));
        System.out.println("Month:" + c.get(Calendar.MONTH));
        System.out.println("Day:" + c.get(Calendar.DATE));
        System.out.println("Hour:" + c.get(Calendar.HOUR));
        System.out.println("HourOfDay:" + c.get(Calendar.HOUR_OF_DAY));
        System.out.println("Minute:" + c.get(Calendar.MINUTE));
        System.out.println("Second:" + c.get(Calendar.SECOND));
        System.out.println("DayOfWeek:" + c.get(Calendar.DAY_OF_WEEK));
        System.out.println("DayOfMonth:" + c.get(Calendar.DAY_OF_MONTH));
        System.out.println("DayOfYear:" + c.get(Calendar.DAY_OF_YEAR));
    }
}

　　輸出結果如下：

Sat May 11 13:44:34 CST 2013
2013-05-11
Sun May 12 00:00:00 CST 2013
Year:113
Month:4
Day:11
Hour:13
Minute:44
Second:35
DayOfWeek:6
Sat May 11 13:44:35 CST 2013
sun.util.calendar.ZoneInfo[id="Asia/Shanghai",offset=28800000,dstSavings=0,useDaylight=false,transitions=19,lastRule=null]
Year:2013
Month:4
Day:11
Hour:1
HourOfDay:13
Minute:44
Second:35
DayOfWeek:7
DayOfMonth:11
DayOfYear:131

　　需要注意的是，Date中的getxxx方法已經變成deprecated了，因此我們盡量使用calendar.get方法來獲取日期的細節信息。

　　另外，注意DateFormat，它不僅可以對日期的輸出進行格式化，而且可以逆向操作，將符合Format的字符串轉換為日期類型。