java反射机制学习与总结

定义

Java的反射（reflection）机制是指在程序的运行状态中，可以构造任意一个类的对象，可以了解任意一个对象所属的类，可以了解任意一个类的成员变量和方法，可以调用任意一个对象的属性和方法。这种动态获取程序信息以及动态调用对象的功能称为Java语言的反射机制。反射被视为动态语言的关键。

用途

在日常的第三方应用开发过程中，经常会遇到某个类的某个成员变量、方法或是属性是私有的或是只对系统应用开放，这时候就可以利用Java的反射机制通过反射来获取所需的私有成员或是方法。当然，也不是所有的都适合反射，之前就遇到一个案例，通过反射得到的结果与预期不符。阅读源码发现，经过层层调用后在最终返回结果的地方对应用的权限进行了校验，对于没有权限的应用返回值是没有意义的缺省值，否则返回实际值起到保护用户的隐私目的。

1、获取class类的对象

我们要想通过反射去使用一一个类，首先我们要获取到该类的字节码文件对象，也就是类型为Class类型的对象
这里我们提供三种方式获取Class类型的对象
●使用类的class属性来获取该类对应的Class对象。 举例: Student.class将 会返回Student类对应的Class对象
●调用对象的getClass()方法, 返回该对象所属类对应的lass对象该方法是Object类中的方法，所有的Java对象都可以调用该方法
●使用Class类中的静态方法forName(tring className),该方法需要传入字符串参数,该字符串参数的值是某个类的全路径，也就是完整包名的路径

对比：第一种 使用性最高 第三种可以把路径写在配置文件中 灵活性更强

定义一个student类

public class Student {
    //成员变量： 一个私有，一个默认，一个公共
    private String name;
    int age;
    public String address;
    //构造方法 一个私有 一个默认 两个公共
    public Student(){
    }
    private Student(String name){
        this.name=name;
    }
    Student(String name,int age){
        this.name=name;
        this.age=age;
    }
    public Student(String name,int age,String address){
        this.name=name;
        this.age=age;
        this.address=address;
    }
    //成员方法 一个私有，四个公共
    private void function(){
        System.out.println("function");
    }
    public void method(){
        System.out.println("method");
    }
    public  void method_01(String s){
        System.out.println("method"+s);
    }
    public String method3(String s,int i){
        return s+","+i;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", address='" + address + '\'' +
                '}';
    }
}

获取class对象

public class ReflectDemo {
//  三种方式获取Class类型的对象
    //使用类的class属性来获取该类对应的Class对象。 举例: Student.class将 会返回Student类对应的Class对象
    //调用对象的getClass()方法, 返回该对象所属类对应的lass对象该方法是Object类中的方法，所有的Java对象都可以调用该方法
    //使用Class类中的静态方法forName(tring className),该方法需要传入字符串参数,该字符串参数的值是某个类的全路径，也就是完整包名的路径
    public static void  main(String[] args) throws ClassNotFoundException {
        //使用类的class属性来获取该类对应的Class对象。 举例: Student.class将 会返回Student类对应的Class对象
        Class<Student> c1 = Student.class;
        System.out.println(c1);

        Class<Student> c2 = Student.class;
        System.out.println(c1==c2);
        System.out.println("---------------------");
        //调用对象的getClass()方法, 返回该对象所属类对应的lass对象该方法是Object类中的方法，所有的Java对象都可以调用该方法
        Student s=new Student();
        Class<? extends Student> c3 = s.getClass();
        System.out.println(c1==c3);
        System.out.println("---------------------");
        //使用Class类中的静态方法forName(tring className),该方法需要传入字符串参数,该字符串参数的值是某个类的全路径，也就是完整包名的路径
        Class<?> c4 = Class.forName("com.wanxi.wanxi_02.Student");
        System.out.println(c1==c4);
    }
}

获取构造方法并使用

public class ReflectDemo_01 {
//    反射获取构造方法并使用
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        //1、获取class对象  使用第三种方法
        Class<?> aClass = Class.forName("com.wanxi.wanxi_02.Student");
        //2、获取构造方法
        // getConstructors() 获得该类的所有公有构造方法 返回一个数组
        //Constructor<?>[] cons = aClass.getConstructors();
        //getDeclaredConstructors() 获得该类所有构造方法 返回一个数组
        Constructor<?>[] cons = aClass.getDeclaredConstructors();
        //遍历数组
        for(Constructor con:cons){
            System.out.println(con);
        }
        System.out.println("---------------");
        //getConstructor(Class...<?> parameterTypes) 获得该类中与参数类型匹配的公有构造方法
        Constructor<?> con = aClass.getDeclaredConstructor(String.class);
        //通过构造方法对象的newInstance 创建对象
        //正常情况下不能私有方法创建对象 但在反射中可以
        //暴力反射
        //public void setAccessible(boolean flag):值为true 取消访问检查
        con.setAccessible(true);
        Object obj = con.newInstance("小花");
        System.out.println(obj);
    }
}

获取成员变量并使用

public class ReflectDemo_02 {
    //反射获取成员变量并使用
    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        //获取class对象
        Class<?> aClass = Class.forName("com.wanxi.wanxi_02.Student");
        //获取成员变量
        // getFields() 获得所有公有的属性对象  返回数组
        //getField(String name) 获得某个公有的属性对象
        //getDeclaredFields() 获得所有属性对象  返回数组
        //getDeclaredField(String name) 获得某个属性对象
        Field[] fields = aClass.getDeclaredFields();
        for(Field field:fields){
            System.out.println(field);
        }
        System.out.println("---------------------------");

        Field field = aClass.getDeclaredField("address");
        //获取无参构造方法创建对象
        Constructor<?> con = aClass.getDeclaredConstructor();
        Object obj = con.newInstance();
        //Field提供的有关类或者接口的单个字段信息和动态访问
        // void set(Object obj,Object value)将指定的对象参数中由此field对象表示的字段设置为指定的新值
        field.set(obj,"西安");
        System.out.println(obj);

    }
}

获取成员方法并使用

public class ReflectDemo_03 {
    //获取成员方法 并使用
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        //获取class对象
        Class<?> aClass = Class.forName("com.wanxi.wanxi_02.Student");
        //获取成员方法
        //getMethod(String name, Class...<?> parameterTypes)	获得该类某个公有的方法
        //getMethods()	获得该类所有公有的方法 包含继承的父类的方法
        //getDeclaredMethod(String name, Class...<?> parameterTypes)	获得该类某个方法
        //getDeclaredMethods()	获得该类所有方法  不包含继承的父类的方法
        Method[] methods = aClass.getDeclaredMethods();
        for(Method method:methods){
            System.out.println(method);
        }
        System.out.println("--------------");
        Method method = aClass.getDeclaredMethod("method");
        //获取无参构造方法创建对象
        Constructor<?> con = aClass.getDeclaredConstructor();
        Object obj = con.newInstance();
        //在类或接口上提供有关单一方法的信息和访问权限
        //Object invoke(Object obj,Object....args)在具有指定参数的指定对象上调用此方法对象表示的基础方法
        //Object :返回值类型
        //obj ：调用方法的对象
        //args:方法需要的参数
        method.invoke(obj);
    }
}

应用

1、向一个arrayList集合中添加字符串数据

public class RefectDemo_04 {
    //向一个arrayList<Integer>集合中添加字符串数据
    public static void main(String[] args) throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
        //定义集合
        ArrayList<Integer> list=new ArrayList<>();
//        list.add(10);
//        list.add(20);
//        System.out.println(list);
        Class<? extends ArrayList> aClass = list.getClass();
        Method method = aClass.getDeclaredMethod("add", Object.class);
        method.invoke(list,"hello");
        System.out.println(list);


    }
}

2、通过配置文件运行类中的方法

public class Student {
    public void Study(){
        System.out.println("好好学习");
    }
}

ClassName=com.wanxi.wanxi_03.Student
MethodsName=Study

public class ReflectDemo_05 {
    //通过配置文件运行类中的方法
    public static void main(String[] args) throws IOException, ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
//        Student student=new Student();
//        student.Study();
//        Teacher teacher=new Teacher();
//        teacher.Teach();
        //配置一个class.txt 把类名和方法放在其中 ClassName=类名 MethodsName=方法名
        //加载数据
        Properties properties=new Properties();
        FileReader fileReader=new FileReader("D:\\wangxi\\myreflect\\class.txt");
        properties.load(fileReader);
        fileReader.close();
        /*
        ClassName=com.wanxi.wanxi_03.Student
        MethodsName=Study
         */
        String className=properties.getProperty("ClassName");
        String methodsName=properties.getProperty("MethodsName");
        //通过反射使用
        Class<?> aClass = Class.forName(className);//com.wanxi.wanxi_03.Student
        Constructor<?> constructor = aClass.getConstructor();
        Object obj = constructor.newInstance();
        Method method = aClass.getMethod(methodsName);//Study
        method.invoke(obj);

}

}

注意事项

通过构造方法对象的newInstance 创建对象
正常情况下不能私有方法创建对象 但在反射中可以需要
使用暴力反射：
public void setAccessible(boolean flag):值为true 取消访问检查
con.setAccessible(true);

  近期学习Java反射和注解，参照一些视频大致总结了一下，希望对刚学反射的同学有所帮助