详解Java反射机制

最新推荐文章于 2023-01-26 22:54:30 发布

sunon_

最新推荐文章于 2023-01-26 22:54:30 发布

阅读量180

点赞数

分类专栏： java 文章标签： Java基础

本文链接：https://blog.csdn.net/sunon_/article/details/103886223

版权

java 专栏收录该内容

41 篇文章 1 订阅

订阅专栏

下午比较清闲，就复习了下反射的相关知识点，记录下。

原文链接：zjblog

反射概念

JAVA反射机制是在运行状态中，对于任意一个实体类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意方法和属性；这种动态获取信息以及动态调用对象方法的功能称为java语言的反射机制。

反射原理

1.将Java文件保存到本地硬盘

2.编译Java文件，生成.class文件

3.使用Java虚拟机（JVM）将字节码文件加载到内存

4.字节码文件在内存中使用Class类表示

5.使用反射的时候，首先获取到Class类，就可以得到class文件里的所有内容，包含属性、构造方法、普通方法

6.属性通过Filed类表示

7.构造方法通过Constructor表示

8.普通方法通过Method表示

Class对象（字节码文件对象）

Class类的实例表示正在运行的Java应用程序中的类和接口。

字节码文件的加载时机：

1、new一个类的时候

2、访问一个类的静态成员的时候

3、调用一个类的静态方法的时候

4、通过反射的方式创建一个类的字节码对象的时候

5、创建一个子类对象的时候

6、java命令执行一个字节码文件的时候

字节码对象的组成：构造方法——Constructor对象

成员方法——Method对象

成员变量——Filed对象

获得类或者对象的字节码文件对象的三种方式

1、Object类的getClass()方法

2、类属性，类.class

3、Class类的静态方法forName(String className),className需要全名称，不然会报错Exception in thread " main" java .lang. Clas sNotFoundException: Personal

（要想解剖一个类,必须先要获取到该类的字节码文件对象（class）。而解剖使用的就是Class类中的方法.所以先要获取到每一个字节码文件对应的Class类型的对象.）

Student.java

package test1;

public class Student {

    private Student() {}
}

class testA {

}

Personal.java

package test1;

public class Personal {

    private String name;
    private int age = 1;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public Personal(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }

    public Personal() {
        super();
    }

    public void eat() {
        System.out.println("eat 1");
    }

    public void eat(String name) {
        System.out.println("eat" + name);
    }

    public String eat(int a) {
        return "eat return";
    }
}

Demo.java

public class Demo {

    public static void main(String[] args) throws ClassNotFoundException {
        //获取Student的字节码文件对象
        Student s = new Student();
        //Object类的getClass()方法
        Class clazz = s.getClass();
        System.out.println(clazz);
        
        testA a = new testA();
        //类的class属性方法
        System.out.println(testA.class);
        //同一个类的对象或者同一个类得到的字节码对象是同一个
        System.out.println(testA.class == a.getClass()); //true
        //Class的forName方法
        Class clazz1 = Class.forName("test1.Personal");
        System.out.println(clazz1);
    }

}

Constructor对象

1、获得Constructor对象的方法

① getConstructor(Class<?>...parameterTypes) 得到公共(public)的指定的构造方法

② getConstructors() 得到公共(public)的构造方法对象

③ getDeclaredConstructor(Class<?>... parameterTypes) 得到指定的构造方法

④ getDeclaredConstructors() 得到所有的构造方法

2、通过Constructor对象创建实例

newInstance(Object...initargs) //得到对象

package test1;

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

public class Demo {

    public static void main(String[] args) throws Exception {        
        //获得构造方法对象
         
         //获得字节码文件对象
        Class clazzPerson = Personal.class;
        //获得所有公告的(public)构造方法对象
        Constructor[] constructors = clazzPerson.getConstructors();
        //遍历输出所有
        for (Constructor con : constructors) {
            System.out.println(con);
        }
        
        //用反射的方式创建Personal类对象
        Object obj = Personal.class.getConstructor().newInstance();
        System.out.println(obj);
        
        Class clazz = Student.class;
        // 获取构造方法对象
        Constructor declaredConstructor = clazz.getDeclaredConstructor();
        // 暴力访问(Student构造方法为private)
        declaredConstructor.setAccessible(true);
        // 用反射的方式创建该类对象
        Object objt = declaredConstructor.newInstance();
        System.out.println(objt);
     
        /**
         * 用反射的便捷方式创建一个类对象 不直接使用构造器对象， 不直接使用构造器对象 无参、public
         */
        Object objp = Personal.class.newInstance();
        System.out.println(objp);

    }

}

Method对象

1、获得Method对象的方法

① getMethod(String name,Class<?>...parameterTypes)

② getMethods

③ getDeclaredMethod(String name,Class<?>...parameterTypes)

④ Method[] getDeclaredMethods()

2、通过Method对象使用该方法

Method.invoke(obj,aram...) //obj为得到的对象，参数为空用null

package test1;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;

public class Demo {

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

        Class clazzPs = Personal.class;
        // 获取所有方法
        Method[] declaredMethods = clazzPs.getDeclaredMethods();
        for (Method method : declaredMethods) {
            System.out.println(method);
        }
        
        // 得到特定的方法--无参的
        Method method = clazzPs.getMethod("eat", null);
        // 调用该方法
        method.invoke(clazzPs.newInstance(), null);
        
        //得到特定的方法--带参的，第二个参数为参数类型的字节码文件对象
        Method method1 = clazzPs.getDeclaredMethod("eat", String.class);
        //调用该方法并传参数"ces"
        method1.invoke(clazzPs.newInstance(), "ces");
        
        // 得到特定的方法--带参并有返回值的
        Method method2 = clazzPs.getMethod("eat", int.class);
        Object res = method2.invoke(clazzPs.newInstance(), 1);
        System.out.println(res);
    }

}

Field对象

1、获得Field对象的方法

① getField(String name)

② getFields()

③ getDeclaredField(String name)

④getDeclaredFields()

2、通过Filed对象使用该属性

Field.set(Object obj, Object value ) //给属性赋值，obj为得到的对象，value为值

package test1;

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

public class Demo {

    public static void main(String[] args)
        throws Exception {
      
      Class clazzPs = Personal.class;
        // 获取所有字段
        Field[] fields = clazzPs.getDeclaredFields();
        for (Field field : fields) {
            System.out.println(field);
        }
        //获取age字段
        Field field = clazzPs.getDeclaredField("age");
        //用反射的方式创建Personal对象
        Object ps = clazzPs.newInstance();
        //输出name的值，此处为null
        System.out.println(((Personal)ps).getName());
  
        //因为name和age都是private，需加这句
        field.setAccessible(true);
        //给Personal中的age赋值为18
        field.set(ps, 18);
        //输出，此处为18
        System.out.println(((Personal)ps).getAge());
    }

}

常见问题

反射机制的作用?

1，反编译：.class-->.java

2,通过反射机制访问java对象的属性，方法，构造方法等；

暴力反射？

获取类的私有成员。通过setAccessible(true)方法，设置成可访问。

类加载的过程？

加载：通过一个类的完全限定查找此类字节码文件，并利用字节码文件创建一个Class对象。

链接：验证字节码的安全性和完整性，准备阶段正式为静态域分配存储空间，注意此时只是分配静态成员变量的存储空间，不包含实例成员变量，如果必要的话，解析这个类创建的对其他类的所有引用。

初始化：类加载最后阶段，若该类具有超类，则对其进行初始化，执行静态初始化器和静态初始化成员变量。

反射的应用场景？

Java的反射特性一般结合注解和配置文件（如：XML）来使用，这也是大部分框架（Spring等）支持两种配置方式的原因。还有著名的junit测试框架也是利用反射方法名和参数名来进行测试的。

理解泛化的Class对象引用

由于Class的引用总是指向某个类的Class对象，利用Class对象可以创建实例，这也就说明Class对象的引用指向的是对象确切的类型。在Java SE5引入泛型后，使我们可以利用泛型来表示Class对象更具体的类型，即使在运行期间会被擦除，但编译期足以确保我们使用正确的对象类型。

附录

Class对象的方法列表

<U> Class<? extends U>	`asSubclass(Class<U> clazz)` 强制转换该 Class 对象，以表示指定的 class 对象所表示的类的一个子类。
`T`	`cast(Object obj)` 将一个对象强制转换成此 Class 对象所表示的类或接口。
`boolean`	`desiredAssertionStatus()` 如果要在调用此方法时将要初始化该类，则返回将分配给该类的断言状态。
`static Class<?>`	`forName(String className)` 返回与带有给定字符串名的类或接口相关联的 `Class` 对象。
`static Class<?>`	`forName(String name, boolean initialize, ClassLoader loader)` 使用给定的类加载器，返回与带有给定字符串名的类或接口相关联的 `Class` 对象。
<A extends Annotation>A	`getAnnotation(Class<A> annotationClass)` 如果存在该元素的指定类型的注释，则返回这些注释，否则返回 null。
`Annotation[]`	`getAnnotations()` 返回此元素上存在的所有注释。
`String`	`getCanonicalName()` 返回 Java Language Specification 中所定义的底层类的规范化名称。
`Class<?>[]`	`getClasses()` 返回一个包含某些 `Class` 对象的数组，这些对象表示属于此 `Class` 对象所表示的类的成员的所有公共类和接口。
`ClassLoader`	`getClassLoader()` 返回该类的类加载器。
`Class<?>`	`getComponentType()` 返回表示数组组件类型的 `Class`。
`Constructor<T>`	`getConstructor(Class<?>... parameterTypes)` 返回一个 `Constructor` 对象，它反映此 `Class` 对象所表示的类的指定公共构造方法。
`Constructor<?>[]`	`getConstructors()` 返回一个包含某些 `Constructor` 对象的数组，这些对象反映此 `Class` 对象所表示的类的所有公共构造方法。
`Annotation[]`	`getDeclaredAnnotations()` 返回直接存在于此元素上的所有注释。
`Class<?>[]`	`getDeclaredClasses()` 返回 `Class` 对象的一个数组，这些对象反映声明为此 `Class` 对象所表示的类的成员的所有类和接口。
`Constructor<T>`	`getDeclaredConstructor(Class<?>... parameterTypes)` 返回一个 `Constructor` 对象，该对象反映此 `Class` 对象所表示的类或接口的指定构造方法。
`Constructor<?>[]`	`getDeclaredConstructors()` 返回 `Constructor` 对象的一个数组，这些对象反映此 `Class` 对象表示的类声明的所有构造方法。
`Field`	`getDeclaredField(String name)` 返回一个 `Field` 对象，该对象反映此 `Class` 对象所表示的类或接口的指定已声明字段。
`Field[]`	`getDeclaredFields()` 返回 `Field` 对象的一个数组，这些对象反映此 `Class` 对象所表示的类或接口所声明的所有字段。
`Method`	`getDeclaredMethod(String name, Class<?>... parameterTypes)` 返回一个 `Method` 对象，该对象反映此 `Class` 对象所表示的类或接口的指定已声明方法。
`Method[]`	`getDeclaredMethods()` 返回 `Method` 对象的一个数组，这些对象反映此 `Class` 对象表示的类或接口声明的所有方法，包括公共、保护、默认（包）访问和私有方法，但不包括继承的方法。
`Class<?>`	`getDeclaringClass()` 如果此 `Class` 对象所表示的类或接口是另一个类的成员，则返回的 `Class` 对象表示该对象的声明类。
`Class<?>`	`getEnclosingClass()` 返回底层类的立即封闭类。
`Constructor<?>`	`getEnclosingConstructor()` 如果该 Class 对象表示构造方法中的一个本地或匿名类，则返回 `Constructor` 对象，它表示底层类的立即封闭构造方法。
`Method`	`getEnclosingMethod()` 如果此 Class 对象表示某一方法中的一个本地或匿名类，则返回 `Method` 对象，它表示底层类的立即封闭方法。
`T[]`	`getEnumConstants()` 如果此 Class 对象不表示枚举类型，则返回枚举类的元素或 null。
`Field`	`getField(String name)` 返回一个 `Field` 对象，它反映此 `Class` 对象所表示的类或接口的指定公共成员字段。
`Field[]`	`getFields()` 返回一个包含某些 `Field` 对象的数组，这些对象反映此 `Class` 对象所表示的类或接口的所有可访问公共字段。
`Type[]`	`getGenericInterfaces()` 返回表示某些接口的 Type，这些接口由此对象所表示的类或接口直接实现。
`Type`	`getGenericSuperclass()` 返回表示此 Class 所表示的实体（类、接口、基本类型或 void）的直接超类的 Type。
`Class<?>[]`	`getInterfaces()` 确定此对象所表示的类或接口实现的接口。
`Method`	`getMethod(String name, Class<?>... parameterTypes)` 返回一个 `Method` 对象，它反映此 `Class` 对象所表示的类或接口的指定公共成员方法。
`Method[]`	`getMethods()` 返回一个包含某些 `Method` 对象的数组，这些对象反映此 `Class` 对象所表示的类或接口（包括那些由该类或接口声明的以及从超类和超接口继承的那些的类或接口）的公共 member 方法。
`int`	`getModifiers()` 返回此类或接口以整数编码的 Java 语言修饰符。
`String`	`getName()` 以 String 的形式返回此 Class 对象所表示的实体（类、接口、数组类、基本类型或 void）名称。
`Package`	`getPackage()` 获取此类的包。
`ProtectionDomain`	`getProtectionDomain()` 返回该类的 `ProtectionDomain`。
`URL`	`getResource(String name)` 查找带有给定名称的资源。
`InputStream`	`getResourceAsStream(String name)` 查找具有给定名称的资源。
`Object[]`	`getSigners()` 获取此类的标记。
`String`	`getSimpleName()` 返回源代码中给出的底层类的简称。
`Class<? super T>`	`getSuperclass()` 返回表示此 `Class` 所表示的实体（类、接口、基本类型或 void）的超类的 `Class`。
`TypeVariable<Class<T>>[]`	`getTypeParameters()` 按声明顺序返回 TypeVariable 对象的一个数组，这些对象表示用此 GenericDeclaration 对象所表示的常规声明来声明的类型变量。
`boolean`	`isAnnotation()` 如果此 Class 对象表示一个注释类型则返回 true。
`boolean`	`isAnnotationPresent(Class<? extends Annotation> annotationClass)` 如果指定类型的注释存在于此元素上，则返回 true，否则返回 false。
`boolean`	`isAnonymousClass()` 当且仅当底层类是匿名类时返回 true。
`boolean`	`isArray()` 判定此 `Class` 对象是否表示一个数组类。
`boolean`	`isAssignableFrom(Class<?> cls)` 判定此 `Class` 对象所表示的类或接口与指定的 `Class` 参数所表示的类或接口是否相同，或是否是其超类或超接口。
`boolean`	`isEnum()` 当且仅当该类声明为源代码中的枚举时返回 true。
`boolean`	`isInstance(Object obj)` 判定指定的 `Object` 是否与此 `Class` 所表示的对象赋值兼容。
`boolean`	`isInterface()` 判定指定的 `Class` 对象是否表示一个接口类型。
`boolean`	`isLocalClass()` 当且仅当底层类是本地类时返回 true。
`boolean`	`isMemberClass()` 当且仅当底层类是成员类时返回 true。
`boolean`	`isPrimitive()` 判定指定的 `Class` 对象是否表示一个基本类型。
`boolean`	`isSynthetic()` 如果此类是复合类，则返回 true，否则 false。
`T`	`newInstance()` 创建此 Class 对象所表示的类的一个新实例。
`String`	`toString()` 将对象转换为字符串。

Field对象方法列表

`boolean`	`equals(Object obj)` 将此 `Field` 与指定对象比较。
`Object`	`get(Object obj)` 返回指定对象上此 `Field` 表示的字段的值。
<T extends Annotation>T	`getAnnotation(Class<T> annotationClass)` 如果存在该元素的指定类型的注释，则返回这些注释，否则返回 null。
`boolean`	`getBoolean(Object obj)` 获取一个静态或实例 `boolean` 字段的值。
`byte`	`getByte(Object obj)` 获取一个静态或实例 `byte` 字段的值。
`char`	`getChar(Object obj)` 获取 `char` 类型或另一个通过扩展转换可以转换为 `char` 类型的基本类型的静态或实例字段的值。
`Annotation[]`	`getDeclaredAnnotations()` 返回直接存在于此元素上的所有注释。
`Class<?>`	`getDeclaringClass()` 返回表示类或接口的 `Class` 对象，该类或接口声明由此 `Field` 对象表示的字段。
`double`	`getDouble(Object obj)` 获取 `double` 类型或另一个通过扩展转换可以转换为 `double` 类型的基本类型的静态或实例字段的值。
`float`	`getFloat(Object obj)` 获取 `float` 类型或另一个通过扩展转换可以转换为 `float` 类型的基本类型的静态或实例字段的值。
`Type`	`getGenericType()` 返回一个 Type 对象，它表示此 Field 对象所表示字段的声明类型。
`int`	`getInt(Object obj)` 获取 `int` 类型或另一个通过扩展转换可以转换为 `int` 类型的基本类型的静态或实例字段的值。
`long`	`getLong(Object obj)` 获取 `long` 类型或另一个通过扩展转换可以转换为 `long` 类型的基本类型的静态或实例字段的值。
`int`	`getModifiers()` 以整数形式返回由此 `Field` 对象表示的字段的 Java 语言修饰符。
`String`	`getName()` 返回此 `Field` 对象表示的字段的名称。
`short`	`getShort(Object obj)` 获取 `short` 类型或另一个通过扩展转换可以转换为 `short` 类型的基本类型的静态或实例字段的值。
`Class<?>`	`getType()` 返回一个 `Class` 对象，它标识了此 `Field` 对象所表示字段的声明类型。
`int`	`hashCode()` 返回该 `Field` 的哈希码。
`boolean`	`isEnumConstant()` 如果此字段表示枚举类型的元素，则返回 true；否则返回 false。
`boolean`	`isSynthetic()` 如果此字段是复合字段，则返回 true；否则返回 false。
`void`	`set(Object obj, Object value)` 将指定对象变量上此 `Field` 对象表示的字段设置为指定的新值。
`void`	`setBoolean(Object obj, boolean z)` 将字段的值设置为指定对象上的一个 `boolean` 值。
`void`	`setByte(Object obj, byte b)` 将字段的值设置为指定对象上的一个 `byte` 值。
`void`	`setChar(Object obj, char c)` 将字段的值设置为指定对象上的一个 `char` 值。
`void`	`setDouble(Object obj, double d)` 将字段的值设置为指定对象上的一个 `double` 值。
`void`	`setFloat(Object obj, float f)` 将字段的值设置为指定对象上的一个 `float` 值。
`void`	`setInt(Object obj, int i)` 将字段的值设置为指定对象上的一个 `int` 值。
`void`	`setLong(Object obj, long l)` 将字段的值设置为指定对象上的一个 `long` 值。
`void`	`setShort(Object obj, short s)` 将字段的值设置为指定对象上的一个 `short` 值。
`String`	`toGenericString()` 返回一个描述此 `Field`（包括其一般类型）的字符串。
`String`	`toString()` 返回一个描述此 `Field` 的字符串。

Method对象方法列表

`boolean`	`equals(Object obj)` 将此 `Method` 与指定对象进行比较。
<T extends Annotation>T	`getAnnotation(Class<T> annotationClass)` 如果存在该元素的指定类型的注释，则返回这些注释，否则返回 null。
`Annotation[]`	`getDeclaredAnnotations()` 返回直接存在于此元素上的所有注释。
`Class<?>`	`getDeclaringClass()` 返回表示声明由此 `Method` 对象表示的方法的类或接口的 `Class` 对象。
`Object`	`getDefaultValue()` 返回由此 Method 实例表示的注释成员的默认值。
`Class<?>[]`	`getExceptionTypes()` 返回 `Class` 对象的数组，这些对象描述了声明将此 `Method` 对象表示的底层方法抛出的异常类型。
`Type[]`	`getGenericExceptionTypes()` 返回 Type 对象数组，这些对象描述了声明由此 Method 对象抛出的异常。
`Type[]`	`getGenericParameterTypes()` 按照声明顺序返回 Type 对象的数组，这些对象描述了此 Method 对象所表示的方法的形参类型的。
`Type`	`getGenericReturnType()` 返回表示由此 Method 对象所表示方法的正式返回类型的 Type 对象。
`int`	`getModifiers()` 以整数形式返回此 `Method` 对象所表示方法的 Java 语言修饰符。
`String`	`getName()` 以 `String` 形式返回此 `Method` 对象表示的方法名称。
`Annotation[][]`	`getParameterAnnotations()` 返回表示按照声明顺序对此 Method 对象所表示方法的形参进行注释的那个数组的数组。
`Class<?>[]`	`getParameterTypes()` 按照声明顺序返回 `Class` 对象的数组，这些对象描述了此 `Method` 对象所表示的方法的形参类型。
`Class<?>`	`getReturnType()` 返回一个 `Class` 对象，该对象描述了此 `Method` 对象所表示的方法的正式返回类型。
`TypeVariable<Method>[]`	`getTypeParameters()` 返回 TypeVariable 对象的数组，这些对象描述了由 GenericDeclaration 对象表示的一般声明按声明顺序来声明的类型变量。
`int`	`hashCode()` 返回此 `Method` 的哈希码。
`Object`	`invoke(Object obj, Object... args)` 对带有指定参数的指定对象调用由此 `Method` 对象表示的底层方法。
`boolean`	`isBridge()` 如果此方法是 bridge 方法，则返回 true；否则，返回 false。
`boolean`	`isSynthetic()` 如果此方法为复合方法，则返回 true；否则，返回 false。
`boolean`	`isVarArgs()` 如果将此方法声明为带有可变数量的参数，则返回 true；否则，返回 false。
`String`	`toGenericString()` 返回描述此 `Method` 的字符串，包括类型参数。
`String`	`toString()` 返回描述此 `Method` 的字符串。