Java反射基础入门

Java反射基础入门，看完这一篇反射基础基本有了

反射的概念：

将java类中各个成分映射成对象

反射的用法

1.首先将类加载进内存
2.将类的属性加载进内存
3.将类的构造方法加载进内存用于实例化对象
4.将类的成员方法方法加载进内存

具体代码：

1.将类加载进内存

代码：

package Reflection;

import Reflection.domain.Person;

public class DemoTestGetClass {
    public static void main(String[] args) throws ClassNotFoundException {
        //通过全类名获取类，这里需要抛出异常，这种方法通常用在配置文件中
        Class cla1 = Class.forName("Reflection.domain.Person");
        System.out.println("cla1:"+cla1);

        //通过类名.class 获取类 这种方法通常用于参数传递
        Class cla2 = Person.class;
        System.out.println("cla2:"+cla2);

        //通过对象获取 这种方法通常用于获取对象的字节码文件
        Person p = new Person();
        Class cla3 = p.getClass();
        System.out.println("cla3:"+cla3);

        //比较内存地址
        System.out.println(cla1 == cla2);
        System.out.println(cla2 == cla3);

        //比较内存地址的值
        System.out.println(cla1.equals(cla2));
        System.out.println(cla2.equals(cla3));

        //结论：同一个字节码文件（*.class）在执行的时候只会被加载一次，不管哪一种方式获取的Class对象都是同一个
    }
}

运行结果：

2.将类的属性加载进内存并使用

代码：

//获取并使用成员方法
package Reflection;

import Reflection.domain.Person;

import java.lang.reflect.Field;

public class DemoTestUseClass1 {

    public static void main(String[] args) throws Exception {


        Class cla = Person.class;

        //获取public成员变量，并保存在数组中
        Field[] fields = cla.getFields();
        for (Field f:fields){
            System.out.println("public成员变量："+f);
        }

        //获取指定的public成员变量，//注意需要抛出异常
        Field fieldAssign = cla.getField("hobby");
        System.out.println("指定的public成员变量："+fieldAssign);

        //获取对象的成员变量的值 //注意抛出异常
        Person p = new Person();
        //获取指定变量的值
        Object valueOfP = fieldAssign.get(p);
        System.out.println("对象指定变量的值："+valueOfP);
        //修改指定变量的值
        fieldAssign.set(p,"打球");
        System.out.println("输出变量p："+p);

        //获取全部变量，不管修饰符是public,private。。。。
        Field[] declaedField = cla.getDeclaredFields();
        for (Field f1:declaedField){
            System.out.println("获取的全部成员变量，不管修饰符："+f1);
        }

        //获取指定的成员变量private修饰的也可以
        Field declaedAssignField = cla.getDeclaredField("name");
        declaedAssignField.setAccessible(true);//忽略访问修饰的安全检查
        System.out.println("获取的指定成员变量（不管访问修饰符）："+declaedAssignField);
        Person p1 = new Person();
        declaedAssignField.set(p1,"名字被修改");
        System.out.println("输出p1:"+p1);



    }
}

运行结果：

3.将类的构造方法加载进内存用于实例化对象

//获取并适应构造方法
package Reflection;

import Reflection.domain.Person;

import java.lang.reflect.Constructor;

public class DemoTestUseClass2 {
    public static void main(String[] args) throws Exception {
        Class cla = Person.class;

        //获取构造函数，//获取构造函数参数的class，这里需要和构造函数参数一致//需要抛出异常
        Constructor cons = cla.getConstructor(String.class,int.class,String.class);
        System.out.println("获取到的构造函数："+cons);

        //通过该构造函数实例化对象
        Object instanceObjWithThreeArgs = cons.newInstance("名字",18,"爱好打球");
        System.out.println("三参数对象:"+instanceObjWithThreeArgs);

        Constructor cons1 = cla.getConstructor();
        Object instanceObjWithZeroArgs = cons1.newInstance();
        System.out.println("零参数对象:"+instanceObjWithZeroArgs);

    }
}

运行结果：

4.将类的成员方法方法加载进内存并使用

//获取成员方法
package Reflection;

import Reflection.domain.Person;

import java.lang.reflect.Method;

public class DemoTestUseClass3 {
    public static void main(String[] args) throws Exception {
        Class cla = Person.class;


        //获取单个public成员方法
        Method oneMethodEat = cla.getMethod("eat");
        System.out.println("eat方法："+oneMethodEat);
        Method oneMethodSleep = cla.getMethod("sleep", int.class);
        System.out.println("sleep方法："+oneMethodSleep);

        //获取所有public成员方法
        Method[] allMethod = cla.getMethods();
        for (Method m:
             allMethod) {
            System.out.println("方法之一："+m);
        }

        //使用获取来的方法：
        Person p = new Person();
        oneMethodEat.invoke(p);
        //注意参数
        oneMethodSleep.invoke(p,8);


    }
}

运行结果：

注意事项

需要抛出异常

一些结论

同一个字节码文件（*.class）在执行的时候只会被加载一次，不管哪一种方式获取的Class对象都是同一个

实际运用

写一个”框架“不用修改代码，通过配置文件就可以创建任何类的对象

package Reflection;

import java.io.InputStream;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.Properties;

//写一个简单的框架，不需要修改代码就可以创建任何类的对象
public class ReflectTest {
    //1.读取配置文件，
    //2.利用配置文件和反射的构造函数创建实例化对象
    public static void main(String[] args) throws Exception {

        //将配置文件读取进来并加载该类
        Properties pro = new Properties();
        ClassLoader clo =ReflectTest.class.getClassLoader();
        InputStream is = ClassLoader.getSystemResourceAsStream("pro.properties");
        System.out.println("is:"+is);
        if (null != is){
            pro.load(is);
            System.out.println("成功加载配置文件");
        }
        //获取配置文件中的类和方法
        String className = pro.getProperty("className");
        System.out.println(className);
        String classMethod = pro.getProperty("methodName");
        String classArg = pro.getProperty("arg");
        System.out.println("classArg:"+classArg);

        //将类加载进内存
        Class cla = Class.forName(className);
        System.out.println("cla:"+cla);
        Object obj = cla.newInstance();
        Method m = cla.getMethod(classMethod);
//        Field f = cla.getField(classArg);
//        f.set(obj,3);

        m.invoke(obj);

    }



}

配置文件：

className=Reflection.domain.Person
methodName=sleep

运行结果：

思维导图总结

说明

这是我学习的时候总结的，如果有错误或者不准确的感谢指出