Class对象：类型信息在运行时是如何表示的，包含了与类有关的信息，用于创建类的所有的“常规”对象的，Java使用Class对象来执行其RTTI。
类是程序的一部分，每个类都有一个Class对象，被保存在一个同名的.class文件中,为了生存这个类的对象，JVM将使用“类加载器"。
所有类的都在在对其第一次使用时，动态加载到JVM中的。当程序创建第一个对类的静态成员的引用时，就会加载这个类。这个证实构造器也是类的静态方法，即使在构造器之前并没有使用static关键字。因此，使用new操作符创建类的新对象也会被当作类的静态成员的引用。
Class的API：###
getName():全限定的类名
getSimpleName():不包含包名的类名
getCanonicalName()：全限定的类名
getInterfaces():返回所有接口的Class对象
getClassLoader():返回该类的类加载器。
getComponentType():返回表示数组组件类型的 Class
getSuperclass():返回表示此 Class 所表示的实体的超类的 Class。
isArray():判定此 Class 对象是否表示一个数组类。
Class实例对象的newInstance()方法来创建的类，必须带有默认构造器。
Class对象的应用方法：###
1.Class.forName()
2.类字面常量：类型.class
简单，安全，因为它在编译时就会受到检查，不需要try语句包围，根除了对forName()方法的调用，所以也更高效。
类字面常量不仅可以应用于普通的类，也可以应用于接口，数组以及基本数据类型。
当使用“.class”来创建对Class对象的引用时，不会自动地初始化该Class对象。初始化被延迟到了对静态方法（构造器隐式地是静态的）或者非常数静态域进行首次引用时才执行。
泛化的Class引用###
Class<?>与Class等价，但优于平凡的Class，非具体的类引用
Class<? extends Number >:任何由Number派生的类
Class<? Super FancyToy>:某个类，它是FancyToy超类
instanceof与Class的等价性###
instanceof和isInstance()生成的结果完全一样，且保持类型的概念
Class的equals()和==也一样，比较实际的Class对象，没有考虑继承
注册工厂###
静态初始化器只有在类首先被加载的情况下才能被调用。
使用工厂方法设计模式，将对象的创建工作交给类自己去完成。工厂方法可以被多态的调用，从而创建适当类型的对象。
精简版（工厂方法就是Factory接口中的create()方法）：
public interface Factory<T> { T create();}
泛型参数T使得create()在每种Factory是实现中返回不同的类型
反射：运行时的类信息(RTTI)
编译时，编译器必须知道所有要通过RTTI来处理的类
反射提供了一种机制——用来检查可用的方法，并返回方法名。
运行时获取类的信息的另一个动机：希望提供在跨网络的远程平台上常见和运行对象的能力，即远程方法调用(RMI)。允许一个java程序将对象分布到多台机器上。
Class类与java.lang.reflect类库一起对反射的概念进行支持，该类库包含了Field、Method以及Constructor类(每个类都是先了Member接口)。这些类型的对象是由JVM在运行时创建的，用以表示未知类里对应的成员。
Constructor->创建新对象
get()和set()->读取和修改与Field对象关联的字段
invoke()方法->调用与Method对象关联的方法
getField(),getMethods()和getConstructors()->返回表示字段、方法以及构造器的对象数组
匿名对象的类信息就能在运行时被完全确定下来，而在编译时不需要知道任何信息。
详见JDK文档
对RTTI来说，编译器在编译时打开和检查.class文件；而对于反射机制来说，.class文件在编译时无法获取，所以在运行时打开和检查.class文件。
类方法提取器###
浏览实现了类定义的源代码或者其JDK文档，只能找到在这个类定义中被定义和被覆盖的方法。反射机制提供了一种方法，使我们能够编写自动展示完整接口的简单工具。
package typeinfo;
import static net.mindview.util.Print.print;
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
import java.util.regex.Pattern;
public class ShowMethod {
private static Pattern p = Pattern.compile("\\w+\\.");
public static void main(String[] args) {
try {
Class<?> c = Class.forName("typeinfo.ShowMethod");
Method[] methods = c.getMethods();
Constructor[] ctors = c.getConstructors();
for (Method method : methods) {
print(p.matcher(method.toString()).replaceAll(""));
}
for (Constructor constructor : ctors) {
print(p.matcher(constructor.toString()).replaceAll(""));
}
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
}
动态代理###
代理是基本的设计模式之一。它是你为了听过额外或不同的操作，而插入的用来替代“实际”对象的对象。这些操作通常涉及与“实际”对象的通信，因此代理通常充当中间人的角色。
package typeinfo;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
interface Interface{
void doSomething();
void somethingElse(String arg);
}
class RealObject implements Interface{
public void doSomething() {
System.out.println("doSomething");
}
public void somethingElse(String arg) {
System.out.println("somethingElse " +arg);
}
}
class DynamicProxyHandler implements InvocationHandler{
private Object proxied;
public DynamicProxyHandler(Object proxied) {
this.proxied = proxied;
}
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
System.out.println("*** proxy: " + proxy.getClass() +
", method: " + method + ", args: " + args);
if (args != null) {
for (Object arg : args) {
System.out.println(" " + arg);
}
}
return method.invoke(proxied, args);
}
}
public class SimpleDynamicProxy {
public static void consumer(Interface iface){
iface.doSomething();
iface.somethingElse("bonobo");
}
public static void main(String[] args) {
RealObject real = new RealObject();
consumer(real);
Interface proxy = (Interface) Proxy.newProxyInstance(
Interface.class.getClassLoader(),
new Class[] {Interface.class},
new DynamicProxyHandler(real));
consumer(proxy);
}
}
通过调用静态方法Proxy.newProxyInstance()可以创建动态代理，这个方法需要一个类加载器(通常从已经加载的对象中获取其类加载器)，一个希望该代理实现的接口列表(不是类或抽象类)，以及InvocationHandler接口的一个实现。
动态代理可以将所有调用重定向到调用处理器，因此通常会向调用处理器的构造器传递给一个“实际”对象的引用，从而使得调用处理器在执行其中介任务时，可以将请求转发。
在invoke()内部，在代理上调用方法时需要格外小心，因为对接口的调用将被重定向为对代理的调用。
使用Method.invoke()将请求转发给被代理对象，并传入必须的参数。
注释：内容来自《Java 编程思想》
