Java类型信息

类型信息

1、RTTI

　　RTTI(Run-Time Type Identification)是Java中非常有用的机制，在Java运行时，RTTI维护类的相关信息。

　　多态(polymorphism)是基于RTTI实现的。RTTI的功能主要是由Class类实现的。

2、Class对象

　　类是程序的一部分，每个类都有一个Class对象。Class对象就是用来创建类的所有的“常规”对象的，它包含了与类有关的信息。Java使用Class对象来执行其RTTI。

public class Test {
    public static void main(String[] args) {
        Class<?> c = null;
        try {
            c = Class.forName("com.my.chapter14.Man");
        } catch(ClassNotFoundException e) {
            System.out.println("Can't find Man");
            return;
        }
​
        System.out.println("Class name: " + c.getName() +
                " is interface? [" + c.isInterface() + "]");
        System.out.println("Simple name: " + c.getSimpleName());
        System.out.println("Canonical name : " + c.getCanonicalName());
        System.out.println("");
        for(Class<?> face : c.getInterfaces())
            System.out.println(face.getSimpleName());
        System.out.println("");
        
        Class<?> up = c.getSuperclass();
        Object obj = null;
        try {
            // Requires default constructor:
            obj = up.newInstance();
        } catch(InstantiationException e) {
            System.out.println("Cannot instantiate");
            return;
        } catch(IllegalAccessException e) {
            System.out.println("Cannot access");
            return;
        }
        System.out.println(obj.getClass());
    }
}
​
interface HasHouse{}
​
class Human{
    Human(){}
    Human(int i){}
}
​
class Man extends Human implements HasHouse{
    Man(){super(1);}
}
​
/*Output：
Class name: com.my.chapter14.Man is interface? [false]
Simple name: Man
Canonical name : com.my.chapter14.Man
​
HasHouse
​
class com.my.chapter14.Human
*/

 

3、类字面常量

　　通过类字面常量可以生成对Class对象的引用。

　　当通过“.class”来创建对Class对象的引用时，不会自动地初始化Class对象，初始化延迟到了对静态方法（构造器隐式地是静态的）或者非常数静态域进行首次引用时。Class.forName()立即就进行了初始化，而仅使用.class语法来获得对类的引用不会引发初始化。

　　如果static final值是“编译期常量”，那么不需要初始化就可以被读取0，如staticFinal。如果只是将一个域设置为static和final，访问时将强制进行类的初始化，如staticFinal2。

static final int staticFinal = 6;
static final int staticFinal2 = ClassInitialization.rand.nextInt(1000);

　　泛化的Class引用。Class<?>表示任何类型；Class<? extends Number>表示Number的子类；Class<？ super FancyToy>表示FancyToy的父类。

 

4、注册工厂

　　一个父类可能会派生出许多子类，当有新的子类产生时，需要将其添加进相应的列表中才便于管理和创建。因此这个列表应置于一个位于中心的、位置明显的地方，而基类就是这个最佳位置。

　　因此为了便于随机创建各个子类，需要运用工厂方法设计模式，将对象的创建工作交给类自己去完成。

interface Factory<T>{
    T create();
}
​
class Parts{
    @Override
    public String toString() {
        return getClass().getSimpleName();
    }
​
    static List<Factory<? extends Parts>> partFactories = new ArrayList<Factory<? extends Parts>>();
    static {
        partFactories.add(new FuelFilter.Factory());
        partFactories.add(new AirFilter.Factory());
        partFactories.add(new CabinAirFilter.Factory());
    }
    private static Random rand = new Random(47);
    public static Parts createRandom(){
        int n = rand.nextInt(partFactories.size());
        return partFactories.get(n).create();
    }
}
​
class Filter extends Parts{}
​
class FuelFilter extends Filter{
    public static class Factory implements com.my.chapter14.Factory<FuelFilter>{
        @Override
        public FuelFilter create() {
            return new FuelFilter();
        }
    }
}
​
class AirFilter extends Filter{
    public static class Factory implements com.my.chapter14.Factory<AirFilter>{
        @Override
        public AirFilter create() {
            return new AirFilter();
        }
    }
}
​
class CabinAirFilter extends Filter{
    public static class Factory implements com.my.chapter14.Factory<CabinAirFilter>{
        @Override
        public CabinAirFilter create() {
            return new CabinAirFilter();
        }
    }
}
​
public class Test {
    public static void main(String[] args) {
        Parts part;
        for(int i = 0; i < 20; i++) {
            part = Parts.createRandom();        System.out.print(part.getClass().getSimpleName() + " ");
        }
    }
}

 

5、反射：运行时的类信息

　　有时你从磁盘文件，或者网络连接中获取了一串字节，并且被告知这些字节代表一个类，而这个类在编译器为你的程序生成代码之后很久才出现，如何使用这样的类呢？通过反射机制可以解决该问题。对于反射机制来说，.class文件在编译时是不可获取的，所以是在运行时打开和检查.class文件。对RTTI来说，编译器在编译时打开和检查.class文件。

 

6、动态代理

　　代理就是将额外的操作从“实际”对象中分离到不同的地方，并且易修改。

　　通过Proxy.newProxyInstance()方法可以创建动态代理，这个方法需要一个类加载器，一个你希望该代理实现的接口列表，以及InvocationHandler接口的一个实现。通过Method.invoke()方法将请求转发给被代理的对象，并传入必需的参数。

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);
        Object ret = method.invoke(proxied, args);
        return ret;
    }
}
​
public class practice22 {
    public static void consumer(Interface iface) {
        iface.doSomething();
        iface.somethingElse("bonobo");
    }
​
    public static void main(String[] args) {
        RealObject real = new RealObject();
        Interface proxy = (Interface) Proxy.newProxyInstance(
                Interface.class.getClassLoader(),
                new Class<?>[]{ Interface.class },
                new DynamicProxyHandler(real));
        consumer(proxy);
    }
}

 

7、接口与类型信息

　　通过反射可以调用标识为private或包访问权限的方法。

package package1;
public interface A{
    void f();
}
​
package package1;
public class HiddenC{
    public static A makeA(){
        return new C();
    }
}
​
class C implements A{
​
    @Override
    public void f() {
        System.out.println("public void C.f()");
    }
    public void g(){
        System.out.println("public void C.g()");
    }
    void u(){
        System.out.println("void C.u()");
    }
    protected void v(){
        System.out.println("protected void C.v()");
    }
    private void w(){
        System.out.println("private void C.w()");
    }
}
​
package package2;
public class Test {
    static void callHiddenMethod(Object a, String methodName)
            throws Exception {
        Method g = a.getClass().getDeclaredMethod(methodName);
        g.setAccessible(true);
        g.invoke(a);
    }
​
    public static void main(String[] args) throws Exception {
        A a = HiddenC.makeA();
        a.f();
        callHiddenMethod(a,"g");
        callHiddenMethod(a,"u");
        callHiddenMethod(a,"v");
        callHiddenMethod(a,"w");
    }
}
​
/*Output：
public void C.f()
public void C.g()
void C.u()
protected void C.v()
private void C.w()
*/

 

 参考于《Java编程思想》，第313~351页