关于java:Java反射机制跟着代码学反射

微信搜寻：码农 StayUp
主页地址：https://gozhuyinglong.github.io
源码分享：https://github.com/gozhuyinglong/blog-demos

在 OOP 的世界里，万物皆对象。也就是说，咱们能够将任何货色形象成一个对象。

比方人，能够形象成一个 Person 类，通过 new Person()来实例化一个对象；再比方鸭子，能够形象成一个 Duck 类，也能够对其进行实例化……那么这一个个类自身是不是也能够形象成一个类呢？Java 提供了一个非凡的类Class，用来形容类的外部信息，是反射的外围类。

下图是本篇讲述内容：

Java 反射（Reflection）容许应用程序在 运行时 借助于反射 API，来获取所有类或接口的外部信息，并且能间接操作任意对象的外部属性及办法。反射机制的外围类为java.lang.Class。

类加载完后，会在堆内存的办法区中产生一个 Class 类型的对象。
Class类没有公开的构造函数，是由类加载器的 defineClass 办法结构而成。所以 Class 对象不是“new”进去的，而是通过办法来获取的。
这个 Class 对象具备类的残缺构造信息，并且一个类只有一个 Class 对象。

获取 Class 对象有以下四种形式：

通过类对象获取；
通过类间接调用 class 获取；
通过 Class.forName 获取；
通过类加载器获取。

上面应用代码展现获取 Person 类的 Class 对象的四种形式：

@Test
public void testClassFor() {

    // 1. 通过类实例获取
    Person person = new Person();
    Class<? extends Person> clazz1 = person.getClass();
    System.out.println("01 -" + clazz1);

    // 2. 通过类间接调用 class 获取
    Class<Person> clazz2 = Person.class;
    System.out.println("02 -" + clazz2);

    // 3. 通过 Class.forName 获取
    Class<?> clazz3 = null;
    try {clazz3 = Class.forName("io.github.gozhuyinglong.reflection.Person");
    } catch (ClassNotFoundException e) {
        // 当找不到指定类时，会抛出此异样
        e.printStackTrace();}
    System.out.println("03 -" + clazz3);

    // 4. 通过类加载器获取
    ClassLoader classLoader = this.getClass().getClassLoader();
    Class<?> clazz4 = null;
    try {clazz4 = classLoader.loadClass("io.github.gozhuyinglong.reflection.Person");
    } catch (ClassNotFoundException e) {
        // 当找不到指定类时，会抛出此异样
        e.printStackTrace();}
    System.out.println("04 -" + clazz4);

    // hashCode 相等，阐明这四种形式获取的是同一个实例
    System.out.println("05 -" + clazz1.hashCode());
    System.out.println("06 -" + clazz2.hashCode());
    System.out.println("07 -" + clazz3.hashCode());
    System.out.println("08 -" + clazz4.hashCode());

}

输入后果：

01 - class io.github.gozhuyinglong.reflection.Person
02 - class io.github.gozhuyinglong.reflection.Person
03 - class io.github.gozhuyinglong.reflection.Person
04 - class io.github.gozhuyinglong.reflection.Person
05 - 721748895
06 - 721748895
07 - 721748895
08 - 721748895

通过下面的输入后果能够看出，这四个 Class 对象的 hashCode 雷同，阐明应用这四种形式获取的是同一个对象。

在源码正文中提到一些非凡的类和接口：

枚举是一品种。
注解是一种接口。
数组也属于一个反映为 Class 对象的类。具备雷同元素类型和维数的数组，也具备雷同的 Class 对象（也就是说，元素类型不同，或数组维数不同，其 Class 对象也不同）。
原始 Java 类型（boolean, byte, char, short, int, long, float,double）和关键字 void 也示意为 Class 对象。

上面通过代码来验证：

@Test
public void testClassOther() {

    // 枚举是一品种
    Class<PersonEnum> clazz1 = PersonEnum.class;
    System.out.println("01 -" + clazz1);

    // 注解是一种接口
    Class<PersonAnnotation> clazz2 = PersonAnnotation.class;
    System.out.println("02 -" + clazz2);

    // 数组也属于一个反馈 Class 实例的类
    Person[] personArray3 = new Person[1];
    Class<? extends Person[]> clazz3 = personArray3.getClass();
    System.out.println("03 -" + clazz3);

    // 具备雷同元素类型和维数的数组，也具备雷同的 Class 实例
    Person[] personArray4 = new Person[4];
    Class<?> clazz4 = personArray4.getClass();

    Person[][] personArray5 = new Person[1][];
    Class<?> clazz5 = personArray5.getClass();

    // 两个一维数组的 hashCode 相等，阐明是同一实例
    System.out.println("04 -" + clazz3.hashCode());
    System.out.println("05 -" + clazz4.hashCode());
    // 一维数组与二维数组的 hashCode 不相等，阐明不是同一实例
    System.out.println("06 -" + clazz5.hashCode());

    // 原始 Java 类型和关键字 void 也示意为 Class 实例
    Class<Integer> clazz6 = int.class;
    System.out.println("07 -" + clazz6);

    Class<Double> clazz7 = double.class;
    System.out.println("08 -" + clazz7);

    Class<Void> clazz8 = void.class;
    System.out.println("09 -" + clazz8);

}

输入后果：

01 - class io.github.gozhuyinglong.reflection.PersonEnum
02 - interface io.github.gozhuyinglong.reflection.PersonAnnotation
03 - class [Lio.github.gozhuyinglong.reflection.Person;
04 - 721748895
05 - 721748895
06 - 1642534850
07 - int
08 - double
09 - void

通过输入后果能够看出，确如源码中形容那样。

Java 提供了一套反射 API，该 API 由 Class 类与 java.lang.reflect 类库组成。该类库蕴含了 Field、Method、Constructor 等类。这些类型的对象是由 JVM 在运行时创立的，用以示意未知类里对应的成员。

反射容许以编程的形式拜访已加载类的字段、办法和构造函数信息，并在平安限度内利用反射对其进行操作。

上面将介绍一些罕用的类：

java.lang.Class类用来形容类的外部信息，Class的实例能够获取类的包、注解、修饰符、名称、超类、接口等。

@Test
public void testClass() throws Exception {Class<?> clazz = Class.forName("io.github.gozhuyinglong.reflection.Person");

    // 获取该类所在包门路
    Package aPackage = clazz.getPackage();
    System.out.println("01 -" + aPackage);

    // 获取该类上所有注解
    Annotation[] declaredAnnotations = clazz.getDeclaredAnnotations();
    for (Annotation temp : declaredAnnotations) {System.out.println("02 -" + temp);
    }

    // 获取类上的修饰符
    int modifiers = clazz.getModifiers();
    String modifier = Modifier.toString(modifiers);
    System.out.println("03 -" + modifier);

    // 获取类名称
    String name = clazz.getName();
    System.out.println("04 -" + name);
    // 获取简略类名
    String simpleName = clazz.getSimpleName();
    System.out.println("05 -" + simpleName);

    // 获取直属超类
    Type genericSuperclass = clazz.getGenericSuperclass();
    System.out.println("06 -" + genericSuperclass);

    // 获取直属实现的接口
    Type[] genericInterfaces = clazz.getGenericInterfaces();
    for (Type temp : genericInterfaces) {System.out.println("07 -" + temp);
    }

}

输入后果：

01 - package io.github.gozhuyinglong.reflection
02 - @io.github.gozhuyinglong.reflection.PersonAnnotation()
03 - public final
04 - io.github.gozhuyinglong.reflection.Person
05 - Person
06 - class io.github.gozhuyinglong.reflection.PersonParent
07 - interface io.github.gozhuyinglong.reflection.PersonInterface

java.lang.reflect.Constructor提供了类的构造函数信息。能够获取构造函数上的注解信息、参数类型等。

@Test
public void testConstructor() throws Exception {Class<?> clazz = Class.forName("io.github.gozhuyinglong.reflection.Person");

    // 获取一个申明为 public 构造函数实例
    Constructor<?> constructor1 = clazz.getConstructor(String.class, int.class, PersonEnum.class);
    System.out.println("01 -" + constructor1);

    // 获取所有申明为 public 构造函数实例
    Constructor<?>[] constructorArray1 = clazz.getConstructors();
    for (Constructor<?> constructor : constructorArray1) {System.out.println("02 -" + constructor);
    }

    // 获取一个申明的构造函数实例
    Constructor<?> constructor2 = clazz.getDeclaredConstructor(String.class);
    System.out.println("03 -" + constructor2);

    // 获取所有申明的构造函数实例
    Constructor<?>[] constructorArray2 = clazz.getDeclaredConstructors();
    for (Constructor<?> constructor : constructorArray2) {System.out.println("04 -" + constructor);
    }

    // 依据构造函数创立一个实例
    Object o1 = constructor1.newInstance("杨过", 25, PersonEnum.MAN);
    System.out.println("05 -" + o1);

    // 将构造函数的可拜访标记设为 true 后，能够通过公有构造函数创立实例
    constructor2.setAccessible(true);
    Object o2 = constructor2.newInstance("小龙女");
    System.out.println("06 -" + o2);

    // 获取该构造函数上的所有注解
    Annotation[] annotations = constructor1.getDeclaredAnnotations();
    for (Annotation annotation : annotations) {System.out.println("07 -" + annotation);
    }

    // 获取该构造函数上的所有参数类型
    Type[] genericParameterTypes = constructor1.getGenericParameterTypes();
    for (Type genericParameterType : genericParameterTypes) {System.out.println("08 -" + genericParameterType);
    }

}

输入后果：

01 - public io.github.gozhuyinglong.reflection.Person(java.lang.String,int,io.github.gozhuyinglong.reflection.PersonEnum)
02 - public io.github.gozhuyinglong.reflection.Person(java.lang.String,int,io.github.gozhuyinglong.reflection.PersonEnum)
02 - public io.github.gozhuyinglong.reflection.Person(java.lang.String,int)
02 - public io.github.gozhuyinglong.reflection.Person()
03 - private io.github.gozhuyinglong.reflection.Person(java.lang.String)
04 - public io.github.gozhuyinglong.reflection.Person(java.lang.String,int,io.github.gozhuyinglong.reflection.PersonEnum)
04 - public io.github.gozhuyinglong.reflection.Person(java.lang.String,int)
04 - private io.github.gozhuyinglong.reflection.Person(java.lang.String)
04 - public io.github.gozhuyinglong.reflection.Person()
05 - Person{name='杨过', age=25, sex='MAN'}
06 - Person{name='小龙女', age=0, sex='null'}
07 - @io.github.gozhuyinglong.reflection.PersonAnnotation()
08 - class java.lang.String
08 - int
08 - class io.github.gozhuyinglong.reflection.PersonEnum

java.lang.reflect.Field提供了类的属性信息。能够获取属性上的注解、修饰符、属性类型、属性名等。

@Test
public void testField() throws Exception {Class<?> clazz = Class.forName("io.github.gozhuyinglong.reflection.Person");

    // 获取一个该类或父类中申明为 public 的属性
    Field field1 = clazz.getField("hobby");
    System.out.println("01 -" + field1);

    // 获取该类及父类中所有申明为 public 的属性
    Field[] fieldArray1 = clazz.getFields();
    for (Field field : fieldArray1) {System.out.println("02 -" + field);
    }

    // 获取一个该类中申明的属性
    Field field2 = clazz.getDeclaredField("name");
    System.out.println("03 -" + field2);

    // 获取该类中所有申明的属性
    Field[] fieldArray2 = clazz.getDeclaredFields();
    for (Field field : fieldArray2) {System.out.println("04 -" + field);
    }

    // 获取该属性上的所有注解
    Annotation[] declaredAnnotations = field2.getDeclaredAnnotations();
    for (Annotation declaredAnnotation : declaredAnnotations) {System.out.println("05 -" + declaredAnnotation);
    }

    // 获取修饰符
    String modifier = Modifier.toString(field2.getModifiers());
    System.out.println("06 -" + modifier);

    // 获取属性类型，返回类对象
    Class<?> type = field2.getType();
    System.out.println("07 -" + type);
    // 获取属性类型，返回 Type 对象
    Type genericType = field2.getGenericType();
    System.out.println("08 -" + genericType);

    // 获取属性名称
    String name = field2.getName();
    System.out.println("09 -" + name);

}

输入后果：

01 - public java.lang.String io.github.gozhuyinglong.reflection.PersonParent.hobby
02 - public int io.github.gozhuyinglong.reflection.Person.height
02 - public java.lang.String io.github.gozhuyinglong.reflection.PersonParent.hobby
03 - private java.lang.String io.github.gozhuyinglong.reflection.Person.name
04 - private java.lang.String io.github.gozhuyinglong.reflection.Person.name
04 - private int io.github.gozhuyinglong.reflection.Person.age
04 - public int io.github.gozhuyinglong.reflection.Person.height
05 - @io.github.gozhuyinglong.reflection.PersonAnnotation()
06 - private
07 - class java.lang.String
08 - class java.lang.String
09 - name

java.lang.reflect.Method提供了类的办法信息。能够获取办法上的注解、修饰符、返回值类型、办法名称、所有参数。

@Test
public void testMethod() throws Exception {Class<?> clazz = Class.forName("io.github.gozhuyinglong.reflection.Person");

    // 获取一个该类及父类中申明为 public 的办法，须要指定办法的入参类型
    Method method = clazz.getMethod("setName", String.class);
    System.out.println("01 -" + method);

    // 获取该类及父类中所有申明为 public 的办法
    Method[] methods = clazz.getMethods();
    for (Method temp : methods) {System.out.println("02 -" + temp);
    }

    // 获取一个在该类中申明的办法
    Method declaredMethod = clazz.getDeclaredMethod("display");
    System.out.println("03 -" + declaredMethod);

    // 获取所有在该类中申明的办法
    Method[] declaredMethods = clazz.getDeclaredMethods();
    for (Method temp : declaredMethods) {System.out.println("04 -" + temp);
    }

    // 获取该办法上的所有注解
    Annotation[] declaredAnnotations = method.getDeclaredAnnotations();
    for (Annotation temp : declaredAnnotations) {System.out.println("05 -" + temp);
    }

    // 获取修饰符
    String modifier = Modifier.toString(method.getModifiers());
    System.out.println("06 -" + modifier);

    // 获取返回值类型，返回类对象
    Class<?> returnType = method.getReturnType();
    System.out.println("07 -" + returnType);
    // 获取返回值类型，返回 Type 对象
    Type genericReturnType = method.getGenericReturnType();
    System.out.println("08 -" + genericReturnType);

    // 获取办法名称
    String name = method.getName();
    System.out.println("09 -" + name);

    // 获取所有入参
    Parameter[] parameters = method.getParameters();
    for (Parameter temp : parameters) {System.out.println("10 -" + temp);
    }

}

输入后果：

01 - public void io.github.gozhuyinglong.reflection.Person.setName(java.lang.String)
02 - public java.lang.String io.github.gozhuyinglong.reflection.Person.toString()
02 - public java.lang.String io.github.gozhuyinglong.reflection.Person.getName()
02 - public void io.github.gozhuyinglong.reflection.Person.setName(java.lang.String)
02 - public int io.github.gozhuyinglong.reflection.Person.getAge()
02 - public void io.github.gozhuyinglong.reflection.Person.setAge(int)
02 - public java.lang.String io.github.gozhuyinglong.reflection.Person.sayHello()
02 - public io.github.gozhuyinglong.reflection.PersonEnum io.github.gozhuyinglong.reflection.PersonParent.getSex()
02 - public void io.github.gozhuyinglong.reflection.PersonParent.setSex(io.github.gozhuyinglong.reflection.PersonEnum)
02 - public final void java.lang.Object.wait() throws java.lang.InterruptedException
02 - public final void java.lang.Object.wait(long,int) throws java.lang.InterruptedException
02 - public final native void java.lang.Object.wait(long) throws java.lang.InterruptedException
02 - public boolean java.lang.Object.equals(java.lang.Object)
02 - public native int java.lang.Object.hashCode()
02 - public final native java.lang.Class java.lang.Object.getClass()
02 - public final native void java.lang.Object.notify()
02 - public final native void java.lang.Object.notifyAll()
03 - private java.lang.String io.github.gozhuyinglong.reflection.Person.display()
04 - public java.lang.String io.github.gozhuyinglong.reflection.Person.toString()
04 - public java.lang.String io.github.gozhuyinglong.reflection.Person.getName()
04 - public void io.github.gozhuyinglong.reflection.Person.setName(java.lang.String)
04 - private java.lang.String io.github.gozhuyinglong.reflection.Person.display()
04 - public int io.github.gozhuyinglong.reflection.Person.getAge()
04 - public void io.github.gozhuyinglong.reflection.Person.setAge(int)
04 - public java.lang.String io.github.gozhuyinglong.reflection.Person.sayHello()
05 - @io.github.gozhuyinglong.reflection.PersonAnnotation()
06 - public
07 - void
08 - void
09 - setName
10 - java.lang.String arg0

java.lang.reflect.Modifier提供了拜访修饰符信息。通过 Class、Field、Method、Constructor 等对象都能够获取修饰符，这个拜访修饰符是一个整数，能够通过 Modifier.toString 办法来查看修饰符形容。并且该类提供了一些静态方法和常量来解码拜访修饰符。

@Test
public void testModifier() throws Exception {Class<?> clazz = Class.forName("io.github.gozhuyinglong.reflection.Person");

    // 获取类的修饰符值
    int modifiers1 = clazz.getModifiers();
    System.out.println("01 -" + modifiers1);

    // 获取属性的修饰符值
    int modifiers2 = clazz.getDeclaredField("name").getModifiers();
    System.out.println("02 -" + modifiers2);

    // 获取构造函数的修饰符值
    int modifiers3 = clazz.getDeclaredConstructor(String.class).getModifiers();
    System.out.println("03 -" + modifiers3);

    // 获取办法的修饰符值
    int modifiers4 = clazz.getDeclaredMethod("display").getModifiers();
    System.out.println("04 -" + modifiers4);

    // 判断修饰符值是否 final 类型
    boolean isFinal = Modifier.isFinal(modifiers1);
    System.out.println("05 -" + isFinal);

    // 判断修饰符值是否 public 类型
    boolean isPublic = Modifier.isPublic(modifiers2);
    System.out.println("06 -" + isPublic);

    // 依据修饰符值，获取修饰符标记的字符串
    String modifier = Modifier.toString(modifiers1);
    System.out.println("07 -" + modifier);
    System.out.println("08 -" + Modifier.toString(modifiers2));

}

输入后果：

01 - 17
02 - 2
03 - 2
04 - 2
05 - true
06 - false
07 - public final
08 - private

java.lang.reflect.Parameter提供了办法的参数信息。能够获取办法上的注解、参数名称、参数类型等。

@Test
public void testParameter() throws Exception {Class<?> clazz = Class.forName("io.github.gozhuyinglong.reflection.Person");

    // 获取构造函数的参数
    Constructor<?> constructor = clazz.getConstructor(String.class, int.class, PersonEnum.class);
    Parameter[] parameterArray1 = constructor.getParameters();
    for (Parameter temp : parameterArray1) {System.out.println("01 -" + temp);
    }

    // 获取办法的参数
    Method method = clazz.getMethod("setName", String.class);
    Parameter[] parameterArray2 = method.getParameters();
    for (Parameter temp : parameterArray2) {System.out.println("02 -" + temp);
    }

    Parameter parameter = parameterArray1[0];
    // 获取参数上的注解
    Annotation[] annotationArray = parameter.getAnnotations();
    for (Annotation temp : annotationArray) {System.out.println("02 -" + temp);
    }

    // 获取参数名称
    String name = parameter.getName();
    System.out.println("03 -" + name);

    // 获取参数类型
    Type parameterizedType = parameter.getParameterizedType();
    System.out.println("04 -" + parameterizedType);
    Class<?> type = parameter.getType();
    System.out.println("05 -" + type);

}

输入后果：

01 - java.lang.String arg0
01 - int arg1
01 - io.github.gozhuyinglong.reflection.PersonEnum arg2
02 - java.lang.String arg0
02 - @io.github.gozhuyinglong.reflection.PersonAnnotation()
03 - arg0
04 - class java.lang.String
05 - class java.lang.String

java.lang.reflect.AccessibleObject类是 Field、Method 和Constructor类的超类。

该类提供了对类、办法、构造函数的访问控制查看的能力（如：公有办法只容许以后类拜访）。

该 拜访查看 在设置 / 获取属性、调用办法、创立 / 初始化类的实例时执行。

能够通过 setAccessible 办法将可拜访标记设为 true（默认为false），会敞开 拜访查看。这样即便是公有的属性、办法或构造函数，也能够拜访。

能够利用反射来创建对象，并可执行办法，上面看代码示例：

通过 Class 类的 newInstance 创立一个实例。（该办法调用无参结构器）。
通过构造函数 Constructor 类创立一个实例。
获取办法，再通过 invoke 办法来调用，第一个参数为实例，前面参数为办法的Parameter。
获取字段，因为 age 字段是公有的，所以将其设置为可拜访（不设置会报异样）。并通过 set 办法来赋值。

@Test
public void testInvoke() throws Exception {Class<?> clazz = Class.forName("io.github.gozhuyinglong.reflection.Person");

    // 通过 Class 类的 newInstance 创立一个实例。（该办法调用无参结构器）Object o1 = clazz.newInstance();
    System.out.println("01 -" + o1.toString());

    // 通过构造函数 Constructor 类创立一个实例
    Constructor<?> constructor = clazz.getConstructor(String.class, int.class, PersonEnum.class);
    Object o2 = constructor.newInstance("杨过", 25, PersonEnum.MAN);
    System.out.println("02 -" + o2.toString());

    // 先获取办法，再通过 invoke 办法来调用，第一个参数为实例，前面参数为办法的 Parameter
    Method method = clazz.getMethod("setName", String.class);
    method.invoke(o1, "小龙女");
    System.out.println("03 -" + o1.toString());

    // 获取字段，因为 age 字段是公有的，所以将其设置为可拜访（不设置会报异样）。并通过 set 办法来赋值
    Field field = clazz.getDeclaredField("age");
    field.setAccessible(true);
    field.set(o1, 28);
    System.out.println("04 -" + o1.toString());

}

执行后果：

01 - Person{name='null', age=0, sex='null'}
02 - Person{name='杨过', age=25, sex='MAN'}
03 - Person{name='小龙女', age=0, sex='null'}
04 - Person{name='小龙女', age=28, sex='null'}

引自官网指南：https://docs.oracle.com/javas…

反射虽是弱小的，但不可随便应用。如果能够在不应用反射的状况下执行操作，则应防止应用它。因为通过反射拜访代码时，会有以下毛病。

反射包含了一些动静类型，所以 JVM 无奈对这些代码进行优化。因而，反射操作的效率要比那些非反射操作低得多。咱们应该防止在常常被执行的代码或对性能要求很高的程序中应用反射。

应用反射技术要求程序必须在一个没有平安限度的环境中运行。如果一个程序必须在有平安限度的环境中运行，如 Applet，那么这就是个问题了。

因为反射容许代码执行一些在失常状况下不被容许的操作，比方拜访公有的属性和办法。所以应用反射可能会导致意料之外的副作用：代码有性能上的谬误，升高可移植性。反射代码毁坏了抽象性，因而当平台产生扭转的时候，代码的行为就有可能也随着变动。

残缺代码请拜访我的 Github，若对你有帮忙，欢送给个⭐，感激~~????????????

https://github.com/gozhuyingl…

Java™ Platform, Standard Edition 8 API Specification
The Java™ Tutorials

关于java:Java反射机制跟着代码学反射

1. 前言

2. Java 反射机制概述

3. 获取 Class 对象

4. 一些非凡的类和接口的 Class 对象

5. Java 反射 API

5.1 Class（类）

5.2 Constructor（构造函数）

5.3 Field（属性）

5.4 Method（办法）

5.5 Modifier（修饰符）

5.6 Parameter（参数）

5.7 AccessibleObject（可拜访标记）

6. 通过反射动静创建对象并执行办法

7. 反射的毛病

7.1 性能开销

7.2 平安限度

7.3 外部裸露

8. 残缺代码

9. 参考资料

Just My Socks（注册教程内含优惠码）

关于java:Java反射机制跟着代码学反射

1. 前言

2. Java 反射机制概述

3. 获取 Class 对象

4. 一些非凡的类和接口的 Class 对象

5. Java 反射 API

5.1 Class（类）

5.2 Constructor（构造函数）

5.3 Field（属性）

5.4 Method（办法）

5.5 Modifier（修饰符）

5.6 Parameter（参数）

5.7 AccessibleObject（可拜访标记）

6. 通过反射动静创建对象并执行办法

7. 反射的毛病

7.1 性能开销

7.2 平安限度

7.3 外部裸露

8. 残缺代码

9. 参考资料

Just My Socks（注册教程 内含优惠码）

Just My Socks（注册教程内含优惠码）