Java反射技术概述

反射技术主要应用于框架中，以下介绍未涉及框架，以简单类为例

//以下代码在同一包下，包名为：com.echo.reflect

//Person.java
public class Person{
    //字段
    public String name = "aaa";
    private int password = 123;
    private static int age = 17;
    //构造函数
    public Person(){
        System.out.println("Person");
    }
    public Person(String name){
        System.out.println(name);
    }
    public Person(String name,int password){
        System.out.println(name+":"+password);
    }
    private Person(List list){
        System.out.println("list");
    }
    //类的方法
    public void aa1(){
        System.out.println("aa1");
    }
    public void aa1(String name,int password){
        System.out.println(name+":"+password);
    }
    public Class[] aa1(String name,int[] password){
        return new Class []{String.class};
    }
    private void aa1(InputStream in){
        System.out.println(in);
    }
    public static void aa1(int num){
        System.out.println(num);
    }
    public static void main(String[] args){
        System.out.println("main!");
    }
}

1.反射类的构造函数

// 测试代码用junit测试的形式分不同函数进行分别测试

//ReflectDemo1.java 
public class ReflectDemo1{
    //反射构造函数：public Person()
    @Test
    public void test1() throws Exception{
        Class clazz = Class.forName("com.echo.reflect.Person");
        Constructor c = clazz.getConstructor();
        Person p = (Person)c.newInstance(null);
        Systeme.out.println(p.name);
    }
    /*
     test1输出结果： 
     Person
     aaa 

     第一行输出为构造函数中的打印，
     第二行为成功反射Person类之后调用的name值
    */

    //反射构造函数：public Person(String name)
    @Test
    public void test2() throws Exception{
        Class clazz = Class.forName("com.echo.reflect.Person");
        Constructor c = clazz.getConstructor(String.class);
        Person p = (Person)c.newInstance("xxx");
        Systeme.out.println(p.name);
    }
    /*
     test2输出结果： 
     xxx
     aaa 

     第一行输出为构造函数中的打印，
     第二行为成功反射Person类之后调用的name值
    */

    //反射构造函数：public Person(String name,int password)
    @Test
    public void test3() throws Exception{
        Class clazz = Class.forName("com.echo.reflect.Person");
        Constructor c = clazz.getConstructor(String.class,int.class);
        Person p = (Person)c.newInstance("xxx",12);
        Systeme.out.println(p.name);
    }
    /*
     test3输出结果： 
     xxx
     aaa 

     第一行输出为构造函数中的打印，
     第二行为成功反射Person类之后调用的name值
    */
}

2.反射类的方法

//ReflectDemo2.java 
public class ReflectDemo2{
    //反射类的方法：public void aa1()
    @Test
    public void test1() throws Exception{
        Person p = new Person();
        Class clazz = Class.forName("com.echo.reflect.Person");
        Method method = clazz.getMethod("aa1",null);
        method.invoke(p,null);
    }
    /*
     test1输出结果： 
     Person
     aa1

     第一行输出为构造函数中的打印，
     第二行为成功反射Person类中的aa1()方法的打印
    */

    //反射类的方法： public void aa1(String name,int password)
    @Test
    public void test2() throws Exception{
        Person p = new Person();
        Class class = Class.forName("com.echo.reflect.Person");
        Method method = clazz.getMethod("aa1",String.class,int.class);
        method.invoke(p,"echo",17);
    }
    /*
     test2输出结果： 
     Person
     echo:17

     第一行输出为构造函数中的打印，
     第二行为成功反射Person类中的aa1(String name,int password)方法的打印
    */

    //反射类的方法： public Class[] aa1(String name,int[] password)
    @Test
    public void test3() throws Exception{
        Person p = new Person();
         Class clazz = Class.forName("com.echo.reflect.Person");
         Method method = clazz.getMethod("aa1",String.class,int[].class);
         Class cs[] = (Class[])method.invoke(p,"echo",new int[]{1,2,3});
         System.out.println(cs[0]);
    }
    /*
     test3输出结果： 
     Person
     class java.lang.String

     第一行输出为构造函数中的打印，
     第二行为成功反射Person类中的public Class[] aa1(String name,int[] password) 返回值的打印
    */

    //反射类的方法： private void aa1(InputStream in)
    @Test
    public void test4() throws Exception{
        Person p = new Person();
        Class clazz = Class.forName("com.echo.reflect.Person");  
        Method method = clazz.getDeclaredMethod("aa1",InputStream.class);
        method.setAccessible(true);
        method.invoke(p,new FileInputStream("c:\\1.txt"));
    }
    /*
     test4输出结果： 
     Person
     java.io.FileInputStream@1e11f1

     第一行输出为构造函数中的打印，
     第二行为成功反射Person类中的private void aa1(InputStream in)
    */

    //反射类的方法： public static void aa1(int num)
    @Test
    public void test5() throws Exception{

        Class clazz = Class.forName("com.echo.reflect.Person");
        Method method = class.getMethod("aa1",int.class);
        method.invoke(null,123);//静态方法调用，第一个参数不需要填入对象
    }
    /*
     test5输出结果： 
     123
     输出为public static void aa1(int num)输入数据的打印，
    */

    //反射类的方法： public static void main(String[] args)
    @Test
    public void test6() throws Exception{

        Class clazz = Class.forName("com.echo.reflect.Person");
        Method method = class.getMethod("aa1",String[].class);
        method.invoke(null,(Object)new String[]{"aa","bb"});//jdk1.4升级到5.0的过程中，产生的兼容问题，需要对数组参数进行处理，也可以按照以下方法进行处理
        //method.invoke(null,new Object[]{new String[]{"aa","bb"}});
    }
    /*
     test6输出结果： 
     main!
     输出为main函数打印数据
    */
}

2.反射类的字段

//ReflectDemo3.java 
public class ReflectDemo3{
    //反射字段:public String name = "aaa";
    @Test
    public void test1 throws Exception(){ 
    Person p = new Person();
    Class clazz = Class.forName("com.echo.reflect.Person");
    Field f = clazz.getField("name");
    /*
    String name = (String)f.get(p);
    System.out.println(name);
    //当反射字段之后不知道字段的类型时，可以用以下方法得到字段的类型
    Class type = f.getType();
    System.out.println(type);
    //输出结果为：class java.lang.String
    */
    //所以，更加严谨的写法为
    //获取字段的值
    Object value = f.get(p);
    //获取字段的类型
    Class type = f.getType();
    if(type.equals(String.class)){
        String svalue = (String)value;
        System.out.println(svalue);
    }
    //设置字段的值
    f.set(p,"xxx");
    }
    /*
     test1输出结果： 
     Person
     aaa
     第一行为构造函数中的打印
     第二行为反射得到的字段的打印
    */

    //反射字段:private int password;
    @Test
    public void test2 throws Exception(){ 
    Person p = new Person();
    Class clazz = Class.forName("com.echo.reflect.Person"); 
    Field f = clazz.getDeclaredField("password");
    f.setAccessible(true);
    System.out.println(f.get(p));
    }
    /*
     test2输出结果： 
     Person
     123
     第一行为构造函数中的打印
     第二行为反射得到的字段的打印
    */

    //反射字段:private static int age = 17;
    @Test
    public void test3 throws Exception(){ 
    Person p = new Person();
    Class clazz = Class.forName("com.echo.reflect.Person"); 
    Field f = clazz.getDeclaredField("password");
    f.setAccessible(true);
    System.out.println(f.get(p));//虽然是静态，但也必须要传入一个对象
    }
    /*
     test3输出结果： 
     Person
     17
     第一行为构造函数中的打印
     第二行为反射得到的字段的打印
    */
｝