RTTI和反射

Class对象

理解RTTI在java中的工作原理，首先必须知道类型信息在运行时是如何表示的。这项工作是由Class对象

的特殊对象完成的，它包含了与类有关的信息。

类是是程序的一部分，每个类都有一个Class对象。没当编写并编译了一个新类，就回产生一个Class对象（更恰当的说，是被保存在一个同名.class文件中）。为了生成这个类的对象，运行这个程序的Java虚拟机将使用被称为“类加载器”的子系统。

类加载其子系统实际上是一条类加载器链，但是只有一个原生类加载器，它是JVM实现的一部分。原生类加载器加载的是所谓的可信类 ，包括java API类，他们通常是从本地盘加载的。如果是从网络中下载的类，那么就需要挂载额外的类加载器。

所有的类都是在其第一次使用的时候，动态加载到JVM 的。当程序首次 new 一个类的对象，或者首次访问该类的静态成员时，类加载器就会首先检查这个类的Class对象是否已经加载。如果尚未加载，默认的类加载器就会根据类名查找.class文件，并加载到JVM中。（某些附加类加载器可能会在数据库中查找字节码）

因此，Java程序在它开始运行之前并非被完全加载，其各个部分是在必须时才加载的。

一旦某个类的Class对象被载如内存，它就被用来创建这个类的所有对象。

package com.cn.thk.typeInfo;

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 main(String[] args) {
		System.out.println("inside main");
		new Candy();
		System.out.println("After creating Candy");
		try {
			Class.forName("com.cn.thk.typeInfo.Gum");
		}catch (ClassNotFoundException e){
			e.printStackTrace();
		}
		System.out.println("After Class.forName('Gum')");
		new Cookie();
		System.out.println("After creating Cookie");
	}
}

无论何时，只要你想在运行时使用类型信息，就必须首先获得对恰当Class对象的引用。Class.forName就是实现此功能的便捷途径，因为你不需要为了获得Class引用而持有该类型的对象。

但是，如果已经拥有一个感兴趣的类型的对象，那就可以通过调用getClass()方法来获取Class引用了。这个方法是属于Object的一部分，它将返回表示该对象实际类型的Class引用。

package com.cn.thk.typeInfo;

interface HasBatteries{}
interface Waterproof{}
interface Shoots{}

class Toy{
	Toy(){}
	Toy(int i){}
}
class FancyToy extends Toy implements HasBatteries ,Waterproof,Shoots{
	public FancyToy() {
		super(1);
	}
}

public class ToyTest {
	static void printInfo(Class cc){
        // 是否接口
		System.out.println("cc is interface?["+cc.isInterface()+"]");
		System.out.println("Class name "+cc.getName());
		System.out.println("Class simple name "+cc.getSimpleName());
		System.out.println("Class canonical name "+cc.getCanonicalName());
	}
	public static void main(String[] args) {
		Class c=null;
		try {
			c = Class.forName("com.cn.thk.typeInfo.FancyToy");
			printInfo(c);
            // 所实现的接口列表
			for(Class face:c.getInterfaces()){
				printInfo(face);
			}
            // 获取直接父类
			Class up = c.getSuperclass();
//			printInfo(up);
			Object object = null;
			object = up.newInstance();
			System.out.println(object.getClass());
		}catch (ClassNotFoundException e){
			e.printStackTrace();
		} catch (IllegalAccessException e) {
			e.printStackTrace();
		} catch (InstantiationException e) {
			e.printStackTrace();
		}
		
	}
}

Class的newInstance方法是实现“虚拟构造器”的一种途径，虚拟构造器允许你声明：“我不知道你的确切类型，但是无论如何我都要正确的创建你自己”。此外，使用newInstance()来创建类，必须带有默认的构造器。

类字面常量

java还提供了另一种方法来生成对Class对象的引用，即使用类字面常量。如FancyToy.class。这样的写法简单，也更安全，因为这种写法在编译时就会受到检查（不需要try语句块了）。并且它根除了对forName()方法的调用，所以也更加高效。

类型字面量 不仅可以应用于普通的类，也可以应用于接口、数组以及基本数据类型。

和Class.forName()不同的是当使用.class来创建对Class对象的引用时，不会自动地初始化该Class对象。为了使用而做的准备工作其实包括三个步骤：

1. 加载，这个是由类加载器执行。该步骤将查找字节码，并从字节码中创建一个Class对象。
2. 链接。在链接阶段将验证类中的字节码，为静态域分配存储空间，并且如果必须的话，将解析创建这个类对其他类的所有引用。
3. 初始化。执行静态初始化器和静态初始化块。

类的初始化被延迟到了 new 一个类的对象，或者首次访问该类的静态成员时。初始化有效地实现了尽可能的“惰性”。

泛化的Class引用

java中允许通过使用泛型裕兴，限定Class引用所指向的Class对象的类型，这样可以让编译器强制执行额外的类型检查。

package com.cn.thk.typeInfo;

public class GenericClassReference {
	public static void main(String[] args) {
		Class iniClass = int.class;
		Class<Integer> genericIntClass = int.class;
		genericIntClass = Integer.class;
		iniClass = double.class;
		// 抛出异常
		// Error:(9, 41) java: 不兼容的类型: java.lang.Class<java.lang.Double>无法转换为java.lang.Class<java.lang.Integer>
		genericIntClass = double.class;
	}
}

为了在使用泛化的Class引用时放松限制，可以使用通配符，它是java泛型的一部分。通配符就是？，表示任何事物。

Class<?>在效果上和Class是等价的，为了限定为某种类型，或者该类型的任何子类型，可以将通配符与extends关键字相结合，创建一个范围。

ppackage com.cn.thk.typeInfo;

public class GenericClassReference {
	public static void main(String[] args) {
		Class iniClass = int.class;
		Class<? extends Number> genericIntClass = int.class;
		genericIntClass = Integer.class;
		iniClass = double.class;
		genericIntClass = double.class;
	}
}

向Class添加泛型语法的原因仅仅是为了提供编译期类型检查。

需要注意这个类必须假设和它一同工作的任何类型都具有一个默认的构造器（无参构造器），如果不符合该条件，你将得到一个异常。

package com.cn.thk.typeInfo;

import java.util.ArrayList;
import java.util.List;

class CountedInteger {
	private static long counter;
	private final long id = counter++;
	
	public String toString() {
		return Long.toString(id);
	}
}

public class FilledList<T> {
	private Class<T> type;
	
	public FilledList(Class<T> type) {
		this.type = type;
	}
	
	public List<T> create(int nElements) throws IllegalAccessException, InstantiationException {
		List<T> result = new ArrayList<T>();
		for (int i = 0; i < nElements; i++) {
			result.add(type.newInstance());
		}
		return result;
	}
	
	public static void main(String[] args) throws InstantiationException, IllegalAccessException {
		FilledList<CountedInteger> filledList = new FilledList<CountedInteger>(CountedInteger.class);
		System.out.println(filledList.create(10));
	}
}

instanceof和isInstance

1. obj instanceof Class 用于判断对象是否是某种类型或者派生类型
2. Class.isInstance(x)用于判断对象是否是某种类型或者派生类型

也可以用 equals或者==来判断两个Class是否同一种类型，但是相比instanceof和isInstance而言，它们没有考虑继承等的派生类型。

反射

java中在运行时识别对象和类的信息主要有两种方式，一种是“传统的”RTTI, 它假定我们在编译时就已经知道了所有的类型；另一种是“反射机制”，它允许我们在运行时发现和使用类的信息。

这两种方式的区别在与RTTI模式是编译器在编译时打开和检查.class文件。而对于反射机制来说，.class文件在编译时是不可获取的，所以是运行时打开和检查.class文件。

类方法的提取

反射是用来支持其它特性的，例如对象序列化和JavaBean。

package com.cn.thk.typeInfo;

import com.cn.thk.innerClass.ClosureCallbacks;
import com.cn.thk.innerClass.Sequence;
import sun.rmi.runtime.Log;

import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
import java.util.regex.Pattern;

public class ShowMethods {
	private static Pattern pattern = Pattern.compile("\\w+\\.");
	private void ss(){}
	static void parse(Class c) {
		try {
//			Class<?> c = Class.forName(className);
//			Method[] methods = c.getDeclaredMethods();
			Method[] methods = c.getMethods();
			Constructor[] constructors = c.getConstructors();
			for (Method method : methods) {
//				System.out.println("origin: "+method.toString());
				System.out.println(pattern.matcher(method.toString()).replaceAll(""));
			}
			for (Constructor constructor : constructors) {
//				System.out.println("origin: "+constructor.toString());
				System.out.println(pattern.matcher(constructor.toString()).replaceAll(""));
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
	
	public static void main(String[] args) {
		parse(ShowMethods.class);
		
	}
}