在日常开发时，经常需要将对象从一种类型转换为另一种类型。CLR允许将对象转换为它的（实际）类型或者它的任何基类型。

C#不要求任何特殊语法即可将对象转换为它的任何基类型，因为向基类型的转换被认为是一种安全的隐式转换。然而，将对象转换为它的某个派生类型时，C#要求开发人员只能进行显式转换，因为这种转换可能在运行时失败。可以理解为：父类强制转换成子类,子类隐式转换成父类

    internal class Employee
    {
    }

    class Program
    {
        static void Main(string[] args)
        {
        // 子类隐式转换成父类，不需要转换
        // 因为new返回一个Employee对象，而Object是Employee的基类
        Object o = new Employee();
        // 子类可以自动转父类 可以这么理解把子类的实例em的地址赋值给了o1, o1的地址就是em的地址
        // 这时就可以调用Employee 类的方法，点出Employee 类的属性
        Employee em = new Employee();
        Object o1 = em;

            // 父类强制转换成子类, 需要转换
            // 因为Employee派生自Object
            Employee e = (Employee)o;
        }
    }

在运行时，CLR会检查转型操作，确定总是转换为对象得实际类型或者它的任意类型。下面的代码虽然能通过编译，但会在运行时抛出InvalidCastException异常：

    internal class People
    {
    }

    internal class Employee : People
    {
    }

    internal class Manager : Employee
    {
    }

    class Program
    {
        static void Main(string[] args)
        {
            // 创建实例的时候没有将父类引用到子类对象,是无法转换的
            // PromoteEmployee不能运行成功
            People p = new People();
            PromoteEmployee(p);

            // 创建实例的时候将父类引用到子类对象,是可以转换的
            // PromoteEmployee能运行成功
            People p1 = new Employee();
            PromoteEmployee(p1);

            // Manager"属于"(IS-A)Employee对象
            // PromoteEmployee能运行成功
            Manager m = new Manager();
            PromoteEmployee(m);

            // DateTime不是从Employee派生的
            // PromoteEmployee不能运行成功
            DateTime newYears = new DateTime(2011, 10, 1);
            PromoteEmployee(newYears);
        }

        static void PromoteEmployee(Object o)
        {
            // 编译器在编译时无法准确地获知对象0引用的是什么类型，因此允许代码通过编译
            // 但在运行时，CLR知道了o引用的是什么类型（在每次执行转型的时候）
            // 所以它会核实对象的类型是不是Employee或者从Employee派生的任何类型
            Employee e = (Employee)o;
        }
    }

使用C#的is和as操作符来转型
在C#语言中进行转换的另一种方式是使用is操作符。is检查对象是否兼容于指定类型，返回Boolean值true或false。注意，is操作符永远不抛出异常，例如以下代码：

        static void Main(string[] args)
        {
            Object o = new Object();
            Boolean b1 = (o is Object);    //True
            Boolean b2 = (o is Employee);  //False
            Boolean b3 = (o is Nullable);  //False
        }

is操作符通常像下面这样使用：

        static void Main(string[] args)
        {
            Object o = new Employee();
            if( o is Employee )
            {
                Employee e = (Employee)o;
            }
        }

在上诉代码中，CLR实际检查两次对象类型。is操作符首先核实o是否兼容于Employee类型。如果是，在if语句内部转型时，CLR再次核实o是否引用一个Employee。CLR的类型检查增强了安全性，但无疑会对性能造成一定的影响。这是因为CLR首先必须判断变量(o)引用的对象的实际类型。然后CLR必须遍历继承层次结构，用每个基类型去核对指定的类型（Employee）。由于这是一个相当常用的编程模式，所以C#专门提供了as操作符，目的就是简化这种代码的写法，同时提升其性能。

        static void Main(string[] args)
        {
            Object o = new Employee();
            Employee e = o as Employee;
            if(e != null)
            {

            }
        }

在这段代码中，CLR核实o是否兼容于Employee类型；如果是，as放回对同一个对象的非null引用。如果o不兼容于Employee类型，as返回null。as操作符永远不抛出异常。注意，as操作符造成CLR只校验一次对象类型。if语句只检查e是否为NULL；这个检查的速度不校验对象的类型快得多。

测试代码：

namespace ConsoleApplicationTest
{
    internal class B{}

    internal class D : B{}

    class Program
    {
        static void Main(string[] args)
        {
            Object o1 = new Object(); //OK
            Object o2 = new B(); //OK
            Object o3 = new D(); //OK
            Object o4 = o3; //OK
            B b1 = new B(); //OK
            B b2 = new D(); //OK
            D d1 = new D(); //OK

            B b3 = new Object(); //编译时错误，正确：Object b3 = new B();
            D d2 = new Object(); //编译时错误，正确：Object b3 = new D();

            B b4 = d1; //OK，子类可以自动转父类
            D d3 = b2; //编译时错误，正确：D d3 = (D)b2;
            D d4 = (D)d1; //OK
            D d5 = (D)b2; //OK

            D d6 = (D)b1; //运行时错误，创建实例的时候没有将父类引用到子类对象
            B b5 = (B)o1; //运行时错误，创建实例的时候没有将父类引用到子类对象
            B b6 = (D)b2; //OK，创建实例的时候将父类引用到子类对象
        }
    }
}

一、引言

什么是RTTI

RTTI（Run-Time Type Identification) 运行时类型识别，最先出现在C++里，引入这个机制是为了让程序在运行时能根据基类的指针或引用来获得该指针或引用所指的对象的实际类型。

Java中的RRTI则是源于《Thinking in Java》一书，可以在程序运行时发现和使用类型信息。这使得我们从只能在编译期执行面向类型的操作中解脱出来。主要有两种方式：一是传统的RRTI，它假定我们在编译期已知道了所有类型(如new对象时必须定义好类型)；但并不是所有的Class都能在编译时明确，因此在某些情况下需要在运行时再发现和确定类型信息（比如：基于构建编程），这就需要第二种方式：反射机制，它允许我们在运行时发现和使用类型的信息。

为什么需要RTTI

按字面意思，我们在某些时候需要知道类的信息并使用它。具体看下面这个例子，我们定义了一个基类Animal及通用行为eat()，派生出的具体类有Dog、Cat和Brid，见下图。

在面向对象编程中基本目的是：让代码只操纵对基类（这里是Animal）的引用。为了实现这点，通常我们在创建具体类的对象时，都将其向上转型为对应的父类，然后在其余的代码中都使用这个父类，这是为了方便以后扩展，例如你可以向下面这样编码：

abstract class Animal {
	void eat() {
		System.out.println("吃");
	}
}

class Dog extends Animal {
	void eat() {
		System.out.println("狗吃骨头");
	}
}

class Cat extends Animal {
	void eat() {
		System.out.println("猫吃小鱼");
	}
}

class Brid extends Animal {
	void eat() {
		System.out.println("鸟吃虫子");
	}
}

public class AnimalTest {
	public static void main(String[] args) {
		List<Animal> aList = Arrays.asList(
			new Dog(), new Cat(), new Brid() 
		);
		for (Animal animal : aList) {
			animal.eat();
		}
	}
}

Output：

狗吃骨头
猫吃小鱼
鸟吃虫子

在这个例子中，创建 Dog、Cat、Brid对象放入List <Animal>中时会向上转型，同时也丢失了它们的具体类型，对于List而言，它们都是Animal类的对象。这时，假如我们需要知道某个泛化引用的确切类型，该怎么办呢？例如，我们只有骨头来喂食动物，猫和鸟并不吃骨头，怎么才能知道这个Animal对象是狗呢？或者我们想要拍动物在天空的照片，这时必须筛选出鸟类，因为其它动物不会飞。

使用RTTI，通过它可以查询某个Animal引用所指向的对象的确切类型，然后选择你需要的或者剔除你不要的。

二、深入理解Class对象

Class类的概念

想要理解RTTI在Java中的工作原理，首先得知道类型信息在运行时是如何表示的。Java用Class类来表示运行时的类型信息，首先必须明确，Class类跟Java API中定义的String、Integer等类以及我们自己定义的类是一样的，是一个实实在在的类，只不过名字特殊点，在JDK的java.lang包中。

那么Class类到底有什么作用呢？是什么的抽象，其实例又表示什么呢？

对于我们自己定义的类，我们用类来抽象现实中的某些事物，比如我们定义名为Dog的类来抽象现实中的狗，然后可以实例化这个类，用这些实例来表示一条黑狗、一条黄狗、我家的狗、你家的狗等等。我们还用Cat类来抽象现实中的猫，用Brid类来抽象现实中的鸟。那么，Dog、Cat、Brid这三个类之间有没有共同特征了，可不可以对这三个类进行抽象呢？

当然可以，我们都知道所有的class都是Object的子类，都有类名，有hashcode，可以判断类型属于class、interface、enum还是annotation。另外可以定义一些方法，比如获取某个方法、获取类型名等等。这样就封装了一个表示类型的类 — Class，用来提取这些类的一些共同特征，表示对这些类（或接口）的抽象。而Dog、Cat、Brid这三个类就分别是Class类的对象。也就是说，每个类都有一个Class对象，即每当我们编写并且编译一个新类，就会产生一个对应的Class对象，被保存在一个同名.class文件（编译后的字节码文件）里。

下面我们来分析一下Class类的源码：

//前一个Class表示这是一个类的声明，第二个Class是类的名称，
  <T>表示这是一个泛型类，并实现了四种接口。
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;

    //定义了一个名为registerNatives()的本地方法，并在静态块中调用：
    private static native void registerNatives();
    static {
        registerNatives();
    }

    // 私有构造函数，只能由JVM调用，创建该类实例
    private Class(ClassLoader loader) {
        classLoader = loader;
    }
    
    /*如果Class对象是一个Java类，返回class full_classname，即class 包名.类名；
      比如上面例子的List，返回的就是class java.util.List；
      如果是接口，将class改成interface；
      如果是void类型，则返回void；
      如果是基本类型，返回基本类型。*/
	public String toString() {
        return (isInterface() ?"interface " : (isPrimitive() ? "" : "class")) + getName();
    }

注意：Class类的构造器是private的，这意味着我们无法用new关键字得到一个Class对象。为了生成一个类的Class对象，必须通过运行Java虚拟机(JVM)中的类加载器子系统。

从上我们可以总结出：

• Class类的作用是运行时提供或获得某个对象的类型信息；
• Class类也是类的一种，只是名字和class关键字高度相似；
• Class类的对象表示你创建的类的类型信息，比如你创建一个Dog类，那么，Java编译后就会创建一个包含Dog类型信息的Class对象；
• Class类只有私有构造函数，因此对应的Class对象不能像普通类一样，以 new 操作符的方式创建，只能通过JVM加载。
• 一个class类有且只有一个相对应的Class对象（无论创建多少个实例对象，在JVM中都只有一个Class对象），如下图所示：
  

Class对象的加载

那么JVM是如何加载这个类的？

当程序创建第一个对类的静态成员的引用时，JVM中的类加载器子系统会将类对应的Class对象加载到JVM中。这个证明构造器也是类的静态方法，尽管构造器前并没有用static关键字修饰。因此，当我们使用new操作符创建一个类的实例对象时，也会被当作对类的静态成员的引用。

可以看出，Java一门动态加载的语言，Java中的类在需要时才会被加载。也就是说，我们编写出的Java程序，在它们开始运行之前并非被完全加载到内存的，其各个部分是在需要时才加载。因此，在我们需要用到某个类时，类加载器首先检查这个类的Class对象是否已被加载，如果没有加载，默认的类加载器就会先根据类名查找.class文件。在这个类的字节码文件被加载时，它们要接受验证，以确保其没有被破坏、并且不包含不良Java代码(这是java众多安全检测机制中的一个)，检测通过后Class对象就被载入内存了，可以被用来创建这个类的所有实例对象。下图表示了一个类加载的过程：

• 第一阶段（加载）：类加载器根据类名找到此类的.Class文件，并把这个文件包含的字节码加载到内存中，生成Class对象。

• 第二阶段（链接）：又分为三个步骤，分别是：

  （1） 验证阶段：确保Class文件的字节流中包含的信息符合当前虚拟机的要求，并且不会危害虚拟机自身的安全。

  （2） 准备阶段：正式为类变量(static 成员变量)分配内存并设置类变量初始值（零值）的阶段，这些变量所使用的内存都将在方法区中进行分配。

  （3）解析阶段：虚拟机将常量池内的符号引用替换为直接引用的过程。

• 第三阶段（初始化）：类中静态属性和初始化赋值，以及静态块的执行。

Class对象的获取方式

Java主要提供了三种方式来获取一个实例对象对应的Class对象：

1. Class.forName()：

这个方法是Class类的一个static成员方法。Class对象和其他对象一样，我们可以获取并操作它的引用，forName()就是取得Class对象的引用的一种方法，该方法允许我们无需通过持有该类的实例对象引用而去获取Class对象。

	try {
	  		//"com.yang"是包名
	 		Class c1 = Class.forName("com.yang.Dog");
		} 	catch (ClassNotFoundException e) {
		         e.printStackTrace();
 	   }

注意：如果Class.forName()没有找到你要加载的类，会抛出ClassNotFoundException异常。因此，在调用forName()方法时，需要向上面一样，给出一个ClassNotFoundException异常捕获。

2. getClass():

通过new一个对象，用这个对象调用getClass()方法来获取Class的引用。这个方法属于根类Object的一部分，将返回表示该对象类型的Class引用。

	Dog dog = new Dog();
	Class c2 = dog.getClass();

3. 类字面常量：

	//字面常量的方式获取Class对象
	Class c3 = Dog.class;

用类字面常量的方式来生成Class对象的引用，在编译时会受到检查（因此不需要置于try语句块中来捕获异常），相对前面两种方式显得更简单、更安全。

采用字面常量的方式不仅可以应用于普通的类，也可以应用在接口、数组以及基本数据类型，这点在反射技术应用传递参数时很有帮助，关于反射技术稍后会分析。另外，因为基本数据类型有着对应的基本包装类型，其包装类型有一个标准字段TYPE，而这个TYPE就是一个引用，指向基本数据类型的Class对象，其等价转换如下：

Class对象	TYPE字段
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对象时，触发的是加载阶段，并不会触发最后阶段类的初始化，下面引用《Java编程思想》中的例子来说明这点：

import java.util.*;

class Initable {
  //静态成员常量，编译期就确定值
  static final int staticFinal = 47;
  //静态成员常量，运行期才确定值
  static final int staticFinal2 =
    ClassInitialization.rand.nextInt(1000);
  //静态初始化块
  static {
    System.out.println("Initializing Initable");
  }
}

class Initable2 {
  //静态成员变量
  static int staticNonFinal = 147;
   //静态初始化块
  static {
    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("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);
  }
}

Output：

After creating Initable ref
47
Initializing Initable
258
Initializing Initable2
147
Initializing Initable3
After creating Initable3 ref
74

根据运行结果可以看出：

1. 初始化有效地实现了尽可能的“惰性”，通过.Class语法来获取Initable类的Class对象时没有触发初始化，通过Class.forName()方式来获取Initable3类的Class对象时就进行了初始化。
2. 调用Initable.staticFinal变量时，只输出了“47”，并没有打印“Initializing Initable”，说明也没有触发初始化，这是因为staticFinal值是“编译期静态常量”，在编译时其值“47”存储到了NotInitialization常量池中，对常量Initable.staticFinal的引用实际都被转化为NotInitialization类对自身常量池的引用了。如果将一个域只设置为static或final，如Initable2.staticNonFinal，还是会触发初始化。

（类型转换和反射将后续更新）

   代码摘抄自《java就业培训教程》——张孝祥老师。

class A{
	public void func1(){
		System.out.println("A func1 is calling");
	}
	public void func2(){
		func1();
	}
}

class B extends A{

	@Override
	public void func1() {
		System.out.println("B fun1 is calling");
	}
	public void func3(){
		System.out.println("B func3 is calling");
	}
	
}
public class C {
	public static void main(String args []){
		A a=new A();       
		callA(a);          //a应用传递给callA 
		callA(new B());    //直接把B对象做为一个A对象传递给函数
	}
	
	public static void callA(A a){
		if(a instanceof B){     //判断a指向的对象类型是否是B类型的
			B b=(B)a;           //因为a指向的对象原来就是B类型的
			b.func1();          //所以，这里可以强制转化，然后真的调用B类型的func3方法
			b.func2();
			b.func3();
		}else{
			a.func1();
			a.func2();
		}
		
	}
}

        简单理一下上面的类型转换过程：在第二个callA()方法时，传递给该方法的是一个B类型的对象。由于callA函数所接收的是一个A类型的对象，所以这里进行了一次类型转化（子类型对象转换为父类型对象）。接下来到了if判断那里，程序判断了一下a指向的对象是不是一个B类型的对象，结果是True，所以执行下面的代码。为了使用传递进来的对象，必须使用该对象的引用，也就是必须使用a，而a本身是A类型的引用，所以必须进行强制类型转化，即 B b=(B) a;这一句。这时相当于新建了一个B类型的引用b，指向了传递进来的B类型的对象。这样就可以使用传进来的对象的所有属性和方法了。

        从上面的过程就能看出来，强制类型转化把父对象转换成子对象，并不是把一个父对象真的补齐了子对象中多出的属性或者方法使之成为一个真正的子对象，而是原本一个子对象的地址由于某种原因赋值给了一个父类的引用后，程序员很明确的知道这个父对象的引用指向的是一个子对象时，才可以使用强制类型转化。