java中的反射

要说java中的反射首先得说说java中的类加载机制。首先java源文件通过编译，生成字节码文件存在硬盘上，虚拟及启动后，根据main函数调用到类的先后顺序动态的加载类到内存，加载有一个原则，首先加载bootstrap classloader：系统类的类加载器；再加载ExtClassLoader：系统中一部分的类加载器；最后是AppClassLoader：应用程序中自己定义的类加载器。三者的关系依次是parentclassloader的关系。因此，在classloader看来，加入内存的类的字节码也是一个个的对象，因此也应该有抽象出来的共性，所以就引出了Class类，Class类是所有字节码类的抽象的结果，每个类中都有的因素比如属性，方法等。而将类中的这些成员抽象成类就是反射。用反射我们可以动态的去加载一个类，动态的去了解一个类。因此可以说反射是java动态编程的重要一部分。

这里先简要的说说class中反射出的method类，field类，constructor类。

1.

要生成类对象，一个大众的方法就是通过constructor类生成对应构造函数参数的constructor类，再通过constructor类的newInstance（）方法传入刚设置的参数，最后生成这个类的实例。

package reflect;

import java.lang.reflect.Constructor;
import java.lang.reflect.Method;

public class TestReflect {

    public static void main(String[] args) throws Exception {
        // TODO Auto-generated method stub
        Class<?> c = Class.forName("reflect.Test1");//通过反射得到名字为Reflect.Test1的类对象
        Test1 test11  = (Test1)c.newInstance();//创建Test的实例 无参
        test11.show1();
        Constructor<?> cons = c.getConstructor(int.class);
        Test1 test12 = (Test1)cons.newInstance(1000);
        test12.show1();
        System.out.println("------------------");
        
        Method m = c.getMethod("show2"); //用get方法只能得到声明为public的成员
        m.invoke(null);//静态方法不通过对象
        
        /*Method[] methods = c.getMethods();
        for(Method m : methods){
            System.out.println(m.getName());//只有public的method方法才可见
        }*/
        
    }

}

class Test1{
    static String s1 ="aaaabb";
    static int i =100;
    public Test1() {
        System.out.println("no parameter constructor");
    }
    public Test1(int i){
        this.i = i;
        System.out.println("Test1 constructor");
    }
    //如果需要开放最好设置为public权限
    public static void show2(){
        System.out.println(i + " " +s1);
    }
    
    public void show1 (){
        System.out.println(s1 + " " +i);
    }
    @Override
    public String toString(){
        return null;
    }
}

 

这里要说明，通过constructor类生成的对象，一般都是自己找的构造函数的生成的对象，如果生成的类需要在构造函数中初始化的话一般用这中方法。而class类中也有newInstance（）方法，其实就用简略的方法直接实现了无参数的构造函数生成对象。上例中通过打印结果可以看出结果，而且还可以验证了静态代码块在类加载内存的只执行一次，构造函数和构造代码块在每次生成对象都会调用一次。

2.

field类是表示类中的成员属性，这里通过对一个类中的所有的string成员属性进行字符串替换学习：

 

package reflect;

import java.lang.reflect.Field;

//用反射实现，将任意一个对象成员中string成员中的"eng"换成字符"cn"。

public class TestReflect1 {

    public static void main(String[] args) throws Exception {
        Class c = Class.forName("reflect.Test2");
        Field[] fields = c.getFields();
        Test2 test21 = (Test2)c.newInstance();
        test21.show();
        System.out.println("------------------");
        for(Field f : fields){
//            System.out.println(f.getName());
            if (f.getType().equals(String.class)) {
//                System.out.println(f.getType().getName());
                String s = (String)f.get(test21);
                if(s.contains("eng")){
                    s = s.replace("eng", "chn");
                    }
                f.set(test21, s);
            }
            
        }
        test21.show();
    }

}

class Test2{
    //public
    public String s1 = "i am eng";
    public String s2 = "i from eng";
    void show (){
        System.out.println(s1 + "\n" +s2);
    }
    
}

通过两个例子，我们大概可以看出class类的一些使用规律，比如a：getXXX返回的一般是一个数组型的，里面包含了所有了这个属性的值，后续操作的时候要先判断是自己要用的那个属性；b：getdeclaredXXX的返回的是按照自己设置的存在的，而且以后使用的时候只能按照取出来的时候的规则使用。c:因为定义的时候并不知道返回的是什么值，所以这部分需要相当一部分的类型转换。

3.

Method类，也遵循上述总结的规律，这里也用例子直接说明：

package reflect;

import java.lang.reflect.Method;

public class TestReflect2 {

    public static void main(String[] args) throws Exception {
        // TODO Auto-generated method stub
//        TestMethod.main("11","22","33");//直接传入字符串
        TestMethod.main(new String[]{"99","88","77"});//传入字符串数组
        
        Method m = Class.forName("reflect.TestMethod").getDeclaredMethod("main", String[].class);
        /*
        理解难点，因为这里原来是string[]，而且并不知道传入的参数的个数，所以这里解决方法是把他看作是一个string[]的整体，
        而这个整体的就可以匹配未定义长度的string[]，所以这里string[]其实是当作一个参数看待的
*/
//        m.invoke(null, new String[]{"11","22","33"});//因为string不是基本类型，所以函数认为传了三个参数进去，但是只应该传一个进去
        m.invoke(null, new Object[]{new String[]{"11","22","33"}});
        m.invoke(null, (Object)new String[]{"11","22","33"});

    }

}

class TestMethod{
    static void main(String[] args){
        int i = 0;
        for(String s : args){
            System.out.println((i++)+" : "+s);
        }
    }
}

这里也有一个理解上的难点，就是注释的部分。我现在理解的也不是很透彻，注释部分按照目前的理解分享出来，以后有新心得在补充。

 

然后看到javabean的内省，按照目前的理解是内省是一种特殊的反射，即成员属性，成员方法比较有规律的一种情况？以后学习完整了新开文章分析。