摘要：接口與類型信息關(guān)鍵字的一種重要目標(biāo)就是允許程序員隔離構(gòu)件，進(jìn)而降低耦合性。如果你編寫接口，那么就可以實(shí)現(xiàn)這一目標(biāo)，但是通過類型信息，這種耦合性還是會(huì)傳播出去接口并非是對(duì)解耦的一種無懈可擊的保障。

運(yùn)行時(shí)類型信息使得你可以在運(yùn)行時(shí)發(fā)現(xiàn)和使用類型信息，主要有兩種方式：

“傳統(tǒng)的”RTTI，它假定我們?cè)诰幾g時(shí)已經(jīng)知道了所有的類型；

“反射”機(jī)制，它允許我們?cè)谶\(yùn)行時(shí)發(fā)現(xiàn)和使用類的信息。

RTTI維護(hù)類型類型的信息，為多態(tài)機(jī)制的實(shí)現(xiàn)提供基礎(chǔ)。

類型信息在運(yùn)行時(shí)是通過Class對(duì)象來表示的，完成的Class對(duì)象包含了與類有關(guān)的信息。Class對(duì)象就是用來創(chuàng)建所有“常規(guī)”對(duì)象的，Java使用Class對(duì)象來執(zhí)行RTTI
類是程序的一部分，每個(gè)類都有一個(gè)Class對(duì)象，被保存在一個(gè)同名的.class文件中。

類加載器

類加載器子系統(tǒng)實(shí)際上可以包含一條類加載器鏈，但是只有一個(gè)原生類加載器，它是JVM實(shí)現(xiàn)的一部分。原生類加載器加載的是可信類，包括Java API類。

所有類都是在對(duì)其第一次使用（靜態(tài)成員或new對(duì)象）時(shí)，動(dòng)態(tài)加載到JVM的。

Class對(duì)象僅在需要的時(shí)候才會(huì)加載，static初始化是在類加載時(shí)進(jìn)行的。

類加載器首先會(huì)檢查這個(gè)類的Class對(duì)象是否已被加載過，如果尚未加載，默認(rèn)的類加載器就會(huì)根據(jù)類名查找對(duì)應(yīng)的.class文件。

Class類方法

想在運(yùn)行時(shí)使用類型信息，必須獲取對(duì)象的Class對(duì)象的引用：Class.forName("s2.A");。該方法會(huì)自動(dòng)初始化該Class對(duì)象，注意必須使用全限定名（包含包名）。

// 獲取類名
clz.getSimpleName()
// 獲取全限定名
clz.getCanonicalName()
// 獲取接口
clz.getInterfaces();
// 獲取父類
clz.getSuperClass();
// 創(chuàng)建該類對(duì)象
clz.newInstance();

Java還提供了類字面常量的方式來生成對(duì)Class對(duì)象的引用：Class clz = A.class。注意這種方式不會(huì)自動(dòng)初始化該Class對(duì)象。

基本類型

類字面常量不僅可以用于普通的類，還可以用于接口、數(shù)組（int[].class）和基本數(shù)據(jù)類型(int.class)。

基本類型的包裝類，都有一個(gè)標(biāo)準(zhǔn)字段TYPE，這是一個(gè)指向?qū)?yīng)基本數(shù)據(jù)類型Class對(duì)象的引用：如public static final Class TYPE = (Class) Class.getPrimitiveClass("int");

類的準(zhǔn)備過程

加載：由類加載器完成，該步驟查找對(duì)應(yīng)的字節(jié)碼，創(chuàng)建一個(gè)Class對(duì)象

鏈接：驗(yàn)證類中的字節(jié)碼，為靜態(tài)域分配空間；并且如果必須的話，將解析這個(gè)類創(chuàng)建的對(duì)其他類的所有引用。

初始化：如果該類有超類，則對(duì)其初始化，執(zhí)行靜態(tài)初始化器和靜態(tài)初始化塊

初始化的惰性

使用Class.forName()會(huì)自動(dòng)初始化；使用A.class不會(huì)自動(dòng)初始化類

編譯期常量：static final int i = 1;的值，則不需要初始化就可以被讀取。

如果只是將一個(gè)域設(shè)置為static final不足以保證是編譯器常量，如static final int ii = new Random().nextInt();。

如果一個(gè)static域不是final的，那么訪問之前要先進(jìn)行鏈接和初始化。

Java SE5之后，Class也可以支持范型了。
向Class引用添加范型語法的原因僅僅是為了提供編譯期類型檢查。

cast()方法接受參數(shù)對(duì)象，將其轉(zhuǎn)型為Class引用的類型。

Class.asSubclass()，該方法允許你講一個(gè)類對(duì)象轉(zhuǎn)型為更加具體的類型。

    Class clz = String.class;
    String str1 = clz.cast("");

Java提供類instanceOf關(guān)鍵字，可以判斷對(duì)象是否是某個(gè)類（及其父類）的實(shí)例。

clz.isInstance()方法接受一個(gè)對(duì)象，判斷該對(duì)象是否是該clz指向的類的實(shí)例。

clz.isAssignableFrom()方法接受一個(gè)Class對(duì)象，判斷該Class對(duì)象是否是clz自身或子類。

public class Test {
    public static void main(String[] args) throws Exception {
        System.out.println(A.class.isAssignableFrom(C.class));
        System.out.println(B.class.isAssignableFrom(C.class));
        System.out.println(A.class.isInstance(new C()));
        System.out.println(B.class.isInstance(new C()));
    }
}

class A { }
interface B {}
class C extends A implements B {}
// Output:
// true
// true
// true
// true

使用工廠方法設(shè)計(jì)模式， 將對(duì)象的創(chuàng)建工作交給類自己去完成。 工廠方法可以被多態(tài)地調(diào)用， 從而為你創(chuàng)建恰當(dāng)類型的對(duì)象。

instanceOf和isInstance()的結(jié)果完全一樣，比較的時(shí)候都考慮了繼承關(guān)系

A.class.equals(B.class) 和 A.class == B.class 只能比較是否為同一個(gè)類，沒有考慮繼承關(guān)系

RTTI的限制

如果不知道某個(gè)對(duì)象的確切類型，RTTI可以告訴你，但這有個(gè)限制：這個(gè)類型在編譯時(shí)必須已知。換句話說，編譯器在編譯時(shí)必須知道所有要通過RTTI來處理的類。

假設(shè)你獲取了一個(gè)指向某個(gè)并不在你程序空間中對(duì)象的引用，在編譯時(shí)你的程序根本無法獲知這個(gè)對(duì)象所屬的類。

運(yùn)行時(shí)獲取類的信息場景：基于構(gòu)件的編程、遠(yuǎn)程方法調(diào)用（RMI）。

反射機(jī)制并沒有什么神奇之處

當(dāng)通過反射與一個(gè)未知類型的對(duì)象打交道時(shí)，JVM只是簡單地檢查這個(gè)對(duì)象，看它屬于哪個(gè)特定的類（就像RTTI那樣）。

在用它做其他事情之前必須先加載那個(gè)類的Class對(duì)象。因此，那個(gè)類的.class文件對(duì)于JVM來說必須是可獲取的：要么在本地機(jī)器上，要么可以通過網(wǎng)絡(luò)取得。

所以RTTI和反射之間真正的區(qū)別只在于，對(duì)RTTI來說，編譯器在編譯時(shí)打開和檢查.class文件；而對(duì)于反射機(jī)制來說，.class文件在編譯時(shí)是不可獲取的，所以是在運(yùn)行時(shí)打開和檢查class文件。

反射的作用

反射在Java中是用來支持其他特性的，例如對(duì)象序列化和JavaBean。

代理是基本的設(shè)計(jì)模式之一，它是為你提供額外的或者不同的操作，而插入的用來代替“實(shí)際”對(duì)象的對(duì)象。這些操作通常設(shè)計(jì)與“實(shí)際”對(duì)象的通信，因此代理通常充當(dāng)著中間人的角色。

靜態(tài)代理

靜態(tài)代理就是寫死了在代理對(duì)象中執(zhí)行這個(gè)方法前后執(zhí)行添加功能的形式。

優(yōu)點(diǎn)：可以做到在符合開閉原則的情況下對(duì)目標(biāo)對(duì)象進(jìn)行功能擴(kuò)展。

缺點(diǎn)：我們得為每一個(gè)服務(wù)都得創(chuàng)建代理類，工作量太大，不易管理。同時(shí)接口一旦發(fā)生改變，代理類也得相應(yīng)修改。

public class Test {
    public static void main(String[] args) throws Exception {
        new RealObject().doSomething();
        System.out.println("代理之后:");
        new SimpleProxy(new RealObject()).doSomething();
    }
}

interface MyInterface {
    void doSomething();
}

class RealObject implements MyInterface {
    @Override
    public void doSomething() {
        System.out.println("RealObject");
    }
}

class SimpleProxy implements MyInterface {
    private MyInterface myInterface;

    public SimpleProxy(MyInterface myInterface) {
        this.myInterface = myInterface;
    }

    // 代理后增加方法
    @Override
    public void doSomething() {
        System.out.println("SimpleProxy");
        myInterface.doSomething();
    }
}

動(dòng)態(tài)代理

Java的動(dòng)態(tài)代理比代理的思想更向前邁進(jìn)了一步， 因?yàn)樗梢詣?dòng)態(tài)地創(chuàng)建代理并動(dòng)態(tài)地處理對(duì)所代理方法的調(diào)用。在動(dòng)態(tài)代理上所做的所有調(diào)用都會(huì)被重定向到單一的調(diào)用處理器上。

通過Proxy.newProxyInstance()可以創(chuàng)建動(dòng)態(tài)代理，需要一個(gè)類加載器（通常是被加載的對(duì)象獲取）、一個(gè)希望實(shí)現(xiàn)的接口列表（不是類或抽象類）、以及InvocationHandler的一個(gè)實(shí)現(xiàn)。

動(dòng)態(tài)代理可以將所有對(duì)接口的調(diào)用重定向?yàn)閷?duì)代理的調(diào)用。

使用動(dòng)態(tài)代理來編寫一個(gè)系統(tǒng)以實(shí)現(xiàn)事務(wù)，其中，代理在被代理的調(diào)用執(zhí)行成功（不拋出任何異常）執(zhí)行提交，而在執(zhí)行失敗時(shí)執(zhí)行回滾。你的提交和回滾都針對(duì)一個(gè)外部的文本文件，該文件不在Java異常的控制范圍之內(nèi)。你必須注意操作的原子性。

    MyInterface myInterface = (MyInterface) Proxy.newProxyInstance(MyInterface.class.getClassLoader(), new Class[]{MyInterface.class}, new InvocationHandler() {
            @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            System.out.println("代理方法");
            return method.invoke(new RealObject(), args);
        }
    });
    myInterface.doSomething();

使用null的時(shí)候每次都要檢查是否為null，這是一件很麻煩的事。

引人空對(duì)象的思想將會(huì)很有用，它可以接受傳遞給它的所代表的對(duì)象的消息，但是將返回表示為實(shí)際上并不存在任何“真實(shí)”對(duì)象的值。通過這種方式，你可以假設(shè)所有的對(duì)象都是有效的，而不必浪費(fèi)編程精力去檢查null。

通常空對(duì)象是單例的，所以你不僅可以用instanceOf來比較，還可以用equals或==來比較。

注意：在某些地方仍然必須測試空對(duì)象，這與檢查是否為null沒有區(qū)別，但在很多地方就不必執(zhí)行額外的測試了，可以直接假設(shè)所有對(duì)象都是有效的。

public class Test {
    public static void main(String[] args) throws Exception {
       // 在使用的時(shí)候可以直接使用而不會(huì)報(bào)錯(cuò)空指針
        Person p = Person.NULL_PERSON;
        System.out.println(p.toString());
    }
}

// 空標(biāo)記接口
interface Null {}

class Person {
    void func() {
        System.out.println("Person");
    }
    
    // 空對(duì)象
    private static class NullPerson extends Person implements Null {
        private NullPerson() {}

        @Override
        public String toString() {
            return "NullPerson";
        }
    }

    public static final Person NULL_PERSON = new NullPerson();
}

動(dòng)態(tài)代理創(chuàng)建空對(duì)象

假設(shè)有不同的多個(gè)Person的子類，我們相對(duì)每一個(gè)都創(chuàng)建一個(gè)空對(duì)象。無論何時(shí)，如果你需要一個(gè)空Person對(duì)象，只需要調(diào)用newNullPerson()并傳遞需要代理的Person的類型。

public class Test {
    public static Person newNullPerson(Class type) {
        return (Person) Proxy.newProxyInstance(NullPerson.NULL_PERSON.getClass().getClassLoader(), new Class[]{type}, new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                System.out.println("代理");
                return method.invoke(NullPerson.NULL_PERSON, args);
            }
        });
    }

    public static void main(String[] args) throws Exception {
        Person p = newNullPerson(Person.class);
        p.func();
    }
}
// 空標(biāo)記接口
interface Null {}

// 父接口
interface Person {
    void func();
}

// 空Person
class NullPerson implements Person, Null {
    @Override
    public void func() {
        System.out.println("NullPerson");
    }

    public static final Person NULL_PERSON = new NullPerson();
    private NullPerson() {}
}

空對(duì)象的邏輯變體是模擬對(duì)象和樁。與空對(duì)象一樣，它們都表示在最終的程序中所使用的“實(shí)際”對(duì)象。但是，模擬對(duì)象和樁都只是假扮可以傳遞實(shí)際信息的存活對(duì)象，而不是像空對(duì)象那樣可以成為null的一種更加智能化的替代物。

模擬對(duì)象和樁之間的差異在于程度不同。模擬對(duì)象往往是輕量級(jí)和自測試的，通常很多模擬對(duì)象被創(chuàng)建出來是為了處理各種不同的測試情況。樁只是返回樁數(shù)據(jù)，它通常是重量級(jí)的，并且經(jīng)常在測試之間被復(fù)用。樁可以根據(jù)它們被調(diào)用的方式，通過配置進(jìn)行修改，因此樁是一 種復(fù)雜對(duì)象，它要做很多事。然而對(duì)于模擬對(duì)象，如果你需要做很多事情，通常會(huì)創(chuàng)建大量小而簡單的模擬對(duì)象。

interface關(guān)鍵字的一種重要目標(biāo)就是允許程序員隔離構(gòu)件，進(jìn)而降低耦合性。如果你編寫接口，那么就可以實(shí)現(xiàn)這一目標(biāo)，但是通過類型信息，這種耦合性還是會(huì)傳播出去——接口并非是對(duì)解耦的一種無懈可擊的保障。

public class Test {
    public static void main(String[] args) {
        A a = new B();
        a.a();
        // 我們需要的是用戶使用接口，但是強(qiáng)制轉(zhuǎn)型還是可以訪問不存在于接口中的方法
        ((B) a).b();
    }
}

interface A {
    void a();
}

class B implements A {
    @Override
    public void a() {}
    public void b() {}
}

解決方法1:方法是直接聲明

如果程序員不使用接口而是子類，它們要對(duì)自己負(fù)責(zé)。即B a = new B();代替A a = new B();。

解決方法2:包訪問權(quán)限隱藏

此時(shí)在此包外只能使用Hidden.newA()來獲取對(duì)象，而且由于沒有B類的信息，也無法強(qiáng)制轉(zhuǎn)型。

class B implements A {
    @Override
    public void a() {}
    public void b() {}
}

public class HiddenB {
    public static A newA() {
        return new B();
    }
}

反射的后門

通過使用反射，仍舊可以到達(dá)并調(diào)用所有方法，甚至是private方法！如果知道方法名，你就可以在其Method對(duì)象上調(diào)用setAccessible(true)。

final域?qū)嶋H上在遭遇修改時(shí)是安全的。運(yùn)行時(shí)系統(tǒng)會(huì)在不拋異常的情況下接受任何修改嘗試，但是實(shí)際上不會(huì)發(fā)生任何修改。

RTTI允許通過匿名基類的引用來發(fā)現(xiàn)類型信息。

面向?qū)ο缶幊陶Z言的目的是讓我們?cè)诜彩强梢允褂玫牡胤蕉际褂枚鄳B(tài)機(jī)制，只在必需的時(shí)候使用RTTI。

可繼承一個(gè)新類，然后添加你需要的方法。在代碼的其他地方，可以檢査你自己特定的類型，并調(diào)用你自己的方法，這樣做不會(huì)破壞多態(tài)性以及程序的擴(kuò)展能力。

但如果在程序主體中添加需要的新特性的代碼，就必須使用RTTI來檢査你的特定的類型。

一致的錯(cuò)誤報(bào)告模型的存在使我們能夠通過使用反射編寫動(dòng)態(tài)代碼。當(dāng)然，盡力編寫能夠進(jìn)行靜態(tài)檢査的代碼是值得的，只要你確實(shí)能夠這么做。但是我相信動(dòng)態(tài)代碼是將Java與其他例如C++這樣的語言區(qū)分開的重要工具之一。