舉例講解Java的RTTI運(yùn)行時類型識別機(jī)制

更新時間：2016年05月09日 09:01:07 作者：arthinking

這篇文章主要介紹了Java的RTTI運(yùn)行時類型識別機(jī)制,包括泛化的Class引用以及類型檢查instanceof等知識點(diǎn),需要的朋友可以參考下

1、RTTI：
運(yùn)行時類型信息可以讓你在程序運(yùn)行時發(fā)現(xiàn)和使用類型信息。

在Java中運(yùn)行時識別對象和類的信息有兩種方式：傳統(tǒng)的RTTI，以及反射。下面就來說下RTTI。

RTTI：在運(yùn)行時，識別一個對象的類型。但是這個類型在編譯時必須已知。

下面通過一個例子來看下RTTI的使用。這里涉及到了多態(tài)的概念：讓代碼只操作基類的引用，而實(shí)際上調(diào)用具體的子類的方法，通常會創(chuàng)建一個具體的對象（Circle，Square，或者Triangle，見下例），把它向上轉(zhuǎn)型為Shape（忽略了對象的具體類型），并在后面的程序中使用匿名（即不知道具體類型）的Shape引用：

20165985229239.png (515×293)

abstract class Shape {
  // this 調(diào)用當(dāng)前類的toString()方法，返回實(shí)際的內(nèi)容
  void draw(){ System.out.println(this + "draw()"); }
  // 聲明 toString()為abstract類型，強(qiáng)制集成在重寫該方法
  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>的數(shù)組的時候會向上轉(zhuǎn)型為Shape，從而丟失了具體的類型信息
  List<Shape> shapeList = Arrays.asList(new Circle(), new Square(), new Triangle());
  // 從數(shù)組中取出時，這種容器，實(shí)際上所有的元素都當(dāng)成Object持有，會自動將結(jié)果轉(zhuǎn)型為Shape，這就是RTTI的基本的使用。
  for(Shape shape : shapeList){
    shape.draw();
  }
}

輸出結(jié)果為：

Circledraw()
Squaredraw()
Triangledraw()

存入數(shù)組的時候，會自動向上轉(zhuǎn)型為Shape，丟失了具體的類型，當(dāng)從數(shù)組中取出的時候，（List容器將所有的事物都當(dāng)做Object持有），會自動將結(jié)果轉(zhuǎn)型回Shape，這就是RTTI的基本用法。Java中所有的類型轉(zhuǎn)換都是在運(yùn)行時進(jìn)行正確性檢查的，也就是RTTI：在運(yùn)行時，識別一個對象的類型。

上面的轉(zhuǎn)型并不徹底，數(shù)組的元素取出時又Object轉(zhuǎn)型為Shape，而不是具體的類型，編譯時這是由容器和Java泛型系統(tǒng)來確保這一點(diǎn)的，而在運(yùn)行時時有類型轉(zhuǎn)換操作來確保這一點(diǎn)的。

而能夠通過Shape對象執(zhí)行到子類的具體代碼就是又多態(tài)來決定的了，具體看Shape引用所指向的具體對象。

另外，使用RTTI，可以查詢某個Shape引用所指向的對象的確切類型，然后選擇性的執(zhí)行子類的方法。

2、Class對象：
要了解RTTI在Java中的工作原理，必須知道類型信息在運(yùn)行時是如何表示的，這里是由Class這個特殊對象完成的。

Class對象是用來創(chuàng)建類的所有的“常規(guī)”對象的。Java使用Class對象來執(zhí)行其RTTI。

每當(dāng)編譯一個新類，就會產(chǎn)生一個Class對象（.class文件）。運(yùn)行這個程序的JVM將使用“類加載器”這個子系統(tǒng)。

類加載器子系統(tǒng)：包含一條類加載器鏈，但只有一個原生類加載器，它是JVM實(shí)現(xiàn)的一部分。原生類加載器加載可信類，包括Java API類，通常是從本地磁盤加載的。當(dāng)需要以某種特定的方式加載類，以支持Web服務(wù)器應(yīng)用，可以掛接額外的類加載器。

2.1、加載類的時機(jī)：
當(dāng)程序創(chuàng)建第一個對類的靜態(tài)成員的引用時，就會加載這個類。這證明其實(shí)構(gòu)造器也是類的靜態(tài)方法，當(dāng)使用new操作符創(chuàng)建類的新對象也會當(dāng)做對類的靜態(tài)成員的引用。

可見Java程序時動態(tài)加載的，按需加載。需要用到Class時，類加載器首先會檢查這個類的Class對象是否已經(jīng)加載，如果尚未加載，默認(rèn)的類加載器就會根據(jù)類名查找到.class文件。接下來是驗(yàn)證階段：加載時，它們會接受驗(yàn)證，以確保其沒有被破壞，并且不包含不良Java代碼。

2.2、Class相關(guān)方法，newInstance()
下面通過一個例子演示Class對象的加載：

class A {
  // 靜態(tài)代碼庫，在第一次被加載時執(zhí)行，通過打印信息知道該類什么時候被加載
  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");
  }
}

輸出結(jié)果為：

execute main...
Loading A
after new A
Loading B
after Class.forName B
Loading C
after new C

可見，Class對象在需要的時候才被加載，注意到這里的Class.forName()方法：

forName()方法是取得Class對象的引用的一種方法，通過這個方法獲得恰當(dāng)?shù)腃lass對象的引用，就可以在運(yùn)行時使用類型信息了。

如果你已經(jīng)有了一個感興趣的類型的對象，則可以通過跟類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()方法創(chuàng)建Class的實(shí)例
      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? true
Simple name: X
Canonical name: com.itzhai.test.type.X
Class name： com.itzhai.test.type.Y is interface? true
Simple name: Y
Canonical name: com.itzhai.test.type.Y
Class name： com.itzhai.test.type.Z is interface? true
Simple name: Z
Canonical name: com.itzhai.test.type.Z
Class name： com.itzhai.test.type.Letter is interface? false
Simple name: Letter
Canonical name: com.itzhai.test.type.Letter

注意，在傳遞給forName()的字符串必須使用全限定名（包括包名）。

通過printInfo里面使用到的方法，你可以在運(yùn)行時發(fā)現(xiàn)一個對象完整的類繼承結(jié)構(gòu)。

通過使用Class的newInstance()方法是實(shí)現(xiàn)“虛擬構(gòu)造器”的一種途徑，用來創(chuàng)建Class的實(shí)例，得到的是Object引用，但是引用時指向Letter對象。使用newInstance()來創(chuàng)建的類，必須帶有默認(rèn)的構(gòu)造器。（而通過反射API，可以用任意的構(gòu)造器來動態(tài)的創(chuàng)建類的對象）。

2.3、類字面常量：
除了使用getName()方法,Java還提供了另一種方法來生成對Class對象的引用，即使用類字面常量：

NewLetter.class;

此方法簡單安全，編譯時就受到檢查，更高效。不僅可用于普通類，也可以用于接口，數(shù)組以及基本數(shù)據(jù)類型。另外，對于基本數(shù)據(jù)類型的包裝器類，還有一個標(biāo)準(zhǔn)字段TYPE，TYPE字段是一個引用，執(zhí)行對應(yīng)的基本數(shù)據(jù)類型的Class對象。為了統(tǒng)一，建議都使用.class這種形式。

2.4、使用.class與使用getName()方法創(chuàng)建對象引用的區(qū)別：
使用.class創(chuàng)建時，不會自動的初始化Class對象。創(chuàng)建步驟如下：

（1）加載由類加載器執(zhí)行：查找字節(jié)碼（通常是在classpath指定的路徑中查找，但并非必須的），然后從這些字節(jié)碼中創(chuàng)建一個Class對象。

（2）鏈接將驗(yàn)證類中的字節(jié)碼，為靜態(tài)域分配存儲空間，如果需要，將會解析這個類創(chuàng)建的對其他類的所有的引用。

（3）初始化如果該類具有超類，則對其初始化，執(zhí)行靜態(tài)初始化器和靜態(tài)初始化塊。

初始化被延遲到了對靜態(tài)方法（構(gòu)造器隱式的是靜態(tài)的）或者非常數(shù)靜態(tài)域進(jìn)行首次引用時才執(zhí)行的：

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);
  }
}

輸出的結(jié)果為：

Data1.class: 
1
init Data1...
0.26771085109184534
init Data2...
12
init Data3...
23

初始化有效的實(shí)現(xiàn)了盡可能的“惰性”。

2.5、下面是判斷是否執(zhí)行初始化的一些情況：
（1）class語法獲得對類的引用不會引發(fā)初始化；

（2）Class.forName()產(chǎn)生了Class引用，立即進(jìn)行了初始化；

（3）如果一個static final值是“編譯器常量”，那么這個值不需要對類進(jìn)行初始化就可以被讀?。?/p>

（4）如果只是把一個域設(shè)置為static final還不足以確保這種行為，例如上面的：

static final double b = Math.random();

（5）如果一個static域bushifinal的，那么在對它訪問時，總是要先進(jìn)性鏈接和初始化；

2.6、泛化的Class引用：
Class引用表示的是它所指向的對象的確切類型，而該對象便是Class類的一個對象。在JavaSE5中，可以通過泛型對Class引用所指向的Class對象進(jìn)行限定，并且可以讓編譯器強(qiáng)制執(zhí)行額外的類型檢查：

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<?>優(yōu)于平凡的Class，更建議使用Class<?>，即便它們是等價的，因?yàn)镃lass<?>的好處是它表示你并非是碰巧或者疏忽，而是使用了一個非具體的類引用。

為了限定Class的引用為某種類型，或者該類型的子類型可以將通配符與extends一起使用，創(chuàng)建一個范圍：

Class<? extends Number> num = int.class;
// num的引用范圍為Number及其子類，所以可以按照如下賦值
num = double.class;
num = Number.class;

2.6.2、泛型下的newInstance()方法：
使用了泛型后的Class，調(diào)用newInstance()返回的對象是確切類型的，但是當(dāng)你使用getSuperclass()獲取泛型對應(yīng)的超類的時候真正的類型會有一些限制：編譯器在編譯期就知道了超類的類型，但是，通過這個獲取到的超類引用的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();
// 通過獲取的超類引用，只能創(chuàng)建返回Object類型的對象
Object obj = animalCls.newInstance();

2.6.3、新的轉(zhuǎn)型語法：cast()方法
直接看下代碼：

Animal animal = new Dog();
Class<Dog> dogCls = Dog.class;
Dog dog = dogCls.cast(animal);
// 或者直接使用下面的轉(zhuǎn)型方法
dog = (Dog)animal;

可以發(fā)現(xiàn)，使用cast()方法的做了額外的工作，這種轉(zhuǎn)換方法可以用在一下的情況中：在編寫泛型帶的時候，如果存儲了Class引用，并希望通過這個Class引用來執(zhí)行轉(zhuǎn)型，就可以使用cast()方法。

3、類型檢查 instanceof
3.1、類型轉(zhuǎn)換前先做檢查
編譯器允許你自由的做向上轉(zhuǎn)型的賦值操作，而不需要任何顯示的轉(zhuǎn)型操作，就好像給超類的引用賦值那樣。

然而如果不使用顯示的類型轉(zhuǎn)換，編譯器就不允許你執(zhí)行向下轉(zhuǎn)換賦值，這個時候我們不妨先來檢查一下對象是不是某個特定類型的實(shí)例，使用到了關(guān)鍵字 instanceof：

if(x instanceof Dog)
  ((Dog) x).bark();

3.2、RTTI的形式：
所以，到目前為止，我們知道RTTI的形式包括：

（1）傳統(tǒng)的類型轉(zhuǎn)換 (Shape)

（2）代表對象的類型的Class對象

（3）關(guān)鍵字instanceof

3.3、動態(tài)的instanceof方法：
Class.isInstance方法提供給了一種動態(tài)測試對象的途徑。

下面演示下instanceof和Class.isInstance的用法：

Attribute:

public interface Attribute {

}

Shape:

/**
 * 創(chuàng)建一個抽象類
 */
public abstract class Shape{
  // this調(diào)用了當(dāng)前類的toString方法獲得信息
  public void draw() { System.out.println(this + ".draw()"); }
  // 聲明toString()方法為abstract，從而強(qiáng)制繼承者需要重寫該方法。
  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"; }
}

類型檢查：

// instanceOf
Circle c = new Circle();
// 判斷是否超類的實(shí)例
System.out.format("Using instanceof: %s is a shape? %b\n", 
    c.toString(), c instanceof Shape);
// 判斷是否Circle的實(shí)例
System.out.format("Using instanceof: %s is a circle? %b\n", 
    c.toString(), c instanceof Circle);
// 判斷是否超類的實(shí)例
System.out.format("Using Class.isInstance: %s is a shape? %b\n", 
    c.toString(), Shape.class.isInstance(c));
// 判斷是否接口的實(shí)例
System.out.format("Using Class.isInstance: %s is a Attribute? %b\n", 
    c.toString(), Attribute.class.isInstance(c));

可以發(fā)現(xiàn)，instanceof或者Class.isInstance方法判斷了是否繼承體系的實(shí)例，即除了判斷本身，還判斷是否超類或接口的實(shí)例。

下面演示下使用動態(tài)的Class.instance的用法：

首先創(chuàng)建一個抽象的形狀生成器類：

public abstract class ShapeCreator {
  private Random rand = new Random(10);
  // 返回一個對象類型數(shù)組，由實(shí)現(xiàn)類提供，后面會看到兩種實(shí)現(xiàn)形式，基于forName的和基于類字面常量的.class
  public abstract List<Class<? extends Shape>> types();
  // 隨機(jī)生成一個對象類型數(shù)組中的類型對象實(shí)例
  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;
    }
  }
  // 生成一個隨機(jī)數(shù)組
  public Shape[] createArray(int size){
    Shape[] result = new Shape[size];
    for(int i=0; i<size; i++){
      result[i] = randomShape();
    }
    return result;
  }
  // 生成一個隨機(jī)數(shù)組，泛型的ArrayList
  public ArrayList<Shape> arrayList(int size){
    ArrayList<Shape> result = new ArrayList<Shape>();
    Collections.addAll(result, createArray(size));
    return result;
  }
}

接下來編寫一個該抽象類的實(shí)現(xiàn)：

/**
 * forName的生成器實(shí)現(xiàn)
 * @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();
      }
    }
  }
  // 初始化加載所需的類型數(shù)組
  static {
    loader();
  }
  public List<Class<? extends Shape>> types() {
    return types;
  }
}

最后寫一個統(tǒng)計形狀個數(shù)的類，里面用到了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關(guān)鍵字統(tǒng)計對象類型
  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());
  }
}

改寫一下抽象類的實(shí)現(xiàn)，重新用類字面常量實(shí)現(xiàn)：

/**
 * 字面量的生成器實(shí)現(xiàn)
 */
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);
  }

}

現(xiàn)在使用Class.instance統(tǒng)計形狀的個數(shù)如下：

/**
 * 通過使用Class.instanceof動態(tài)的測試對象，移除掉原來的ShapeCount中單調(diào)的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()統(tǒng)計對象類型
  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());
  }
}

現(xiàn)在生成器有了兩種實(shí)現(xiàn)，我們在這里可以添加一層外觀，設(shè)置默認(rèn)的實(shí)現(xiàn)方式：

/**
 * 現(xiàn)在生成器有了兩種實(shí)現(xiàn)，我們在這里添加一層外觀，設(shè)置默認(rèn)的實(shí)現(xiàn)方式
 */
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()生成的結(jié)果完全一樣，保持了類型的概念，判斷是否一個類或者是這個類的派生類。

equals()與==也是一樣的，而使用這個比較實(shí)際的Class對象，就沒有考慮繼承。

System.out.println(new Circle() instanceof Circle); // true
System.out.println(Shape.class.isInstance(new Circle())); // true
System.out.println((new Circle()).getClass() == Circle.class); // true
System.out.println((new Circle().getClass()).equals(Shape.class)); // false

您可能感興趣的文章: