java 运行时类型识别(RTTI) - 2 - 反射

本文将叙述如何运行时查看类信息，其中包括变量，方法，以及通过反射修改变量，执行方法等
包括如何反射匿名内部类及如何执行其方法，但是笔者强烈不建议这么做，这里只是演示反射而已

下面是一个测试类
[java]
package reflect;

public class Outer {

    static{
        System.out.println("Testing..");
    }

    TestInterface ti = new TestInterface() {
        public String test() {
            return "this is ti";
        }
    };

    public Outer(String name){
        System.out.println("Outer");
    }

    public String toString(){
        System.out.println("Outer toString");
        return new TestInterface() {
            public String test() {
                return "this is a test!";
            }
        }.test();
    }

    @SuppressWarnings("unused")
    private void privateMethod(){
        System.out.println("privateMethod");
    }

    protected void protectedMethod(){
        System.out.println("protectedMethod");
    }

    void packageMethod(){
        System.out.println("packageMethod");
    }

    public static void staticMethod(){
        System.out.println("staticMethod");
    }

    public interface TestInterface {
        public String test();
    }

    public static class StaticInner {
        private static final String TAG = "StaticInnerTAG";
        public StaticInner(){
            System.out.println("StaticInner");
        }

        public String toString(){
            System.out.println("StaticInner toString");
            return TAG;
        }
    }

    private class Inner{
        String name;
        public Inner(){
            System.out.println("Inner");
        }

        public Inner(String name){
            System.out.println("reflect.Outer.Inner.Inner(String name)");
            this.name = name;
        }
    }
}
其中包括了普通内部类，静态内部类，内部匿名类，接口等
其中外部类Outer没有默认构造器，String reflect.Outer.Inner.getName()是private的……

外部类
Constructor,Method,Class.forName,newInstance
下面来看如何对上述的类进行反射
首先先看外部类Outer
[java]
public static void main(String[] args) {
    try {
        Class<?> outer = Class.forName("reflect.Outer");
        outer = Outer.class;
        Constructor<?>[] constructors = outer.getConstructors();
        for (Constructor<?> constructor : constructors) {
            Class<?>[] types = constructor.getParameterTypes();
            System.out.println(constructor.getName() + "(" + arrayToString(types) + ")");
        }

        Constructor<?> outerConstructor = outer.getConstructor(String.class);
        Outer outerInstance = (Outer) outerConstructor.newInstance("a outer");
        System.out.println(outerInstance);
    } catch (ClassNotFoundException e) {
        e.printStackTrace();
    } catch (SecurityException e) {
        e.printStackTrace();
    } catch (NoSuchMethodException e) {
        e.printStackTrace();
    } catch (IllegalArgumentException e) {
        e.printStackTrace();
    } catch (InstantiationException e) {
        e.printStackTrace();
    } catch (IllegalAccessException e) {
        e.printStackTrace();
    } catch (InvocationTargetException e) {
        e.printStackTrace();
    }
}

public static String arrayToString(Class<?>[] classes){
    StringBuilder stringBuilder = new StringBuilder();
    for (Class<?> type : classes) {
        stringBuilder.append(type.getCanonicalName());
        stringBuilder.append(",");
    }
    if(classes.length > 0){&n

补充：软件开发 , Java ,