java学习笔记---类型信息(type information)、反射机制与动态代理

（1）Class对象

要理解RTTI在java 中的工作原理，首先必须知道类型信息在运行时是如何表示的，这项工作是由成为Class对象的特殊对象完成的，它包含了与类有关的信息。

Class.forName(String classname)：Class类的静态方法，参数字符串必须包含包名，返回Class对象。

package cp14;

interface HasBatteries{}
class Toy
{
Toy(){}
Toy(int i ){}
void play()
{
System.out.println("Play it!");
}
}
class FancyToy extends Toy implements HasBatteries
{
FancyToy(){super(1);}
}
public class ToyTest
{
static void printInfo(Class c)
{
System.out.println("Class name: "+c.getName());//得到该类的全名，包括包名
System.out.println("Is interface()? "+c.isInterface());//判断该类是否为接口
System.out.println("Simple name: "+c.getSimpleName());//得到该类的的简单名字，也就是类名
System.out.println("Canonical name: "+c.getCanonicalName());//得到该类的全名，包括包名

}
public static void main(String[] args)
{
Class c=null;
try
{
c=Class.forName("cp14.FancyToy");
}
catch(ClassNotFoundException e)
{
System.out.println("Class not found!");
System.exit(1);
}
printInfo(c);
for(Class face:c.getInterfaces())//得到该类实现的所有接口
{
printInfo(face);
}
Class up=c.getSuperclass();
Object obj=null;
try
{
//使用newInstance()来创建的类必须带有默认的构造器
obj=(Toy)up.newInstance();//由该类的Class对象创建该类的实例，必须满足该类有一个午餐构造方法
}
catch(Exception e)
{
e.printStackTrace();
System.exit(1);
}
printInfo(obj.getClass());
//此时Toy对象向上转型为了Object对象，必须向下转型后才能调用Toy特有的方法
//obj.play();
((Toy)obj).play();
}
}

运行结果：

Class name: cp14.FancyToy
Is interface()? false
Simple name: FancyToy
Canonical name: cp14.FancyToy
Class name: cp14.HasBatteries
Is interface()? true
Simple name: HasBatteries
Canonical name: cp14.HasBatteries
Class name: cp14.Toy
Is interface()? false
Simple name: Toy
Canonical name: cp14.Toy
Play it!

java还提供了另一种方法来生成Class对象的引用，即使用类字面常量。类字面常量不仅可以应用于普通的类，也可以应用于接口、数组以及基本数据类型。另外对于基本数据类型的包装类，还有一个标准字段TYPE。TYPE字段是一个引用，指向对应的基本数据类型的Class对象，如下所示:

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对象。为了使用类而坐的准备工作实际包含三个步骤：

1）加载，这是由类加载器执行的。该步骤查找字节码，并从这些字节码中创建一个Class对象。

2）链接。在链接阶段将验证类中的字节码，为静态域分配存储空间，并且如果必须的话，将解析这个类创建的对其他类的所有引用。

3）初始化。如果该类具有超累，则对其初始化，执行静态初始化器和静态初始化块。

如果一个static final值是“编译器常量”，那么这个值不需要对其所属类进行初始化就可以被读取。但是只是将一个域设置为static或者final的，还不足以确保这种行为。

Class引用所指向的Class对象可以进行限定，这里使用了Class的泛化语法。

当将泛型语法用于Class对象时，newInstance ()方法将返回该对象的确切类型，而不仅仅是在ToyTest.java中看到的基本的Object。

public class GenericToyTest
{
public static void main(String[] args) throws Exception
{
Class<FancyToy> ftClass=FancyToy.class;
FancyToy fancyToy=ftClass.newInstance();
Class <? super FancyToy> up=ftClass.getSuperclass();
Object obj=up.newInstance();
//写成下面这种形式将无法编译，这简直不可思议
//Class <Toy> up3=ftClass.getSuperclass();
Class <Toy> up3=(Class<Toy>) ftClass.getSuperclass();
Toy obj3=up3.newInstance();
obj3.play();
}
}

（2）类型转换前先做检查

某个对象是不是某个类的实例

静态检查：instanceof()

Pet pet=new Pet();
if(pet instanceOf Pet)
{
System.out.println("true");
}

动态检查：isInstance()

Pet pet=new Pet();
Class<? extends Pet> cla=Pet.class;
if(cla.isInstance(pet)){}

（3）instanceof与Class的等价性

class Base{}
class Derived extends Base{}
public class FamilyVsExactType
{
static void test(Object x)
{
System.out.println("Testing x of type "+x.getClass());
System.out.println("x instanceof Base "+(x instanceof Base));
System.out.println("x instanceof Derived "+(x instanceof Derived));
System.out.println("Base isInstance(x)  "+Base.class.isInstance(x));
System.out.println("Derived isInstance(x)  "+Derived.class.isInstance(x));
System.out.println("x.getClass()==Base.class "+(x.getClass()==Base.class));
System.out.println("x.getClass()==Derived.class "+(x.getClass()==Derived.class));
System.out.println("x.getClass().equals(Base.class) "+(x.getClass().equals(Base.class)));
System.out.println("x.getClass().equals(Derived.class) "+(x.getClass().equals(Derived.class)));
}
public static void main(String[] args)
{
test(new Base());
test(new Derived());
}
}

输出结果是：

Derived isInstance(x)  false
x.getClass()==Base.class true
x.getClass()==Derived.class false
x.getClass().equals(Base.class) true
x.getClass().equals(Derived.class) false
Testing x of type class cp14.Derived
x instanceof Base true
x instanceof Derived true
Base isInstance(x)  true
Derived isInstance(x)  true
x.getClass()==Base.class false
x.getClass()==Derived.class true
x.getClass().equals(Base.class) false
x.getClass().equals(Derived.class) true

instanceof()和isInstance()结果完全一样，equals()和==也一样。instanceof保持了类型的概念，它指的是“你是这个类吗？或者你是这个类的派生类吗？”而如果使用==比较实际的Class对象，就没有考虑继承----它或者是这个确切类型，或者不是。

（4）动态代理

代理是基本的设计模式之一，它是你为了提供的额外的或不同的操作，而插入的用来代替“实际”对象的对象。这些操作通常涉及与“实际”对象的通信，因此代理通常充当着中间人的角色。下面是一个用来展示代理结构的简单示例：

interface Interface
{
void doSomething();
void doSomethingElse();
}
class RealObject implements Interface
{
public void doSomething()
{
System.out.println("do something.");
}
public void doSomethingElse()
{
System.out.println("do something else.");
}
}
class SimpleProxy implements Interface
{
private Interface proxied;
public SimpleProxy(Interface proxied)
{
this.proxied=proxied;
}
public void doSomething()
{
System.out.println("SimpleProxy do something.");
proxied.doSomething();
}
public void doSomethingElse()
{
System.out.println("SimpleProxy do something else.");
proxied.doSomethingElse();
}
}

public class SimpleProxyDemo
{
static void consumer(Interface iface)
{
iface.doSomething();
iface.doSomethingElse();
}
public static void main(String[] args)
{
consumer(new RealObject());
consumer(new SimpleProxy(new RealObject()));
}
}

输出结果是：

do something.
do something else.
SimpleProxy do something.
do something.
SimpleProxy do something else.
do something else.

java的动态代理比代理的思想要向前迈进了一步，因为它可以动态创建代理并动态地处理对所代理方法的调用。在动态代理上所做的所有调用都会被重定向到单一的调用处理器（InvocationHandler），他的工作是解释调用的类型并确定相应的对策。

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

interface SomeMethods
{
void boring1();
void boring2();
void interesting();
void boring3();
}
class Implementation implements SomeMethods
{
public void boring1()
{
System.out.println("boring1");
}
public void boring2()
{
System.out.println("boring2");
}
public void boring3()
{
System.out.println("boring3");
}
public void interesting()
{
System.out.println("interesting");
}
}
class MethodSelector implements InvocationHandler
{
private Object proxied;
public MethodSelector(Object proxied)
{
this.proxied=proxied;
}
@Override
public Object invoke(Object proxy,Method method,Object[] args) throws Throwable
{
if(method.getName().equals("interesting"))
{
System.out.println("Proxy detected interesting method!");
}
return method.invoke(proxied, args);
}
}
public class SelectingMethod
{
public static void main(String[] args)
{
SomeMethods proxy=(SomeMethods)Proxy.newProxyInstance
(SomeMethods.class.getClassLoader(),
new Class[]{SomeMethods.class},
new MethodSelector(new Implementation()));
proxy.boring1();
proxy.boring2();
proxy.boring3();
proxy.interesting();
}
}

输出结果是：

boring1
boring2
boring3
Proxy detected interesting method!
interesting

通过调用Proxy.newProxyInstance()可以创建动态代理，这个方法需要得到一个类加载器（你通常可以从已经被加载的对象中获取其类加载器，然后传递给它），一个你希望代理实现的接口列表（不是类或者抽象类），以及InvocationHandler接口的一个实现。