Class对象

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 编程思想》