Java反射详解

作者: 一只好奇的茂 | 来源:发表于2017-06-15 16:18 被阅读72次

Java 反射机制
Java基础之反射
反射
Android 编译时注解 —— 语法详解
详解Java反射机制(Reflection)
Android相关面试题
java反射详解
Java反射详解
Java反射详解
Java反射详解

反射（Reflection）能够让运行于 JVM 中的程序检测和修改运行时的行为。

Class类提供了以下方法

四个public方法，用于获取某个类的构造方法：

Constructor getConstructor(Class[] params)     
// 根据构造函数的参数，返回一个具体的具有public属性的构造函数
Constructor getConstructors()     
// 返回所有具有public属性的构造函数数组
Constructor getDeclaredConstructor(Class[] params)     
// 根据构造函数的参数，返回一个具体的构造函数（不分public和非public属性）
Constructor getDeclaredConstructors()    
// 返回该类中所有的构造函数数组（不分public和非public属性）

四种获取成员方法的方法

Method getMethod(String name, Class[] params)    
// 根据方法名和参数，返回一个具体的具有public属性的方法
Method[] getMethods()    
// 返回所有具有public属性的方法数组
Method getDeclaredMethod(String name, Class[] params)    
// 根据方法名和参数，返回一个具体的方法（不分public和非public属性）
Method[] getDeclaredMethods()    
// 返回该类中的所有的方法数组（不分public和非public属性）

四种获取成员属性的方法

Field getField(String name)    
// 根据变量名，返回一个具体的具有public属性的成员变量
Field[] getFields()    
// 返回具有public属性的成员变量的数组
Field getDeclaredField(String name)    
// 根据变量名，返回一个成员变量（不分public和非public属性）
Field[] getDelcaredFields()    
// 返回所有成员变量组成的数组（不分public和非public属性）

getDeclaredFields 和 getFields 的区别:
getDeclaredFields()获得某个类的所有申明的字段，即包括public、private和proteced，但是不包括父类的申明字段。
getFields()获得某个类的所有的公共（public）的字段，包括父类。

获取父类的方法

Class<?> superclass = class1.getSuperclass() ;

获取接口

Class<?>[] interS = class1.getInterfaces() ;
// 获取所有的接口

实例化

 Object object = class1.newInstance() ;
 //创建实例化：相当于 new 了一个对象

实例

Person.class

package reflection;
public class Person {
    private String id;
    private String name;
    public String age;
    public static String str = "Json";
    //构造函数1
    public Person() {
        System.out.println( "构造函数  无参" );
    }
    //构造函数2
    public Person(String id) {
        this.id = id;
        System.out.println( "构造函数 id : " + id );
    }
    //构造函数3
    public Person(String id, String name) {
        this.id = id;
        this.name = name;
        System.out.println( "构造函数 id : " + id  + " name: " + name );
    }
    public String getId() {
        return id;
    }
    public void setId(String id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getAge() {
        return age;
    }
    public void setAge(String age) {
        this.age = age;
    }
    /**
     * 静态方法
     */
    public static String update(int id) {
        return str+id;
    }
}

练习一：通过反射，获取对象实例，并且操作对象的方法

package reflection;
public class T1 {
    public static void main(String[] args) {
        try {
            //创建类
            Class<?> class1 = Class.forName("reflection.Person");
            //创建实例化：相当于 new 了一个对象
            Object object = class1.newInstance();
            //向下转型
            Person person = (Person) object;
            person.setId("100");
            person.setName("jack");
            System.out.println("id: " + person.getId() + " name: " + person.getName());
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
    }
}

运行结果：

id: 100 name: jack

练习二：通过反射获取对象字段属性，并且赋值

package reflection;
import java.lang.reflect.Field;
public class T1 {
    public static void main(String[] args) {
        try {
            //创建类
            Class<?> class1 = Class.forName("reflection.Person");
            //创建实例
            Object person = class1.newInstance();
            //获得id 属性
            Field idField = class1.getDeclaredField( "id" ) ;
//打破封装  实际上setAccessible是启用和禁用访问安全检查的开关,并不是为true就能访问为false就不能访问
//由于JDK的安全检查耗时较多.所以通过setAccessible(true)的方式关闭安全检查就可以达到提升反射速度的目的
            idField.setAccessible( true );
            //给id 属性赋值
            idField.set(person, "100") ;
            //打印 person 的属性值
            System.out.println( idField.get( person ));
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (NoSuchFieldException e) {
            e.printStackTrace();
        } catch (SecurityException e) {
            e.printStackTrace() ;
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

id 这个属性的是 private 私有的，不能修改它的值。需要添加 idField.setAccessible( true );

练习三：通过反射操作属性和方法

package reflection;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
public class T1 {
    public static void main(String[] args) {
        try {
            //创建类
            Class<?> class1 = Class.forName("reflection.Person");
            //创建实例
            Object person = class1.newInstance();
            //获得id 属性
            Field idField = class1.getDeclaredField( "id" ) ;
            //打破封装  实际上setAccessible是启用和禁用访问安全检查的开关,并不是为true就能访问为false就不能访问
            //由于JDK的安全检查耗时较多.所以通过setAccessible(true)的方式关闭安全检查就可以达到提升反射速度的目的
            idField.setAccessible( true );
            //给id 属性赋值
            idField.set(  person , "100") ;
            //获取 setName() 方法
            Method setName = class1.getDeclaredMethod( "setName", String.class ) ;
            //打破封装
            setName.setAccessible( true );
            //调用setName 方法。
            setName.invoke( person , "jack" ) ;
            //获取name 字段
            Field nameField = class1.getDeclaredField( "name" ) ;
            //打破封装
            nameField.setAccessible( true );
            //打印 person 的 id 属性值
            String id_ = (String) idField.get( person ) ;
            System.out.println( "id: " + id_ );
            //打印 person 的 name 属性值
            String name_ = ( String)nameField.get( person ) ;
            System.out.println( "name: " + name_ );
            //获取 getName 方法
            Method getName = class1.getDeclaredMethod( "getName" ) ;
            //打破封装
            getName.setAccessible( true );
            //执行getName方法，并且接收返回值
            String name_2 = (String) getName.invoke( person  ) ;
            System.out.println( "name2: " + name_2 );
        } catch (IllegalArgumentException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (NoSuchFieldException e) {
            e.printStackTrace();
        } catch (SecurityException e) {
            e.printStackTrace() ;
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

运行结果：

id: 100
name: jack
name2: jack

练习四：静态属性、静态方法调用

package reflection;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
public class T1 {
    public static void main(String[] args) {
        try {
            //创建类
            Class<?> class1 = Class.forName("reflection.Person");
            //获取 nameField 属性
            Field nameField = class1.getDeclaredField( "str" ) ;
            //获取 nameField 的值
            String name_ = (String) nameField.get( nameField ) ;
            //输出值
            System.out.println( name_ );
            //有返回值，有参数
            Method getUpdateMethod = class1.getDeclaredMethod( "update" , int.class ) ;
            String result_4 = (String) getUpdateMethod.invoke( null  , 1 ) ;
            System.out.println( "返回值： "+ result_4 );
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        } catch (IllegalArgumentException e) {
            e.printStackTrace();
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (NoSuchFieldException e) {
            e.printStackTrace();
        } catch (SecurityException e) {
            e.printStackTrace() ;
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

练习五：调用构造函数，创建对象实例

package reflection;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
public class T1 {
    public static void main(String[] args) {
        try {
            //创建类
            Class<?> class1 = Class.forName("reflection.Person");
            //无参构造函数
            Object object = class1.newInstance() ;
            //有参构造函数：一个参数
            Constructor<?> constructor =  class1.getDeclaredConstructor( String.class ) ;
            constructor.newInstance( "1000" ) ;
            //有参构造函数：二个参数
            Constructor<?> constructor2 =  class1.getDeclaredConstructor( String.class , String.class ) ;
            constructor2.newInstance( "1001" , "jack" ) ;
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        } catch (IllegalArgumentException e) {
            e.printStackTrace();
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        } catch (SecurityException e) {
            e.printStackTrace() ;
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

参考文章

Java 反射使用总结

Java 反射机制
[1]. java反射详解[2]. Java Reflection(反射机制)详解[3]. 深入理解Java类型...
Java基础之反射
Java基础之—反射（非常重要）Java中反射机制详解Java进阶之reflection(反射机制)——反射概念与...
反射
优秀文章博客：Rittel_Liu > Java反射的作用博客园：Rollen Holt > Java反射详解 ...
Android 编译时注解 —— 语法详解
java Type 详解 java 反射机制详解注解使用入门（一） Android 自定义编译时注解1 - 简单...
详解Java反射机制(Reflection)
详解Java反射机制(Reflection) 反射机制的作用 JAVA反射机制是在运行状态中，对于任意一个类，都能...
Android相关面试题
面试过程中遇到的题集，都会摘要记录下来一，Java部分 1.什么是反射？ Java反射机制基础详解 2.反射的实...
java反射详解
1、什么是反射？ JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个...
Java反射详解
一、简介 Java在编译时候就必须知道所引用的类所在地方，但是在实际编程中，在某些场合，可能需要引用一个并不在编译...
Java反射详解
一、什么是反射？ “反射（Reflection）能够让运行于JVM中的程序检测和修改运行时的行为。反射用于在运行时...
Java反射详解
反射（Reflection）能够让运行于 JVM 中的程序检测和修改运行时的行为。 Class类提供了以下方法四...