首页 > 代码库 > RRTI的概念以及Class对象作用

RRTI的概念以及Class对象作用

  深入理解Class对象
  
  RRTI的概念以及Class对象作用
  
  认识Class对象之前,先来了解一个概念,RTTI(Run-Time Type Identification)运行时类型识别,对于这个词一直是 C++ 中的概念,至于Java中出现RRTI的说法则是源于《Thinking in Java》一书,其作用是在运行时识别一个对象的类型和类的信息,这里分两种:传统的”RRTI”,它假定我们在编译期已知道了所有类型(在没有反射机制创建和使用类对象时,一般都是编译期已确定其类型,如new对象时该类必须已定义好),另外一种是反射机制,它允许我们在运行时发现和使用类型的信息。在Java中用来表示运行时类型信息的对应类就是Class类,Class类也是一个实实在在的类,存在于JDK的java.lang包中,其部分源码如下:
  
  public final class Class<T> implements java.io.Serializable,GenericDeclaration,Type, AnnotatedElement {
  
  private static final int ANNOTATION= 0x00002000;
  
  private static final int ENUM = 0x00004000;
  
  private static final int SYNTHETIC = 0x00001000;
  
  private static native void registerNatives();
  
  static {
  
  registerNatives();
  
  }
  
  /*
  
  * Private constructor. Only the Java Virtual Machine creates Class objects.(私有构造,只能由JVM创建该类)
  
  * This constructor is not used and prevents the default constructor being
  
  * generated.
  
  */
  
  private Class(ClassLoader loader) {
  
  // Initialize final field for classLoader. The initialization value of non-null
  
  // prevents future JIT optimizations from assuming this final field is null.
  
  classLoader = loader;
  
  Class类被创建后的对象就是Class对象,注意,Class对象表示的是自己手动编写类的类型信息,比如创建一个Shapes类,那么,JVM就会创建一个Shapes对应Class类的Class对象,该Class对象保存了Shapes类相关的类型信息。实际上在Java中每个类都有一个Class对象,每当我们编写并且编译一个新创建的类就会产生一个对应Class对象并且这个Class对象会被保存在同名.class文件里(编译后的字节码文件保存的就是Class对象),那为什么需要这样一个Class对象呢?是这样的,当我们new一个新对象或者引用静态成员变量时,Java虚拟机(JVM)中的类加载器子系统会将对应Class对象加载到JVM中,然后JVM再根据这个类型信息相关的Class对象创建我们需要实例对象或者提供静态变量的引用值。需要特别注意的是,手动编写的每个class类,无论创建多少个实例对象,在JVM中都只有一个Class对象,即在内存中每个类有且只有一个相对应的Class对象,挺拗口,通过下图理解(内存中的简易现象图):
  
  到这我们也就可以得出以下几点信息:
  
  Class类也是类的一种,与class关键字是不一样的。
  
  手动编写的类被编译后会产生一个Class对象,其表示的是创建的类的类型信息,而且这个Class对象保存在同名.class的文件中(字节码文件),比如创建一个Shapes类,编译Shapes类后就会创建其包含Shapes类相关类型信息的Class对象,并保存在Shapes.class字节码文件中。
  
  每个通过关键字class标识的类,在内存中有且只有一个与之对应的Class对象来描述其类型信息,无论创建多少个实例对象,其依据的都是用一个Class对象。
  
  Class类只存私有构造函数,因此对应Class对象只能有JVM创建和加载
  
  Class类的对象作用是运行时提供或获得某个对象的类型信息,这点对于反射技术很重要(关于反射稍后分析)。
  
  Class对象的加载及其获取方式
  
  Class对象的加载
  
  前面我们已提到过,Class对象是由JVM加载的,那么其加载时机是?实际上所有的类都是在对其第一次使用时动态加载到JVM中的,当程序创建第一个对类的静态成员引用时,就会加载这个被使用的类(实际上加载的就是这个类的字节码文件),注意,使用new操作符创建类的新实例对象也会被当作对类的静态成员的引用(构造函数也是类的静态方法),由此看来Java程序在它们开始运行之前并非被完全加载到内存的,其各个部分是按需加载,所以在使用该类时,类加载器首先会检查这个类的Class对象是否已被加载(类的实例对象创建时依据Class对象中类型信息完成的),如果还没有加载,默认的类加载器就会先根据类名查找.class文件(编译后Class对象被保存在同名的.class文件中),在这个类的字节码文件被加载时,它们必须接受相关验证,以确保其没有被破坏并且不包含不良Java代码(这是java的安全机制检测),完全没有问题后就会被动态加载到内存中,此时相当于Class对象也就被载入内存了(毕竟.class字节码文件保存的就是Class对象),同时也就可以被用来创建这个类的所有实例对象。下面通过一个简单例子来说明Class对象被加载的时机问题(例子引用自Thinking in Java):
  
  package com.zejian;
  
  class Candy {
  
  static { System.out.println("Loading Candy"); }
  
  }
  
  class Gum {
  
  static { System.out.println("Loading Gum"); }
  
  }
  
  class Cookie {
  
  static { System.out.println("Loading Cookie"); }
  
  }
  
  public class SweetShop {
  
  public static void print(Object obj) {
  
  System.out.println(obj);
  
  }
  
  public static void main(String[] args) {
  
  print("inside main");
  
  new Candy();
  
  print("After creating Candy");
  
  try {
  
  Class.forName("com.zejian.Gum");
  
  } catch(ClassNotFoundException e) {
  
  print("Couldn‘t find Gum");
  
  }
  
  print("After Class.forName(\"com.zejian.Gum\")");
  
  new Cookie();
  
  print("After creating Cookie");
 
  在上述代码中,每个类Candy、Gum、Cookie都存在一个static语句,这个语句会在类第一次被加载时执行,这个语句的作用就是告诉我们该类在什么时候被加载,执行结果:
  
  inside main
  
  Loading Candy
  
  After creating Candy
  
  Loading Gum
  
  After Class.forName("com.zejian.Gum")
  
  Loading Cookie
  
  After creating Cookie
  
  Process finished with exit code 0
  
  从结果来看,new一个Candy对象和Cookie对象,构造函数将被调用,属于静态方法的引用,Candy类的Class对象和Cookie的Class对象肯定会被加载,毕竟Candy实例对象的创建依据其Class对象。比较有意思的是
  
  Class.forName("com.zejian.Gum");
  
  1
  
  1
  
  其中forName方法是Class类的一个static成员方法,记住所有的Class对象都源于这个Class类,因此Class类中定义的方法将适应所有Class对象。这里通过forName方法,我们可以获取到Gum类对应的Class对象引用。从打印结果来看,调用forName方法将会导致Gum类被加载(前提是Gum类从来没有被加载过)。
  
  Class.forName方法
  
  通过上述的案例,我们也就知道Class.forName()方法的调用将会返回一个对应类的Class对象,因此如果我们想获取一个类的运行时类型信息并加以使用时,可以调用Class.forName()方法获取Class对象的引用,这样做的好处是无需通过持有该类的实例对象引用而去获取Class对象,如下的第2种方式是通过一个实例对象获取一个类的Class对象,其中的getClass()是从顶级类Object继承而来的,它将返回表示该对象的实际类型的Class对象引用。
  
  public static void main(String[] args) {
  
  try{
  
  //通过Class.forName获取Gum类的Class对象
  
  Class clazz=Class.forName("com.zejian.Gum");
  
  System.out.println("forName=clazz:"+clazz.getName());
  
  }catch (ClassNotFoundException e){
  
  e.printStackTrace();
  
  }
  
  //通过实例对象获取Gum的Class对象
  
  Gum gum = new Gum();
  
  Class clazz2=gum.getClass();
  
  System.out.println("new=clazz2:"+clazz2.getName());

  这种方式相对前面两种方法更加简单,更安全。因为它在编译器就会受到编译器的检查同时由于无需调用forName方法效率也会更高,因为通过字面量的方法获取Class对象的引用不会自动初始化该类。更加有趣的是字面常量的获取Class对象引用方式不仅可以应用于普通的类,也可以应用用接口,数组以及基本数据类型,这点在反射技术应用传递参数时很有帮助,关于反射技术稍后会分析,由于基本数据类型还有对应的基本包装类型,其包装类型有一个标准字段TYPE,而这个TYPE就是一个引用,指向基本数据类型的Class对象,其等价转换如下,一般情况下更倾向使用.class的形式,这样可以保持与普通类的形式统一。
  
  boolean.class = Boolean.TYPE;
  
  char.class = Character.TYPE;
  
  byte.class = Byte.TYPE;
  
  short.class = Short.TYPE;
  
  int.class = Integer.TYPE;
  
  long.class = Long.TYPE;
  
  float.class = Float.TYPE;
  
  double.class = Double.TYPE;
  
  void.class = Void.TYPE;
  
  前面提到过,使用字面常量的方式获取Class对象的引用不会触发类的初始化,这里我们可能需要简单了解一下类加载的过程,如下:
  
  加载:类加载过程的一个阶段:通过一个类的完全限定查找此类字节码文件,并利用字节码文件创建一个Class对象
  
  链接:验证字节码的安全性和完整性,准备阶段正式为静态域分配存储空间,注意此时只是分配静态成员变量的存储空间,不包含实例成员变量,如果必要的话,解析这个类创建的对其他类的所有引用。
  
  初始化:类加载最后阶段,若该类具有超类,则对其进行初始化,执行静态初始化器和静态初始化成员变量。
  
  由此可知,我们获取字面常量的Class引用时,触发的应该是加载阶段,因为在这个阶段Class对象已创建完成,获取其引用并不困难,而无需触发类的最后阶段初始化。下面通过小例子来验证这个过程:
  
  import java.util.*;
  
  class Initable {
  
  //编译期静态常量
  
  static final int www.dihaoyule798.com/ staticFinal = 47;
  
  //非编期静态常量
  
  static final int staticFinal2 =
  
  ClassInitialization.rand.nextInt(1000);
  
  static {
  
  System.out.println("Initializing Initable");
  
  }
  
  }
  
  class Initable2www.yuheng119.com/ {
  
  //静态成员变量
  
  static int staticNonFinal = 147;
  
  static www.xyseo.net{
  
  System.out.println("Initializing Initable2");
  
  }
  
  }
  
  class Initable3 {
  
  //静态成员变量
  
  static int staticNonFinal = 74;
  
  static {
  
  System.out.println("Initializing Initable3");
  
  }
  
  }
  
  public class ClassInitialization {
  
  public static Random rand = new Random(47);
  
  public static void main(String[] args) throws Exception {
  
  //字面常量获取方式获取Class对象
  
  Class initable = Initable.class;
  
  System.out.println("www.baqist.cn www.yyizx.cn After creating Initable ref");
  
  //不触发类初始化
  
  System.out.println(Initable.staticFinal);
  
  //会触发类初始化
  
  System.out.println(Initable.staticFinal2);
  
  //会触发类初始化
  
  System.out.println(Initable2.staticNonFinal);
  
  //forName方法获取Class对象
  
  Class initable3 = Class.forName("Initable3");
  
  System.out.println("After creating Initable3 ref");
  
  System.out.println(Initable3.staticNonFinal);
  
 

RRTI的概念以及Class对象作用