1、RTTI:
運行時類型信息可以讓你在程序運行時發現和使用類型信息。
在Java中運行時識別對象和類的信息有兩種方式:傳統的RTTI,以及反射。下面就來說下RTTI。
RTTI:在運行時,識別一個對象的類型。但是這個類型在編譯時必須已知。
下面通過一個例子來看下RTTI的使用。這裡涉及到了多態的概念:讓代碼只操作基類的引用,而實際上調用具體的子類的方法,通常會創建一個具體的對象(Circle,Square,或者Triangle,見下例),把它向上轉型為Shape(忽略了對象的具體類型),並在後面的程序中使用匿名(即不知道具體類型)的Shape引用:
abstract class Shape { // this 調用當前類的toString()方法,返回實際的內容void draw(){ System.out.println(this + "draw()"); } // 聲明toString()為abstract類型,強制集成在重寫該方法abstract public String toString();}class Circle extends Shape { public String toString(){ return "Circle"; }}class Square extends Shape { public String toString(){ return "Square"; }}class Triangle extends Shape { public String toString(){ return "Triangle"; }}public static void main(String[] args){ // 把Shape對象放入List<Shape>的數組的時候會向上轉型為Shape,從而丟失了具體的類型信息List<Shape> shapeList = Arrays.asList(new Circle(), new Square(), new Triangle()); // 從數組中取出時,這種容器,實際上所有的元素都當成Object持有,會自動將結果轉型為Shape,這就是RTTI的基本的使用。 for(Shape shape : shapeList){ shape.draw(); }}輸出結果為:
Circledraw()Squaredraw()Triangledraw()
存入數組的時候,會自動向上轉型為Shape,丟失了具體的類型,當從數組中取出的時候,(List容器將所有的事物都當做Object持有),會自動將結果轉型回Shape,這就是RTTI的基本用法。 Java中所有的類型轉換都是在運行時進行正確性檢查的,也就是RTTI:在運行時,識別一個對象的類型。
上面的轉型並不徹底,數組的元素取出時又Object轉型為Shape,而不是具體的類型,編譯時這是由容器和Java泛型系統來確保這一點的,而在運行時時有類型轉換操作來確保這一點的。
而能夠通過Shape對象執行到子類的具體代碼就是又多態來決定的了,具體看Shape引用所指向的具體對象。
另外,使用RTTI,可以查詢某個Shape引用所指向的對象的確切類型,然後選擇性的執行子類的方法。
2、Class對象:
要了解RTTI在Java中的工作原理,必須知道類型信息在運行時是如何表示的,這裡是由Class這個特殊對象完成的。
Class對像是用來創建類的所有的“常規”對象的。 Java使用Class對象來執行其RTTI。
每當編譯一個新類,就會產生一個Class對象(.class文件)。運行這個程序的JVM將使用“類加載器”這個子系統。
類加載器子系統:包含一條類加載器鏈,但只有一個原生類加載器,它是JVM實現的一部分。原生類加載器加載可信類,包括Java API類,通常是從本地磁盤加載的。當需要以某種特定的方式加載類,以支持Web服務器應用,可以掛接額外的類加載器。
2.1、加載類的時機:
當程序創建第一個對類的靜態成員的引用時,就會加載這個類。這證明其實構造器也是類的靜態方法,當使用new操作符創建類的新對像也會當做對類的靜態成員的引用。
可見Java程序時動態加載的,按需加載。需要用到Class時,類加載器首先會檢查這個類的Class對像是否已經加載,如果尚未加載,默認的類加載器就會根據類名查找到.class文件。接下來是驗證階段:加載時,它們會接受驗證,以確保其沒有被破壞,並且不包含不良Java代碼。
2.2、Class相關方法,newInstance()
下面通過一個例子演示Class對象的加載:
class A { // 靜態代碼庫,在第一次被加載時執行,通過打印信息知道該類什麼時候被加載static { System.out.println("Loading A"); }}class B { static { System.out.println("Loading B"); }}class C { static { System.out.println("Loading C"); }}public class Load { public static void main(String[] args){ System.out.println("execute main..."); new A(); System.out.println("after new A"); try { Class.forName("com.itzhai.test.type.B"); } catch (ClassNotFoundException e) { System.out.println("cloud not find class B"); } System.out.println("after Class.forName B"); new C(); System.out.println("after new C"); }}輸出結果為:
execute main...Loading Aafter new ALoading Bafter Class.forName BLoading Cafter new C
可見,Class對像在需要的時候才被加載,注意到這裡的Class.forName()方法:
forName()方法是取得Class對象的引用的一種方法,通過這個方法獲得恰當的Class對象的引用,就可以在運行時使用類型信息了。
如果你已經有了一個感興趣的類型的對象,則可以通過跟類Object提供的getClass()方法來獲得Class引用。
下面是一段Class的使用的代碼:
interface X{}interface Y{}interface Z{}class Letter { Letter(){}; Letter(int i){};}class NewLetter extends Letter implements X, Y, Z{ NewLetter(){ super(1); };}public class ClassTest { /** * 打印類型信息* @param c */ static void printInfo(Class c){ // getName()獲得全限定的類名System.out.println("Class name: " + c.getName() + " is interface? " + c.isInterface()); // 獲得不包含包名的類名System.out.println("Simple name: " + c.getSimpleName()); // 獲得全限定類名System.out.println("Canonical name: " + c.getCanonicalName()); } public static void main(String[] args){ Class c = null; try { // 獲得Class引用c = Class.forName("com.itzhai.test.type.NewLetter"); } catch (ClassNotFoundException e) { System.out.println("Can not find com.itzhai.test.type.NewLetter"); System.exit(1); } // 打印接口類型信息for(Class face : c.getInterfaces()){ printInfo(face); } // 獲取超類Class引用Class up = c.getSuperclass(); Object obj = null; try { // 通過newInstance()方法創建Class的實例obj = up.newInstance(); } catch (InstantiationException e) { System.out.println("Can not instantiate"); } catch (IllegalAccessException e) { System.out.println("Can not access"); } // 打印超類類型信息printInfo(obj.getClass()); }}輸出為:
Class name: com.itzhai.test.type.X is interface? trueSimple name: XCanonical name: com.itzhai.test.type.XClass name: com.itzhai.test.type.Y is interface? trueSimple name: YCanonical name: com.itzhai.test.type.YClass name: com.itzhai.test.type.Z is interface? trueSimple name: ZCanonical name: com.itzhai.test.type.ZClass name: com.itzhai.test.type.Letter is interface? falseSimple name: LetterCanonical name: com.itzhai.test.type.Letter
注意,在傳遞給forName()的字符串必須使用全限定名(包括包名)。
通過printInfo裡面使用到的方法,你可以在運行時發現一個對象完整的類繼承結構。
通過使用Class的newInstance()方法是實現“虛擬構造器”的一種途徑,用來創建Class的實例,得到的是Object引用,但是引用時指向Letter對象。使用newInstance()來創建的類,必須帶有默認的構造器。 (而通過反射API,可以用任意的構造器來動態的創建類的對象)。
2.3、類字面常量:
除了使用getName()方法,Java還提供了另一種方法來生成對Class對象的引用,即使用類字面常量:
NewLetter.class;
此方法簡單安全,編譯時就受到檢查,更高效。不僅可用於普通類,也可以用於接口,數組以及基本數據類型。另外,對於基本數據類型的包裝器類,還有一個標準字段TYPE,TYPE字段是一個引用,執行對應的基本數據類型的Class對象。為了統一,建議都使用.class這種形式。
2.4、使用.class與使用getName()方法創建對象引用的區別:
使用.class創建時,不會自動的初始化Class對象。創建步驟如下:
(1)加載由類加載器執行:查找字節碼(通常是在classpath指定的路徑中查找,但並非必須的),然後從這些字節碼中創建一個Class對象。
(2)鏈接將驗證類中的字節碼,為靜態域分配存儲空間,如果需要,將會解析這個類創建的對其他類的所有的引用。
(3)初始化如果該類具有超類,則對其初始化,執行靜態初始化器和靜態初始化塊。
初始化被延遲到了對靜態方法(構造器隱式的是靜態的)或者非常數靜態域進行首次引用時才執行的:
class Data1{ static final int a = 1; static final double b = Math.random(); static { System.out.println("init Data1..."); }}class Data2{ static int a = 12; static { System.out.println("init Data2..."); }}class Data3{ static int a = 23; static { System.out.println("init Data3..."); }}public class ClassTest2 { public static void main(String[] args){ System.out.println("Data1.class: "); Class data1 = Data1.class; System.out.println(Data1.a); // 沒有初始化Data1 System.out.println(Data1.b); // 初始化了Data1 System.out.println(Data2.a); // 初始化了Data2 try { Class data3 = Class.forName("com.itzhai.test.type.Data3"); // 初始化了Data3 } catch (ClassNotFoundException e) { System.out.println("can not found com.itzhai.test.type.Data3..."); } System.out.println(Data3.a); }}輸出的結果為:
Data1.class: 1init Data1...0.26771085109184534init Data2...12init Data3...23
初始化有效的實現了盡可能的“惰性”。
2.5、下面是判斷是否執行初始化的一些情況:
(1)class語法獲得對類的引用不會引發初始化;
(2)Class.forName()產生了Class引用,立即進行了初始化;
(3)如果一個static final值是“編譯器常量”,那麼這個值不需要對類進行初始化就可以被讀取;
(4)如果只是把一個域設置為static final還不足以確保這種行為,例如上面的:
static final double b = Math.random();
(5)如果一個static域bushifinal的,那麼在對它訪問時,總是要先進性鏈接和初始化;
2.6、泛化的Class引用:
Class引用表示的是它所指向的對象的確切類型,而該對象便是Class類的一個對象。在JavaSE5中,可以通過泛型對Class引用所指向的Class對象進行限定,並且可以讓編譯器強制執行額外的類型檢查:
Class intCls = int.class;// 使用泛型限定Class指向的引用Class<Integer> genIntCls = int.class;// 沒有使用泛型的Clas可以重新賦值為指向任何其他的Class對象intCls = double.class;// 下面的編譯會出錯// genIntCls = double.class;
2.6.1、使用通配符?放鬆泛型的限定:
Class<?> intCls = int.class;intCls = String.class;
在JavaSE5中,Class<?>優於平凡的Class,更建議使用Class<?>,即便它們是等價的,因為Class<?>的好處是它表示你並非是碰巧或者疏忽,而是使用了一個非具體的類引用。
為了限定Class的引用為某種類型,或者該類型的子類型可以將通配符與extends一起使用,創建一個範圍:
Class<? extends Number> num = int.class;// num的引用範圍為Number及其子類,所以可以按照如下賦值num = double.class;num = Number.class;
2.6.2、泛型下的newInstance()方法:
使用了泛型後的Class,調用newInstance()返回的對像是確切類型的,但是當你使用getSuperclass()獲取泛型對應的超類的時候真正的類型會有一些限制:編譯器在編譯期就知道了超類的類型,但是,通過這個獲取到的超類引用的newInstance()方法返回的不是精確類型,而是Object:
Dog dog = dogCls.newInstance();abstract class Animal {}class Dog extends Animal{}// 下面的寫法是錯誤的,只能返回Class<? super Dog>類型// Class<Animal> animalCls = dogCls.getSuperclass(); Class<? super Dog> animalCls = dogCls.getSuperclass();// 通過獲取的超類引用,只能創建返回Object類型的對象Object obj = animalCls.newInstance(); 2.6.3、新的轉型語法:cast()方法
直接看下代碼:
Animal animal = new Dog();Class<Dog> dogCls = Dog.class;Dog dog = dogCls.cast(animal);// 或者直接使用下面的轉型方法dog = (Dog)animal;
可以發現,使用cast()方法的做了額外的工作,這種轉換方法可以用在一下的情況中:在編寫泛型帶的時候,如果存儲了Class引用,並希望通過這個Class引用來執行轉型,就可以使用cast()方法。
3、類型檢查instanceof
3.1、類型轉換前先做檢查
編譯器允許你自由的做向上轉型的賦值操作,而不需要任何顯示的轉型操作,就好像給超類的引用賦值那樣。
然而如果不使用顯示的類型轉換,編譯器就不允許你執行向下轉換賦值,這個時候我們不妨先來檢查一下對像是不是某個特定類型的實例,使用到了關鍵字instanceof:
if(x instanceof Dog) ((Dog) x).bark();
3.2、RTTI的形式:
所以,到目前為止,我們知道RTTI的形式包括:
(1)傳統的類型轉換(Shape)
(2)代表對象的類型的Class對象
(3)關鍵字instanceof
3.3、動態的instanceof方法:
Class.isInstance方法提供給了一種動態測試對象的途徑。
下面演示下instanceof和Class.isInstance的用法:
Attribute:
public interface Attribute {}Shape:
/** * 創建一個抽像類*/public abstract class Shape{ // this調用了當前類的toString方法獲得信息public void draw() { System.out.println(this + ".draw()"); } // 聲明toString()方法為abstract,從而強制繼承者需要重寫該方法。 abstract public String toString();}Circle:
public class Circle extends Shape implements Attribute{ public String toString(){ return "Circle"; }}Square:
public class Square extends Shape{ public String toString(){ return "Square"; }}Triangle:
public class Triangle extends Shape{ public String toString(){ return "Triangle"; }}類型檢查:
// instanceOfCircle c = new Circle();// 判斷是否超類的實例System.out.format("Using instanceof: %s is a shape? %b/n", c.toString(), c instanceof Shape);// 判斷是否Circle的實例System.out.format("Using instanceof: %s is a circle? %b/n", c.toString(), c instanceof Circle);// 判斷是否超類的實例System.out.format("Using Class.isInstance: %s is a shape? %b/n", c.toString(), Shape.class.isInstance(c));// 判斷是否接口的實例System.out.format("Using Class.isInstance: %s is a Attribute? %b/n", c.toString(), Attribute.class.isInstance(c));可以發現,instanceof或者Class.isInstance方法判斷了是否繼承體系的實例,即除了判斷本身,還判斷是否超類或接口的實例。
下面演示下使用動態的Class.instance的用法:
首先創建一個抽象的形狀生成器類:
public abstract class ShapeCreator { private Random rand = new Random(10); // 返回一個對像類型數組,由實現類提供,後面會看到兩種實現形式,基於forName的和基於類字面常量的.class public abstract List<Class<? extends Shape>> types(); // 隨機生成一個對像類型數組中的類型對象實例public Shape randomShape(){ int n = rand.nextInt(types().size()); try { return types().get(n).newInstance(); } catch (InstantiationException e) { e.printStackTrace(); return null; } catch (IllegalAccessException e) { e.printStackTrace(); return null; } } // 生成一個隨機數組public Shape[] createArray(int size){ Shape[] result = new Shape[size]; for(int i=0; i<size; i++){ result[i] = randomShape(); } return result; } // 生成一個隨機數組,泛型的ArrayList public ArrayList<Shape> arrayList(int size){ ArrayList<Shape> result = new ArrayList<Shape>(); Collections.addAll(result, createArray(size)); return result; }}接下來編寫一個該抽像類的實現:
/** * forName的生成器實現* @author arthinking * */public class ForNameCreator extends ShapeCreator{ private static List<Class<? extends Shape>> types = new ArrayList<Class<? extends Shape>>(); private static String[] typeNames = { "com.itzhai.javanote.entity.Circle", "com.itzhai.javanote.entity.Square", "com.itzhai.javanote.entity.Triangle" }; @SuppressWarnings("unused") private static void loader(){ for(String name : typeNames){ try { types.add((Class<? extends Shape>)Class.forName(name)); } catch (ClassNotFoundException e) { e.printStackTrace(); } } } // 初始化加載所需的類型數組static { loader(); } public List<Class<? extends Shape>> types() { return types; }}最後寫一個統計形狀個數的類,裡面用到了instanceof:
public class ShapeCount { static class ShapeCounter extends HashMap<String, Integer>{ public void count(String type){ Integer quantity = get(type); if(quantity == null){ put(type, 1); } else { put(type, quantity + 1); } } } // 演示通過instanceof關鍵字統計對像類型public static void countShapes(ShapeCreator creator){ ShapeCounter counter = new ShapeCounter(); for(Shape shape : creator.createArray(20)){ if(shape instanceof Circle) counter.count("Circle"); if(shape instanceof Square) counter.count("Square"); if(shape instanceof Triangle){ counter.count("Triangle"); } } System.out.println(counter); } public static void main(String[] args){ countShapes(new ForNameCreator()); }}改寫一下抽像類的實現,重新用類字面常量實現:
/** * 字面量的生成器實現*/public class LiteralCreator extends ShapeCreator{ public static final List<Class<? extends Shape>> allType = Collections.unmodifiableList(Arrays.asList(Circle.class, Triangle.class, Square.class)); public List<Class<? extends Shape>> types(){ return allType; } public static void main(String[] args){ System.out.println(allType); }}現在使用Class.instance統計形狀的個數如下:
/** * 通過使用Class.instanceof動態的測試對象,移除掉原來的ShapeCount中單調的instanceof語句* */public class ShapeCount2 { private static final List<Class<? extends Shape>> shapeTypes = LiteralCreator.allType; static class ShapeCounter extends HashMap<String, Integer>{ public void count(String type){ Integer quantity = get(type); if(quantity == null){ put(type, 1); } else { put(type, quantity + 1); } } } // 演示通過Class.isInstance()統計對像類型public static void countShapes(ShapeCreator creator){ ShapeCounter counter = new ShapeCounter(); for(Shape shape : creator.createArray(20)){ for(Class<? extends Shape> cls : shapeTypes){ if(cls.isInstance(shape)){ counter.count(cls.getSimpleName()); } } } System.out.println(counter); } public static void main(String[] args){ countShapes(new ForNameCreator()); }}現在生成器有了兩種實現,我們在這裡可以添加一層外觀,設置默認的實現方式:
/** * 現在生成器有了兩種實現,我們在這裡添加一層外觀,設置默認的實現方式*/public class Shapes { public static final ShapeCreator creator = new LiteralCreator(); public static Shape randomShape(){ return creator.randomShape(); } public static Shape[] createArray(int size){ return creator.createArray(size); } public static ArrayList<Shape> arrayList(int size){ return creator.arrayList(size); }} 3.4、instanceof與Class的等價性:
instanceof和isInstance()生成的結果完全一樣,保持了類型的概念,判斷是否一個類或者是這個類的派生類。
equals()與==也是一樣的,而使用這個比較實際的Class對象,就沒有考慮繼承。
System.out.println(new Circle() instanceof Circle); // trueSystem.out.println(Shape.class.isInstance(new Circle())); // trueSystem.out.println((new Circle()).getClass() == Circle.class); // trueSystem.out.println((new Circle().getClass()).equals(Shape.class)); // false