動態(tài)綁定的典型，就是父類的引用可以引用任何子類的實例。比如有如下父類子類關系，介紹說明動態(tài)綁定的具體過程：

Parent p = new Children();

1. 編譯器檢查對象的聲明類型和方法名；
   • 假如我們有 Children 的實例對象 child，此時想要調(diào)用 Children 的 fun(args) 方法，那么編譯器就會列舉出所有名稱為 fun 的方法（所有方法簽名相同，參數(shù)列表不同的 fun 方法），并列舉 Children 的超類 Parent 中 fun 方法；
2. 編譯器檢查方法調(diào)用中提供的參數(shù)類型；
   • 如果所有簽名為 fun 的方法中，有一個參數(shù)類型和調(diào)用時提供的參數(shù)類型最匹配，那么就調(diào)用該方法。該過程成為<font color=red>重載解析</font>；
3. 當程序運行并使用動態(tài)綁定調(diào)用方法時，虛擬機必須調(diào)用與 child 指向的對象的實際類型相匹配的方法版本。調(diào)用方法的時候，如果當前子類已經(jīng)對父類實現(xiàn)了方法的重寫，則調(diào)用子類重寫后的方法；否則只調(diào)用父類的方法。即如果子類 Children 中如果實現(xiàn)了對應的 fun(args) 方法，則調(diào)用 Children 的方法，否則就在父類 Parent 中尋找；在 Parent 中找不到，則在 Parent 的父類中找，直到最頂層的父類。

JVM 調(diào)用一個類方法時（即標注 static 的靜態(tài)方法），它會基于對象引用的類型來選擇所調(diào)用的方法，通常在編譯時 JVM 就知道了要調(diào)用什么方法，這就是靜態(tài)綁定。相反，如果 JVM 調(diào)用一個實例對象方法時，它會基于對象實際的類型來選擇所調(diào)用的方法，具體調(diào)用什么方法只能在運行時得知。這就是動態(tài)綁定，是多態(tài)的一種。動態(tài)綁定為解決實際的業(yè)務問題提供了很大的靈活性，是一種非常優(yōu)美的機制。

參考網(wǎng)址：《Java靜態(tài)綁定與動態(tài)綁定》

3. 類的初始化順序

創(chuàng)建一個實例對象時，考慮到該對象的父子關系，JVM 按照一定的順序進行初始化：

1. 先父類靜態(tài)，再子類靜態(tài)
2. 父類的定義初始化 + 構(gòu)造函數(shù)
3. 子類定義初始化 + 構(gòu)造函數(shù)

以例程來說明初始化順序：

package oop4;

public class Test2 {
    public static void main(String[] args) {
        D d = new D();
    }
}
class C{
    // C 的定義初始化
    {System.out.println("aa..");}
    // C 的靜態(tài)初始化
    static{
        System.out.println("bb..");
    }
    // C 的構(gòu)造函數(shù)
    C(){System.out.println("cc..");}
}
class D extends C{
    // D 的定義初始化
    {System.out.println("dd...");}
    // D 的靜態(tài)初始化
    static{
        System.out.println("ee..");
    }
    // D 的構(gòu)造函數(shù)
    D(){
        System.out.println("ff...");
    }
}

分析該段程序，先后順序應該如下：

1. 父類 C 的靜態(tài)初始化：bb..
2. 子類 D 的靜態(tài)初始化：ee..
3. 父類 C 的定義初始化：aa..
4. 父類 C 的構(gòu)造函數(shù)：cc..
5. 子類 D 的定義初始化：dd...
6. 子類 D 的構(gòu)造函數(shù)：ff...

綜上所述，該段程序輸出的結(jié)果：

bb..
ee..
aa..
cc..
dd...
ff...

4. Java 的單繼承

Java 中的繼承只能是<font color=red>單一繼承</font>，即 extends 關鍵字只能有一個類名；但 java 的繼承具有傳遞性。

為什么 Java 只能單繼承，而不像 C++ 一樣能夠多繼承？從技術(shù)的角度來說，是為了降低復雜性。例如，A 類中有一個 m 方法，B 類中也有一個 m 方法。如果 C 類單獨繼承 A 類或者 B 類時，C 類中的 m 方法要么繼承于 A 類，要么繼承于 B 類。而如果多重繼承的話，C 類的 m 方法有可能來自 A 類，又有可能來自 B 類，就會造成沖突。這樣的繼承關系，就會增加復雜性，甚至進一步影響多態(tài)的靈活性。

此外，java.lang.Object 是一切類的父類。或者可以說，如果一個類沒有父類，那么它的父類就是 java.lang.Object。Object 類型有幾個方法比較實用：

• equals 方法：用來判斷兩個 obj 對象的地址是否相等。
  • 由于 Object 的原始 equals 方法比較時，比較雙方如果地址相同，則返回 true，否則返回 false，所以對于很多 Object 的子類并不適用，故很多 Object 的子類經(jīng)常會重寫 equals 方法。以后如果有調(diào)用 equals 方法的時候，需要了解該 equals 方法的具體意義；
• toString() 方法：打印一個對象，就會打印該對象的 toString 的返回值；

如果要判斷一個實例對象 obj 是否屬于某個類型 T，可以使用關鍵字 instanceof。對于表達式 obj instanceof T，如果實例 obj 屬于 T 類型，則返回 true；否則返回 false。

5. 抽象類

對于普通的類，其本身就是一個完善的功能類，可以直接產(chǎn)生實例化對象，并且在普通類中可以包含構(gòu)造方法、普通方法、static 方法、常量和變量等內(nèi)容。抽象類，就是指在普通類的結(jié)構(gòu)里面增加抽象方法的組成部分。

那么什么叫抽象方法呢？抽象方法，是指沒有方法體的方法，即一個方法只有聲明，沒有實現(xiàn)。同時抽象方法還必須用 abstract 關鍵字來聲明。只要擁有一個抽象方法的類就是抽象類。

抽象類的使用原則如下：

• 抽象方法必須為 public 或者 protected（因為如果為 private，則不能被子類繼承，子類便無法實現(xiàn)該方法），缺省情況下，默認為public；
• 抽象類不能直接實例化，需要依靠子類采用向上轉(zhuǎn)型的方式處理；
• 抽象類必須有子類，使用 extends 繼承，一個子類只能繼承一個抽象類；
• 對于不是抽象類的子類，必須覆寫抽象類之中的全部抽象方法（如果子類沒有實現(xiàn)父類的抽象方法，則必須將子類也定義為 abstract 類）；

對于抽象類，還有一些需要注意的地方：

• 抽象類繼承子類，其中有明確的方法覆寫要求，而普通類可以有選擇性的來決定是否需要覆寫；
• 抽象類實際上就比普通類多了一些抽象方法而已，其他組成部分和普通類完全一樣；
• 普通類對象可以直接實例化，但抽象類的對象必須經(jīng)過向上轉(zhuǎn)型之后才可以得到。

可以看出，雖然一個類的子類可以去繼承任意的一個普通類，可是從開發(fā)的實際要求來講，普通類盡量不要去繼承另外一個普通類，而是去繼承抽象類。

6. final 關鍵字

在 Java 中，final 關鍵字可以用來修飾類、方法和變量（包括成員變量和局部變量）。

用 final 關鍵字修飾變量：

• final 關鍵字來修飾類的變量，只能被賦一次值。
• final 修飾的成員變量也只能賦值一次；但在對象創(chuàng)建的時候，成員變量必須賦值，即在定義初始化或構(gòu)造函數(shù)中對 final 修飾的成員變量進行賦值；
• java 語言中沒有常量，但可以<font color=red>通過 public static final</font> 來定義常量，且一般大寫；
  • 例：public static final int CELL_WIDTH = 50;

用 final 關鍵字修飾的類不能被繼承；例如，String, Math 類就是 Java 中典型的 final 關鍵字修飾的類；
用 final 關鍵字修飾的方法，不能夠被重寫。

需要注意的是，用 final 修飾的數(shù)組，與普通的變量理解起來難度。如下例中：

//========================================
final int a = 10;
a = 20; // 錯誤，a 變量只能賦值一次
//========================================
final int[] b = {1, 2, 3, 4};
b[0] = 10; // 正確
//========================================

int 類型的 a 由于被 final 關鍵字修飾，所以不能被二次賦值，這比較容易理解。但下面的例子中，看起來好像是數(shù)組的二次賦值也可以完成。其實實際上對于被 final 關鍵字修飾的數(shù)組而言，數(shù)組的引用地址是不能改變的。上例程中，b[0] = 10 僅改變了 b 數(shù)組 0 位置的元素內(nèi)容而已，而該位置的地址引用沒有發(fā)生任何改變，所以是可以完成的。

7. 接口

接口體現(xiàn)的是一種標準，外部體現(xiàn)為方法的聲明。接口用關鍵字 interface 修飾。提供一個接口，是為了實現(xiàn)某種標準的對接過程，而實現(xiàn)接口，就是意味著符合這個標準。對接口的實現(xiàn)，需要使用 implements 關鍵字。實現(xiàn)一個接口，就要重寫接口中的方法；換個角度來說，如果不實現(xiàn)接口，就變成了一個抽象類。

接口里的方法，默認都是 public abstract 類型的。此外接口里也可以聲明變量，變量的類型也默認為 public static final 類型。例如：

public interface Memory {
    public void memo(); // 等價于 public abstract void memo();
    int i = 1; // 等價于 public static final int i = 1;
}

Java 中的接口與繼承最大的不同是，繼承是單一繼承，但接口與接口之間可以多繼承。此外一個類可以繼承一個父類，同時實現(xiàn)多個接口。舉一個例子，如何定義一個英雄？我們假定一個人，如果同時滿足可以飛、可以打架、可以游泳，那么他就是一個英雄。同時，人又屬于動物。那么我們就可以定義英雄 Hero 如下：

public class Hero extends Animal implemets CanFly, CanFight, CanSwim {}

上例中，也可以看到接口與繼承的另一個區(qū)別：繼承體現(xiàn)了 is-a 關系（單繼承），接口體現(xiàn)了 can-do 關系（多繼承）。

接口與抽象又有一些相似的共同點：如果看到接口類型的引用，那么引用的一定是實現(xiàn)了該接口的類的實例；如果看到抽象類型的引用，那么引用的一定是繼承了該抽象類的類的實例。

8. 內(nèi)部類

使用內(nèi)部類的原因，在于內(nèi)部類提供了更好的封裝，只有外部類可以訪問內(nèi)部類。此外內(nèi)部類中的屬性和方法，即使是外部類也不能直接訪問，相反，內(nèi)部類可以直接訪問包括 private 聲明的外部類的屬性和方法。另外屬于內(nèi)部類的匿名內(nèi)部類也十分利于回調(diào)函數(shù)的編寫。

內(nèi)部類與外部類是一個相對獨立的實體，它與外部類并不是 is-a 關系。比如我們定義了內(nèi)部類外部類的 OuterClass.java 如下：

public class OuterClass {
    private String outerName;
    private int outerAge;
    public class InnerClass{
        private String innerName;
        private int innerAge;
    }
}

在該文件的路徑下輸入指令：

javac OuterClass.java

結(jié)果如圖：

3-01.png

從編譯的結(jié)果就可以看出來，編譯后外部類及其內(nèi)部類會生成兩個獨立的 .class 文件：OuterClass.class 和 OuterClass$InnerClass.class。說明內(nèi)部類是一個編譯時的概念。

此外，內(nèi)部類可以直接訪問外部類的元素，但是外部類不可以直接訪問內(nèi)部類的元素；而且外部類可以通過內(nèi)部類引用間接訪問內(nèi)部類元素。

關于內(nèi)部類的創(chuàng)建，如果在外部類中創(chuàng)建內(nèi)部類，那么就和普通的創(chuàng)建對象是一樣的：

InnerClass innerClass = new InnerClass();

如果在外部類之外創(chuàng)建外部類中的內(nèi)部類（有點拗口），就需要 outerClass.new 來創(chuàng)建：

//================================================
OuterClass outerClass = new OuterClass();
OuterClass.InnerClass innerClass = outerClass.new InnerClass();
//================================================
// 或者一步到位的方法：
OuterClass.InnerClass innerClass = new OuterClass().new InnerClass();
//================================================

Java中內(nèi)部類主要分為四種：成員內(nèi)部類、方法內(nèi)部類、匿名內(nèi)部類、靜態(tài)內(nèi)部類。

(1) 成員內(nèi)部類

成員內(nèi)部類也是最普通的內(nèi)部類，上面的 InnerClass 與 OuterClass就是屬于成員內(nèi)部類與其外部類。成員內(nèi)部類又稱為局部內(nèi)部類，它是外部類的一個成員，所以他是可以無限制的訪問外圍類的所有成員屬性和方法，盡管是 private 的，但是外部類要訪問內(nèi)部類的成員屬性和方法，就需要通過內(nèi)部類實例來訪問。

在成員內(nèi)部類中要注意兩點：

• 成員內(nèi)部類中不能存在任何 static 的變量和方法
• 成員內(nèi)部類是依附于外圍類的，所以只有先創(chuàng)建了外圍類才能夠創(chuàng)建內(nèi)部類

(2) 靜態(tài)內(nèi)部類

static 關鍵字可以修飾成員變量、方法、代碼塊，其實它還可以修飾內(nèi)部類，使用 static 修飾的內(nèi)部類我們稱之為靜態(tài)內(nèi)部類。靜態(tài)內(nèi)部類與非靜態(tài)內(nèi)部類之間存在一個最大的區(qū)別，我們知道非靜態(tài)內(nèi)部類在編譯完成之后會隱含地保存著一個引用，該引用是指向創(chuàng)建它的外圍內(nèi)，但是靜態(tài)內(nèi)部類卻沒有。沒有這個引用就意味著靜態(tài)內(nèi)部類的兩個屬性：

• 靜態(tài)內(nèi)部類的創(chuàng)建不需要依賴于外圍類，可以直接創(chuàng)建；
• 靜態(tài)內(nèi)部類不可以使用任何外圍類的非 static 成員變量和方法，而內(nèi)部類則都可以；

靜態(tài)內(nèi)部類的示例如下：

public class OuterClass {
    private static String outerName;
    public  int age;

    static class InnerClass1{
        // 在靜態(tài)內(nèi)部類中可以存在靜態(tài)成員
        public static String _innerName = "static variable";
        public void display(){
            /*=========================================
             * 靜態(tài)內(nèi)部類只能訪問外部類的靜態(tài)成員變量和方法
             * 不能訪問外部類的非靜態(tài)成員變量和方法
             ==========================================
             */
            System.out.println("OutClass name :" + outerName);
        }
    }
    class InnerClass2{
        // 非靜態(tài)內(nèi)部類中不能存在靜態(tài)成員
        public String _innerName = "no static variable";
        // 非靜態(tài)內(nèi)部類中可以調(diào)用外部類的任何成員,不管是靜態(tài)的還是非靜態(tài)的
        public void display() {
            System.out.println("OuterClass name：" + outerName);
            System.out.println("OuterClass age：" + age);
        }
    }
    public void display(){
        // 外部類能直接訪問靜態(tài)內(nèi)部類靜態(tài)元素
        System.out.println(InnerClass1._innerName);
        // 靜態(tài)內(nèi)部類可以直接創(chuàng)建實例不需要依賴于外部類
        new InnerClass1().display();
        // 非靜態(tài)內(nèi)部的創(chuàng)建需要依賴于外部類
        OuterClass.InnerClass2 inner2 = new OuterClass().new InnerClass2();
        // 非靜態(tài)內(nèi)部類的成員需要使用非靜態(tài)內(nèi)部類的實例訪問
        System.out.println(inner2._innerName);
        inner2.display();
    }

    public static void main(String[] args) {
        OuterClass outer = new OuterClass();
        outer.display();
    }
}

(3) 方法內(nèi)部類

方法內(nèi)部類定義在外部類的方法中，局部內(nèi)部類和成員內(nèi)部類基本一致，只是它們的作用域不同，方法內(nèi)部類只能在該方法中被使用，出了該方法就會失效。 對于這個類的使用主要是應用與解決比較復雜的問題，想創(chuàng)建一個類來輔助我們的解決方案，到那時又不希望這個類是公共可用的，所以就產(chǎn)生了局部內(nèi)部類。

(4) 匿名內(nèi)部類

匿名內(nèi)部類是沒有名字的局部內(nèi)部類，它沒有 class, interface, implements, extends 等關鍵字的修飾，也沒有構(gòu)造器，它一般隱式的繼承某一個父類，或者具體實現(xiàn)某一個接口。

• 什么時候用：
  • 已知父類，要獲取其子類的實例對象；
  • 已知接口，要獲取其實現(xiàn)了該接口的類的實例；
• 怎么用：

對于子類繼承：

new 父類(給父類的構(gòu)造函數(shù)傳遞參數(shù)) {  
    // 子類具體實現(xiàn)部分；  
}  
// 此處得到的是子類的實例對象

對于接口實現(xiàn)：

new 接口() {  
    // 實現(xiàn)了該接口的類的實現(xiàn)部分；  
}
// 此處得到的是接口的實現(xiàn)類的實例對象

后面將會在很多地方看到匿名內(nèi)部類的使用，比如在后面講到的 TreeSet，JDBC 的 JdbcTemplate.query 方法中的 RowMapper 繼承類實現(xiàn)等。此處以 TreeSet 為例，需要實現(xiàn)一個比較器 Comparator 的 compareTo 方法，這里就可以實現(xiàn)匿名內(nèi)部類。代碼如下：

TreeSet<T> ts = new TreeSet<T>(new Comparator<T>() {
    public int compare(T o1, T o2) {
        // TODO Auto-generated method stub
        return o2.getName().compareTo(o1.getName());
    }
});

上面的代碼中，new TreeSet< T > 后面?zhèn)魅氲膮?shù)，是直接定義得到的一個 new Comparator< T >(){...} 。這里就體現(xiàn)了匿名內(nèi)部類直接對接口的實現(xiàn)，確定了數(shù)據(jù)類型為 T 的兩個對象 o1, o2 的名稱按照字母順序進行排列的規(guī)定。

后續(xù)的 RowMapper 繼承，也會用到匿名內(nèi)部類。代碼大致如下，到后面會詳細講解：

@Test  
public void testResultSet1() {  
  jdbcTemplate.update("insert into test(name) values('name5')");  
  String listSql = "select * from test";  
  List result = jdbcTemplate.query(listSql, new RowMapper<Map>() {  
      @Override  
      public Map mapRow(ResultSet rs, int rowNum) throws SQLException {  
          Map row = new HashMap();  
          row.put(rs.getInt("id"), rs.getString("name"));  
          return row;  
  }});  
  Assert.assertEquals(1, result.size());  
  jdbcTemplate.update("delete from test where name='name5'");       
}  

內(nèi)部類相關內(nèi)容參考地址：《
java 內(nèi)部類（inner class）詳解》

接下篇《JavaSE 基礎學習之四 —— 異常的處理》