Java之RTTI和泛型学习

RTTI

一个类的运行时的类型信息是通过class类的对象来表示的，Java利用Class对象来执行RTTI。

每一个类都有一个Class对象，每当编写一个类时，都会产生一个Class对象，当JVM加载该类时这个对象就产生了。

如何获取Class对象

• 通过Class类的静态方法forName来获取Class对象，具体形式如下：

Class class = Class.forName(String); //String是类完全限定名字符串

获取到一个类的Class对象后就可以通过其接口做一些事情，具体如下：

class.getName();//获取该类的限定名

class.getSimpleName();//获取该类的简单名

class.getSuperclass();//获取该类的父类的Class对象

• 通过类的内部的成员常量class来获取，具体形式如下：

Class class = <Class>.class;

两种方法的比较

• 相比Class.forName方法，T.class方法更安全，在编译时就会被检查，因此不需要放在Try/Catch块里
• Class.forName会引起类的静态初始化块的执行，T.class不会引起类的静态初始化块的执行

Class类的一些常见函数

• 通过函数getClass来获取，具体形式如下：

//获取Person类的Class对象

Object o = new Person()；

Class class = o.getClass()；

    上述获取Class对象的都是采用非泛化的方法，虽然这样做没有问题，但是并不安全。可以限定Class对象能够指向的类型，这样可以强制编译器进行额外的类型检查。

//依然是获取Person类的Class对象

Class<Person> class = Person.class;

//如果是下面这样就会报错

Class<Person> class = Manager.class;

• 同时也可以采用通配符？表示任何类型，或者配合extends和super来规定一个范围

假设Person有子类Student

Class<? extends Person> class = Student.class;//规定可以是继承自Person类

Class<? super Student> class = Person.class;//规定可以是Student的父类

    通过RTTI可以获取对象的类型信息，但前提是这个类型必须在编译时已知，即编译时类型必须定义好。

但是很多情况下这种情况并不能满足，此时可以通过reflection（反射）机制来获取运行时的对象信息。

• 通过获取的Class对象，可以得到该类内所有的方法和变量等：

//还是通过Person对象来举例

Class<?> class = Person.class;

Construtor<?>[] cons = class.getConstructors();

Method[] methods = class.getMethods();//获取所有的方法，包括继承的

Method[] methods = class.getDeclaredMethods();//获取在本类中定义的方法

• 获取获取的Class对象来创建实例:

//通过直接调用newInstance方法来创建实例，等价于调用该类的缺省构造函数

Person person = (Person)class.newInstance();

//调用调用getConstructor函数+newInstrance函数来创建实例，根据newInstance的参数匹配对应的构造函数

Person person = (Person)class.getContructor(String.class).newInstance("John");//这里先根据getConstructor(String.class)获取Person的构造函数Person(String str)，再调用newInstance("John")函数实例化。

• 调用获取到的其他函数

Method method = class.getMethod("setName",String.class);//这里的第一个参数表示的是获取的函数名，后面的参数表示函数的参数类型。

method.setAccessible(true);//如果方法是private的，需要调用该方法
method.invoke(s,"Hello")；//通过invoke函数来调用该函数，其中第一个参数表示调用函数的对象，后面的参数表示该函数的对象。

泛型

所谓范性就是参数化参数类型

使用泛型的优点

当使用了泛型后可以在编译时即可检测出类型不匹配的错误，举例如下：

ArrayList<String> list = new ArrayList<String>();

list.add(new Integer(1));//这时在编译时就会报错，规定了泛型为String类型

需要注意的是，泛型必须的参数类型必须是引用类型，比如：

ArrayList<int> list = new ArrayList<int>();//int不是引用类型，会报错

泛型的实现原理

泛型是采用擦除法实现的，编译器采用泛型类型信息来编译代码，但是后期会擦除参数类型，因此泛型信息在运行时是不可用的。

• 当泛型编译类，接口和方法时，会用Object代替泛型的参数类型E，比如：

//使用泛型来编写方法

public <E> void print(E msg){....};

//运行时的方法

public void print(Object msg){....};

• 当泛型的参数类型受限时，编译器会采用该受限类型来代替它，比如：

//使用受限的泛型参数类型编写方法

public <E extends Person> void print(E msg){....}；

//运行时的方法

public void print(Person msg){....};

泛型的使用限制

• 不可以用泛型类型来调用new实例化对象，例如：

public <E> void print(){

    E o = new E();//这样是错误，只可以用newInstance()函数来创建

    E[] o = new E[capacity];

}

• 不可以通过泛型类型来进行类型转换，例如：

E o = (E)new Person();

• 不可以通过泛型来new数组，例如：

ArrayList<String> list = new ArrayList<String>[10];

• 在静态方法，数据域或者初始化语句中都不能使用泛型的参数类型，例如：

public static print(E e);//非法

public static E e;//非法

static{

    E e;//非法

}

• 异常类不能是泛型的，例如：

public class MyException<E> extends Exception{

}

  因为如果采用泛型的参数类型的化，JVM必须检查这个从try语句中抛出的异常以确定与catch语句中的异常类型匹配，但这不可能，因为运行时的类型信息是不可获得的。