首先介绍一个本文后面会频繁提到的概念：RTTI（Runtime Type Information，或者，Run-Time Type Identification），运行时类型信息。简单来说，就是指程序能够在运行时发现和使用类型信息。
RTTI能做什么？？它解放了程序在编期间执行的面向类型的操作，不管是程序的安全性还是可扩展性和可维护性，都得到了大大的加强。
我们一般使用二种方式来实现运行时识别对象和类的信息：“传统的”RTTI和“反射”机制。
一、一个大家都熟悉的例子
传统的RTTI假定我们在编译时已经知道了所有的信息。
下面我们来看一看一个很熟悉的例子：
1. <span style="font-size: small;">package
2.
3. import
4. import
5.
6. abstract class
7. void study(){ System.out.println(this+".study()");}
8. abstract public
9. }
10.
11. class PrimaryStudent extends
12. public String toString(){ return "PrimaryStudent";}
13. }
14.
15. class HighSchoolStudent extends
16. public String toString(){ return "HighSchoolStudent";}
17. }
18.
19. class UniversityStudent extends
20. public String toString(){ return "UniversityStudent";}
21. }
22.
23.
24. public class
25.
26. public static void
27. List<Student> studentList = Arrays.asList(
28. new PrimaryStudent(),new HighSchoolStudent(),new
29. );
30. for(Student s : studentList){
31. s.study();
32. }
33. }
34. }
35. /* output:
36. PrimaryStudent.study()
37. HighSchoolStudent.study()
38. UniversityStudent.study()
39. *///
40. </span>
基类Studeng中包含study方法，通过传递this参数给System.out.println()方法，间接使用toString()来打印类标识符。这里，toString()被声明为abstract，以此强制子类覆写该方法，并可以防止无格式的Student的实例化。
输出结果反映，子类通过覆盖toString方法，study()方法在不同的情况下会有不同的输出（多态）。
而且，在将Student对象放入List<Student>的数组时，对象被向上转型为Student类，但同时也丢失了Student对象的具体类型信息：对于程序而言，如果我们不对数组内的对象进行向下转型，那么，他们“只是”Student对象。
在上述例子中，还有一个地方用到了RTTI。容器List将它持有的对象都看做Object对象来处理。当我们从数组中取出对象时，对象被转型回Student类型。这是最基本的RTTI形式，因为在Java中，所有的类型转换都是在运行才进行正确性检查的。
还有一点，例子中的RTTI类型转换并不彻底：Object对象被转型为Student，而不是UStudent、PStudent、HStudent。这是因为程序只知道数组中保存的是Student，在编译时Java通过容器和泛型来确保这一点，而在运行时就由转型来实现。
例子很简单，但说明的东西很多。
二、一个特殊的编程问题
在现实当中，当我们能够知道某个泛化引用的确切类型的时候，我们可以方便快捷的解决它，怎么办？？
比如：我们扫描某个区域的生物(animal)，并将之装入一个数组。当用户要突出的显出其中的某一类，如人类，的时候，系统是并不容易判断的。因为，对于程序而言，数组中的对象都是aniaml。使用RTTI，可以查询animal引用的确切类型，然后选择或者剔除特例。
三、Class对象
Class对象是RTTI在Java中工作机制的核心。
我们知道，Java程序是由一个一个的类组成的。而对于每一个类，都有一个class对象与之对应。也就是说，每编译一个新类都会产生一个class对象（事实上，是这个class对象时被保存在同名和.class文件当中的）。这个过程涉及到类的加载，不在本文的内容之内。
无论何时，只要我们想要在运行时使用类型信息，就必须获得恰当的class对象的引用。
常规来讲，class对象有三种获得方式，而且，它包含很多有用的方法。看下面的程序：
1. package
2.
3. interface
4. interface
5.
6. class
7. //运行这个程序后，注释掉这个默认的无参构造器再试一试
8. int
9. }
10.
11. class CocaCola extends
12. implements
13. public CocaCola() { super(1);}
14. }
15.
16.
17. public class
18. static void
19. "Class Name:"+c.getName()+" is interface? ["+
20. "]");
21. "Simple Name:"+c.getSimpleName());
22. "Canonical Name:"+c.getCanonicalName());
23. }
24.
25.
26. public static void
27. null;
28.
29. try{
30. "cn.OOP.Typeinfo.CocaCola");
31.
32. //or we can init c in this way
33. // CocaCola cc = new CocaCola();
34. // c = cc.getClass();
35.
36. //we can also init c in this way
37. // c = CocaCola.class;
38.
39. catch(ClassNotFoundException e){
40. "Can't find CocaCola!!");
41. 1);
42. }
43.
44. printinfo(c);
45.
46. for(Class face : c.getInterfaces()){
47. printinfo(face);
48. }
49. }
50. }/* output:
51. Class Name:cn.OOP.Typeinfo.CocaCola is interface? [false]
52. Simple Name:CocaCola
53. Canonical Name:cn.OOP.Typeinfo.CocaCola
54. Class Name:cn.OOP.Typeinfo.Drinkable is interface? [true]
55. Simple Name:Drinkable
56. Canonical Name:cn.OOP.Typeinfo.Drinkable
57. Class Name:cn.OOP.Typeinfo.Sellable is interface? [true]
58. Simple Name:Sellable
59. Canonical Name:cn.OOP.Typeinfo.Sellable
60. *///
CocaCola类继承自Cola类并实现了Drinkable、Sellable接口。在mian方法中，我们用forName()方法创建了一个
Class对象的引用。需要注意的是，forName()方法传入的参数必须是全限定名（就是包含包名）
在printinfo()方法中，分别使用getSimpleName()和getCanonicalName()来打印出不含包名的类名和全限定的类名。isInterface()很明显，是得到这个class对象是否表示一个接口。虽然，我们这里只是演示了class对象的3种方法，但实际上，通过class对象，我们发现我们能够了解到类型的几乎所有的信息（之所以是“几乎”是因为我们有时候并不需要客户了解我们提供的类的某些信息，而选择性的屏蔽。大家可以试一试用class对象查询某些类的private属性！）
例子有出现了三种不同的获得class对象的方法：
Class.forName():最简单的，也是最快捷的方式，因为我们并不需要为了获得class对象而持有该类的对象实例。
obj.getClass():当我们已经拥有了一个感兴趣的类型的对象时，这个方法很好用。
Obj.class : 类字面常量，这种方式很安全，因为它在编译时就会得到检查（因此不需要放到try语句块中），而且高效。
我们可以根据我们的程序的条件和需要，选择上面三种方式中的任何一种来实现RTTI。
四、泛化的Class引用
通过上面的例子我们可以很容易的知道，class引用表示的是它所指向的对象的确切类型，并且，通过class对象我们
能获取特定类的几乎所有信息。这很容易理解。
但是，Java的设计者并不止步于此。通过泛型，我们可以让class引用所指向的类型更加具体。
package cn.OOP.Typeinfo;
1. public class
2.
3. public static void
4. int.class;
5. int.class;
6.
7. class; //same thing
8. double.class;
9. // genericIntClass = double.class; //Illegal，<span style="font-size: xx-small;"><span style="color: #333333; font-family: arial, sans-serif; white-space: normal; background-color: #f5f5f5;" class="hps">Can not</span><span style="color: #333333; font-family: arial, sans-serif; white-space: normal; background-color: #f5f5f5;"> </span><span style="color: #333333; font-family: arial, sans-serif; white-space: normal; background-color: #f5f5f5;" class="hps">compiled</span></span>
10. }
11. }
看这个例子，普通的Class引用intClass能被随意赋值指向任意类型，但是，使用了泛型之后，编译器会强制对class引用的重新赋值进行检查。
但这种泛型的使用与普通的泛型又是不同的，比如下面这条语句：
Class<Number> c = int.class;
乍一看，没什么不对，Integer继承自Number类，不就是父类引用指向子类对象么。但实际上，这句代码会在编译时就出错。因为Integer的class对象引用不是Number的Class引用的子类。这看起来很诡异，但却是事实。
事实上，正确的做法是使用通配符？。看下面：
package cn.OOP.Typeinfo;
1. public class
2.
3. public static void
4. int.class; //？ means everything
5. double.class;
6.
7. extends Number> longClass = long.class;
8. float.class; //Compile Success
9. }
10. }
通配符？表示“任何类”，所以intClass能够重新指向double.class。同时? extends Number 表示任何Number类的子类。
五、反射：RTTI实现和动态编程
就上面的例子我们看到，RTTI可以告诉你所有的你想知道的类型信息，前提是这个类型是在编译时候已知的。
这好像没有什么不对吧？？
将眼界放开点：假设程序获取了一个我们程序空间以外的对象的引用。即编译时并不存在的类。例如：从本地硬盘，从网络。要知道，Java的一大优势就是适于现在的WEB环境！！！
看下面：
package cn.OOP.Typeinfo;
1. import
2.
3. public class
4.
5.
6. public static void
7. null;
8. new
9. "Please put the name of the Class you want load:");
10. String ClassName = sc.next();
11.
12. try
13. c = Class.forName(ClassName);
14. "successed load the Class:"+ClassName);
15. catch
16. "Can not find the Class ACommonClass");
17. 1);
18. }
19.
20.
21. }
22. }
当我们运行这个程序的时候，系统会阻塞在这一步：String ClassName = sc.next();
这时的输出是：
Please put the name of the Class you want load:然后，由我们给定一个类名。假定，我们需要输入一个我们自定义的类：ACommonClass。注意，这是关键。这个时候，我们并没有开始写这个类，更没有编译这个类，也就没有对应的.class文件。
这个时候，写第二个程序（类）
package cn.OOP.Typeinfo;
1. public class
2. //I am just a generic Class
3. }
编译这个类，得到此类的.class 文件。然后，在程序一（注意，这个程序一直没有停止，一直在运行）输入类名：
cn.OOP.Typeinfo.ACommonClass，阻塞停止，打印输出。
最终结果：
Please put the name of the Class you want load:
1. cn.OOP.Typeinfo.ACommonClass
2. successed load the Class:cn.OOP.Typeinfo.ACommonClass
在这个例子中，我们看到了一个和以前传统的编程截然不同的东西：在程序运行时，我们还能云淡风轻的写着程序必须的类，而且，这个类还能用于这个已经开始的程序！！！！神奇吧。
当然，这只是一个最简单的RTTI反射应用，通常的Java动态编程会更复杂，也更神奇！！
Class类与java.lang.reflect类库一起对反射机制提供了支持。当通过反射与一个未知类型的对象打交道时，JVM只是简单的检查这个对象，看他属于哪个特定的类（就像传统的RTTI一样）。当我们用反射机制做某些事情时，我们还是必须知道特定的类（也就是必须得到.class文件），要么在本地，要么从网络获取。所不同的是，由于设计体系的特殊，我们逃避了在编译期间的检查，知道运行时猜打开和检查.class文件。
