Java反射机制

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

 原文链接：zjblog

反射概念

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

反射原理

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

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

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

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

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

6.属性通过Filed类表示

7.构造方法通过Constructor表示

8.普通方法通过Method表示

157838627758257034365.png

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 {

}
View Code

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";
    }
}
View Code

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);
    }

}
View Code

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);

    }

}
View Code

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);
    }

}
View Code

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 的字符串。

 

一个java小菜鸡的进阶之路，我的个人博客:http://www.zjhuiwan.cn 欢迎访问！
【推广】 免费学中医，健康全家人
原文地址：https://www.cnblogs.com/sunonzj/p/12165176.html