JavaSE-反射

全干丶

已于 2022-05-26 17:45:54 修改

阅读量224

点赞数

文章标签： java

于 2022-05-26 17:44:17 首次发布

本文链接：https://blog.csdn.net/errrl/article/details/124989171

版权

JavaSE-反射

类加载
反射的意义、原理、作用
反射信息（字节码信息）
类的动态加载
类加载器Classloader
使用反射信息
关于反射的面试题

什么是反射？

反射就是Reflection，Java的反射是指程序在运行期可以拿到一个类的所有信息。

类加载

除了int等基本类型外，Java的其他类型全部都是class（包括interface）。例如：

String
Object
Runnable
Exception
…
仔细思考，我们可以得出结论：class（包括interface）的本质是数据类型（Type）。无继承关系的数据类型无法赋值：

Number n = new Double(123.456); // OK
String s = new Double(123.456); // compile error!

而class是由JVM在执行过程中动态加载的。JVM在第一次读取到一种class类型时，将其加载进内存。

每加载一种class，JVM就为其创建一个Class类型的实例，并关联起来。注意：这里的Class类型是一个名叫Class的class。它长这样：

public final class Class {
    private Class() {}
}

以String类为例，当JVM加载String类时，它首先读取String.class文件到内存，然后，为String类创建一个Class实例并关联起来：

Class cls = new Class(String);

这个Class实例是JVM内部创建的，如果我们查看JDK源码，可以发现Class类的构造方法是private，只有JVM能创建Class实例，我们自己的Java程序是无法创建Class实例的。

所以，JVM持有的每个Class实例都指向一个数据类型（class或interface）：

┌───────────────────────────┐
│      Class Instance       		   │──────> String
├───────────────────────────┤
│name = "java.lang.String"  │
└───────────────────────────┘
┌───────────────────────────┐
│      Class Instance       		   │──────> Random
├───────────────────────────┤
│name = "java.util.Random"  │
└───────────────────────────┘
┌───────────────────────────┐
│      Class Instance       		   │──────> Runnable
├───────────────────────────┤
│name = "java.lang.Runnable"│
└───────────────────────────┘

一个Class实例包含了该class的所有完整信息：

┌───────────────────────────┐
│      Class Instance       		   │──────> String
├───────────────────────────┤
│name = "java.lang.String"  │
├───────────────────────────┤
│package = "java.lang"      │
├───────────────────────────┤
│super = "java.lang.Object" │
├───────────────────────────┤
│interface = CharSequence...│
├───────────────────────────┤
│field = value[],hash,...   │
├───────────────────────────┤
│method = indexOf()...      │
└───────────────────────────┘

反射的意义、原理、作用

由于JVM为每个加载的class创建了对应的Class实例，并在实例中保存了该class的所有信息，包括类名、构造器、包名、父类、实现的接口、所有方法、字段等，因此，如果获取了某个Class实例，我们就可以通过这个Class实例获取到该实例对应的class的所有信息。

这种通过Class实例获取class信息的方法称为反射（Reflection）。

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

实例化：引入需要的“包类”名称 --> 通过new 实例化 --> 取得实例化对象

反射：实例化对象 --> getClass() 方法 --> 得到完整的“包类”名称

作用一：动态实例化对象 Class 对象.newInstance();

实际上是调用了该类的空参构造器。所以这个类上必须存在一个空参构造器。并且类构造器的访问权限必须足够。

class Demo2 {
    private Demo2() {
        System.out.println("Demo2 无参构造器");
    }
}

public class Demo {
    public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InstantiationException, InvocationTargetException, NoSuchFieldException {
        Class<Demo2> demo2Class = Demo2.class;
//        Demo2 demo2 = demo2Class.newInstance();
//        System.out.println(demo2);
        /**
         * 输出结果:
         * Exception in thread "main" java.lang.IllegalAccessException: Class src.com.study.Demo can not access a member of class src.com.study.Demo2 with modifiers "private
         */
        Constructor<Demo2> declaredConstructor = demo2Class.getDeclaredConstructor();
//        如果不设置 declaredConstructor.setAccessible(true); 同样会包上面的错误.
        declaredConstructor.setAccessible(true);
        Demo2 demo2 = declaredConstructor.newInstance();
        System.out.println(demo2);
        /**
         * 输出结果:
         * Demo2 无参构造器
         * src.com.study.Demo2@1b6d3586
         */
    }
}

同样也可以调用有参构造器实例化对象：

class Demo2 {
    // 重载
    private Demo2(String name) {
        System.out.println(name+"有参构造器");
    }
}
public class Demo {
    public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InstantiationException, InvocationTargetException, NoSuchFieldException {
        Class<Demo2> demo2Class = Demo2.class;
        Constructor<Demo2> declaredConstructor = demo2Class.getDeclaredConstructor(String.class);
        declaredConstructor.setAccessible(true);
        Demo2 obj = declaredConstructor.newInstance("Demo2");
        System.out.println(obj);
    }
}

作用二：动态获取类对象的方法并调用。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-0AKFcZQX-1653557846366)(imgclip.png "imgclip.png")]

例如：

// PayInterface.java
package src.com.study.reflection;

public interface PayInterface {
    void pay();
}

// Wechat.java
package src.com.study.reflection;

public class Wechat implements PayInterface {
    @Override
    public void pay() {
        System.out.println("使用微信支付");
    }
}

// Ali.java
package src.com.study.reflection;

public class Ali implements PayInterface {
    @Override
    public void pay() {
        System.out.println("使用支付宝支付");
    }
}

// Card.java
package src.com.study.reflection;

public class Card implements PayInterface {
    @Override
    public void pay() {
        System.out.println("使用银行卡支付");
    }
}

// Demo.java
package src.com.study.reflection;

import java.lang.reflect.Method;

public class Demo {
    /*public static void main(String[] args) {
        String str = "Wechat";
        if (str.equals("Wechat")) {
            pay(new Wechat());
        } else if (str.equals("Ali")) {
            pay(new Ali());
        } else {
            pay(new Card());
        }
    }
    // 使用多态进行简化
    public static void pay(PayInterface payMethod) {
        payMethod.pay();
    }*/
    public static void main(String[] args) throws Exception {
        String str = "src.com.study.reflection.Wechat";
        Class cls = Class.forName(str);
        Method pay = cls.getMethod("pay");
        pay.invoke(cls.newInstance());
    }
}

输出结果：使用微信支付

同样还是需要注意权限问题。详细看【反射机制】-【反射信息的使用 Class类的使用（运行时结构）】-【权限问题（非public）】

作用三：获取类的运行时结构。请看【反射机制】-【反射信息的使用 Class类的使用（运行时结构）】

反射信息（字节码信息）

获取反射信息

方法一：直接通过一个class的静态变量class获取：

Class cls = String.class;

方法二：如果我们有一个实例变量，可以通过该实例变量提供的getClass()方法获取：

String s = "Hello";
Class cls = s.getClass();

方法三：如果知道一个class的完整类名，可以通过静态方法Class.forName()获取：

Class cls = Class.forName("java.lang.String");
// jdbc、常用

方法四：通过ClassLoader 类加载器加载

ClassLoader loader = [Class].class.getClassLoader();
Class cls = loader.loadClass("java.lang.String");

拓展

因为Class实例在JVM中是唯一的，所以，上述方法获取的Class实例是同一个实例。可以用==比较两个Class实例：

Class cls1 = String.class;

String s = "Hello";
Class cls2 = s.getClass();

boolean sameClass = cls1 == cls2; // true

注意一下Class实例比较和instanceof的差别：instanceof 是继承关系的判断，而反射是类的判断。

Integer n = new Integer(123);

boolean b1 = n instanceof Integer; // true，因为n是Integer类型
boolean b2 = n instanceof Number; // true，因为n是Number类型的子类

boolean b3 = n.getClass() == Integer.class; // true，因为n.getClass()返回Integer.class
boolean b4 = n.getClass() == Number.class; // false，因为Integer.class!=Number.class

public class Demo {
    public static void main(String[] args) throws ClassNotFoundException {
        Parent children = new Children();
        Class cl1 = children.getClass(); // 获取反射只与实例对象有关
        Class cl2 = Class.forName("src.com.study.Children");
        System.out.println(children instanceof Parent);  // true
        System.out.println(children instanceof Children);  // true
        System.out.println(cl1 == Parent.class);  // false
        System.out.println(cl2 == Children.class);  // true
    }
}

class Children extends Parent {

}

class Parent {

}

用instanceof不但匹配指定类型，还匹配指定类型的子类。而用==判断class实例可以精确地判断数据类型，但不能作子类型比较。

通常情况下，我们应该用instanceof判断数据类型，因为面向抽象编程的时候，我们不关心具体的子类型。只有在需要精确判断一个类型是不是某个class的时候，我们才使用==判断class实例。

可以作为Class 类的实例的种类有哪些？

类：自定义类、内部类、外部类、包装类…
接口：Comarable
注解：Override，…
基本数据类型：int、float、char…
数组：int[]…
void

要注意的是：

// 同一类型同一维度的数组对应的class 才相同。

int[] arr1 = {1,2,3};
int[] arr2 = {4,5,6};
char[] arr3 = {'a','b','c'};
System.out.println(arr1.class==arr2.class);  // true
System.out.println(arr1.class==arr3.class);  // false

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-tGXWlo3f-1653557879205)(imgclip.png "imgclip.png")]

类的动态加载

JVM在执行Java程序的时候，并不是一次性把所有用到的class全部加载到内存，而是第一次需要用到class时才加载。例如：

// Main.java
public class Main {
    public static void main(String[] args) {
        if (args.length > 0) {
            create(args[0]);
        }
    }

    static void create(String name) {
        Person p = new Person(name);
    }
}

当执行Main.java时，由于用到了Main，因此，JVM首先会把Main.class加载到内存。然而，并不会加载Person.class，除非程序执行到create()方法，JVM发现需要加载Person类时，才会首次加载Person.class。如果没有执行create()方法，那么Person.class根本就不会被加载。

一个类在内存中只有一个Class 对象，被加载后，类的整个结构都会被封装在Class 对象中。

这就是JVM动态加载class的特性。

类的加载

加载：将class 文件字节码内容加载到内存中，并将这些静态数据转换成方法区的运行时数据结构，然后生成一个代表这个类的java.lang.Class 对象。
链接：将java 类的二进制代码合并到jvm的运行状态之中的过程。

验证：确保加载的类信息符合jvm 规范，没有安全问题
准备：正式为类变量（static）分配内存空间并设置类变量默认初始值阶段，这些内存都将在方法区中进行分配
解析：虚拟机常量池内的符号引用（常量名）替换为直接引用（地址）的过程。

初始化：

执行类构造器()方法的过程。类构造器()方法是由编译器自动收集类中所有类变量的赋值动作和静态代码块中的语句合并产生的。（类构造器是构造类信息的不是构造该类对象的构造器）。
当初始化一个类的时候，如果发现其父类还没有进行初始化，则需要先触发其父类的初始化。
虚拟机会保证一个类的()方法在多线程环境下被正确地加锁和同步。所以在多线程模式下内部类是单例模式的形式之一。

类加载器Classloader

类加载器的作用

将class 文件字节码内容加载到内存中，并将这些静态数据转换成方法区的运行时数据结构，然后在堆中生成一个代表这个类的java.lang.Class对象，作为方法区中类数据的访问入口。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-niGryWKr-1653557955176)(imgclip.png "imgclip.png")]

jvm 规范定义了那些类加载器

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-2iHxfbXd-1653557955178)(imgclip_1.png "imgclip_1.png")]

获取类加载器：

public class Demo {
    public static void main(String[] args) throws ClassNotFoundException {
        ClassLoader systemClassLoader = ClassLoader.getSystemClassLoader();
        System.out.println(systemClassLoader);  // sun.misc.Launcher$AppClassLoader@18b4aac2
        ClassLoader parent = systemClassLoader.getParent();
        System.out.println(parent); // sun.misc.Launcher$ExtClassLoader@1b6d3586
        ClassLoader parent1 = parent.getParent();
        System.out.println(parent1);  // null 无法被访问 引导类加载器
        System.out.println("自定义类的加载器：" + Demo.class.getClassLoader());  // 自定义类的加载器：sun.misc.Launcher$AppClassLoader@18b4aac2
        Class<?> aClass = Class.forName("java.lang.Object");
        System.out.println("JDK 的加载器：" + aClass.getClassLoader());  // JDK 的加载器：null  引导类加载器无法被访问
        String property = System.getProperty("java.class.path");
        System.out.println(property);
        /*
        C:\Program Files\Java\jdk1.8.0_261\jre\lib\charsets.jar;
        C:\Program Files\Java\jdk1.8.0_261\jre\lib\deploy.jar;
        C:\Program Files\Java\jdk1.8.0_261\jre\lib\ext\access-bridge-64.jar;
        C:\Program Files\Java\jdk1.8.0_261\jre\lib\ext\cldrdata.jar;
        C:\Program Files\Java\jdk1.8.0_261\jre\lib\ext\dnsns.jar;
        C:\Program Files\Java\jdk1.8.0_261\jre\lib\ext\jaccess.jar;
        C:\Program Files\Java\jdk1.8.0_261\jre\lib\ext\jfxrt.jar;
        C:\Program Files\Java\jdk1.8.0_261\jre\lib\ext\localedata.jar;
        C:\Program Files\Java\jdk1.8.0_261\jre\lib\ext\nashorn.jar;
        C:\Program Files\Java\jdk1.8.0_261\jre\lib\ext\sunec.jar;
        C:\Program Files\Java\jdk1.8.0_261\jre\lib\ext\sunjce_provider.jar;
        C:\Program Files\Java\jdk1.8.0_261\jre\lib\ext\sunmscapi.jar;
        C:\Program Files\Java\jdk1.8.0_261\jre\lib\ext\sunpkcs11.jar;
        C:\Program Files\Java\jdk1.8.0_261\jre\lib\ext\zipfs.jar;
        C:\Program Files\Java\jdk1.8.0_261\jre\lib\javaws.jar;
        C:\Program Files\Java\jdk1.8.0_261\jre\lib\jce.jar;
        C:\Program Files\Java\jdk1.8.0_261\jre\lib\jfr.jar;
        C:\Program Files\Java\jdk1.8.0_261\jre\lib\jfxswt.jar;
        C:\Program Files\Java\jdk1.8.0_261\jre\lib\jsse.jar;
        C:\Program Files\Java\jdk1.8.0_261\jre\lib\management-agent.jar;
        C:\Program Files\Java\jdk1.8.0_261\jre\lib\plugin.jar;
        C:\Program Files\Java\jdk1.8.0_261\jre\lib\resources.jar;
        C:\Program Files\Java\jdk1.8.0_261\jre\lib\rt.jar;
        C:\Users\Jming_er\Desktop\javaStudy\out\production\javaStudy;
        F:\intellij\IntelliJ IDEA 2018.1.7\lib\idea_rt.jar
         */
    }
}

注意：SystemClassLoader 另外一个名字 AppClassLoader

使用反射信息

Class cls = [ClassName].class;
cls.XXX...方法如下：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-IRSPdfh2-1653558007976)(imgclip.png "imgclip.png")]

权限问题（非public）

setAccessible

Method 和Field、Constructor 对象都有setAccessible 方法。
setAccessible的所用是开启或关闭访问安全权限的检测。

true：使得原本无法访问和操作的私有成员也可以访问。
false：遵循java 语法访问检测。

如果访问的属性字段具有私有性（private）可以使用Declared 去访问，但是获取的结果不能被直接操作，就需要用到 setAccessible()

import java.lang.reflect.Field;

public class Test {
    public static void main(String[] args) throws Exception {
        Class stdClass = Student.class;  // 反射数据
        Field score = stdClass.getDeclaredField("score");  // 获取某个字段

        // 获取值
        Student student = new Student(10);
        Object o = score.get(student);
        System.out.println(o);
    }
}

class Student {
    private int score;

    public Student(int score) {
        this.score = score;
    }
}

发生错误：

Exception in thread "main" java.lang.IllegalAccessException: Class com.study.Test can not access a member of class com.study.Student with modifiers "private"
	at sun.reflect.Reflection.ensureMemberAccess(Reflection.java:102)
	at java.lang.reflect.AccessibleObject.slowCheckMemberAccess(AccessibleObject.java:296)
	at java.lang.reflect.AccessibleObject.checkAccess(AccessibleObject.java:288)
	at java.lang.reflect.Field.get(Field.java:390)
	at com.study.Test.main(Test.java:13)

关闭访问安全权限的检测

import java.lang.reflect.Field;
import java.lang.reflect.Modifier;

public class Test {
    public static void main(String[] args) throws Exception {
        Class stdClass = Student.class;  // 反射数据
        Field score = stdClass.getDeclaredField("score");  // 获取某个字段
        score.setAccessible(true);  // 忽略权限

        // 获取值
        Student student = new Student(10);
        score.set(stdClass.newInstance(),20);  // 设置值
        Object o = score.get(student);
        System.out.println(o);  // 20
    }
}

class Student {
    private int score;

    public Student(int score) {
        this.score = score;
    }
}

访问类属性

public class Test {
    public static void main(String[] args) throws Exception {
        Class stdClass = Student.class;
        System.out.println(stdClass);  // class com.study.Student
        /**
         * Field getField(name)：根据字段名获取某个public的field（包括父类）
         * Field getDeclaredField(name)：根据字段名获取当前类的某个field（不包括父类）
         * Field[] getFields()：获取所有public的field（包括父类）
         * Field[] getDeclaredFields()：获取当前类的所有field（不包括父类）
         */
        // 获取public字段"score":
        System.out.println(stdClass.getField("score"));  // public int com.study.Student.score
        // 获取继承的public字段"name":
        System.out.println(stdClass.getField("name"));  // public java.lang.String com.study.Person.name
        // 获取private字段"grade":
        System.out.println(stdClass.getDeclaredField("grade"));  // private int com.study.Student.grade
    }
}

class Student extends Person {
    public int score;
    private int grade;
}

class Person {
    public String name;
}

返回一个Field 对象，可以通过该对象返回某个字段的信息

import java.lang.reflect.Field;
import java.lang.reflect.Modifier;

public class Test {
    public static void main(String[] args) throws Exception {
        Class stdClass = Student.class;
        /**
         * getName()：返回字段名称，例如，"name"；
         * getType()：返回字段类型，也是一个Class实例，例如，String.class；
         * getModifiers()：返回字段的修饰符，它是一个int，不同的bit表示不同的含义。
         */
        Field score = stdClass.getField("score");
        System.out.println(score.getName());  // score
        System.out.println(score.getType());  // int
        int modifiers = score.getModifiers();
        System.out.println(Modifier.isFinal(modifiers));  // false
        System.out.println(Modifier.isPublic(modifiers));  // true
        System.out.println(Modifier.isPrivate(modifiers));  // false
        System.out.println(Modifier.isStatic(modifiers));  // false

        // 获取值通过实例化对象
        Student student = new Student();
        Object o = score.get(student);
        System.out.println(o);  // 10
    }
}

class Student {
    public int score = 10;
}

重新设置访问属性的值

import java.lang.reflect.Field;
import java.lang.reflect.Modifier;

public class Test {
    public static void main(String[] args) throws Exception {
        Class stdClass = Student.class;  // 反射数据
        Field score = stdClass.getDeclaredField("score");  // 获取某个字段

        // 获取值
        Student student = new Student(10);
        score.set(student, 20);
        Object o = score.get(student);
        System.out.println(o);  // 20
    }
}

class Student {
    public int score;

    public Student(int score) {
        this.score = score;
    }
}

访问类方法

public class Test {
    public static void main(String[] args) throws Exception {
        Class stdClass = Student.class;
        /**
         * Method getMethod(name, Class...)：获取某个public的Method（包括父类）
         * Method getDeclaredMethod(name, Class...)：获取当前类的某个Method（不包括父类）
         * Method[] getMethods()：获取所有public的Method（包括父类）
         * Method[] getDeclaredMethods()：获取当前类的所有Method（不包括父类）
         */
        // 获取public方法getScore，参数为String:
        System.out.println(stdClass.getMethod("getScore", String.class));  // public int com.study.Student.getScore(java.lang.String)
        // 获取继承的public方法getName，无参数:
        System.out.println(stdClass.getMethod("getName"));  // public java.lang.String com.study.Person.getName()
        // 获取private方法getGrade，参数为int:
        System.out.println(stdClass.getDeclaredMethod("getGrade", int.class));  // private int com.study.Student.getGrade(int)
    }
}

class Student extends Person {
    public int getScore(String type) {
        return 99;
    }
    private int getGrade(int year) {
        return 1;
    }
}

class Person {
    public String getName() {
        return "Person";
    }
}

返回一个Field 对象，可以通过该对象返回方法的信息

public class Test {
    public static void main(String[] args) throws Exception {
        Class stdClass = Student.class;
        /**
         * getName()：返回方法名称，例如："getScore"；
         * getReturnType()：返回方法返回值类型，也是一个Class实例，例如：String.class；
         * getParameterTypes()：返回方法的参数类型，是一个Class数组，例如：{String.class, int.class}；
         * getModifiers()：返回方法的修饰符，它是一个int，不同的bit表示不同的含义。
         */
        System.out.println(stdClass.getMethod("getScore", String.class).getName());  // getScore
        System.out.println(stdClass.getMethod("getName").getReturnType());  // class java.lang.String
        System.out.println(stdClass.getMethod("setName").getReturnType());  // void
        System.out.println(stdClass.getDeclaredMethod("getGrade", int.class).getParameterTypes());  // [Ljava.lang.Class;@677327b6
    }
}

class Student extends Person {
    public int getScore(String type) {
        return 99;
    }
    private int getGrade(int year) {
        return 1;
    }
}

class Person {
    public String getName() {
        return "Person";
    }
    public void setName() {
    }
}

调用public 方法

import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;

public class Test {
    public static void main(String[] args) throws Exception {
        Class stdClass = Student.class;
        Student student = new Student();
        Method m = stdClass.getMethod("getScore", int.class);
        String invoke = (String) m.invoke(student, 20);
        System.out.println(invoke);  // 201
    }
}

class Student {
    public static String getScore(int type) {
        return type + "1";
    }
}

调用静态方法

import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;

public class Test {
    public static void main(String[] args) throws Exception {
        Class stdClass = Student.class;
        Method m = stdClass.getMethod("getScore", int.class);
        String invoke = (String) m.invoke(null, 20);
        System.out.println(invoke);  // 201
    }
}

class Student {
    public static String getScore(int type) {
        return type + "1";
    }
}

调用非public 方法

import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;

public class Test {
    public static void main(String[] args) throws Exception {
        Class stdClass = Student.class;
        Student student = new Student();
        Method m = stdClass.getDeclaredMethod("getScore", int.class);
        m.setAccessible(true);
        m.invoke(student, 20);
        System.out.println(student.i);  // 20
    }
}

class Student {
    int i;

    private void getScore(int type) {
        this.i = type;
    }
}

注意多态

总是调用实际类型的覆写方法

import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;

public class Test {
    public static void main(String[] args) throws Exception {
        // 获取Person的hello方法:
        Method h = Person.class.getMethod("hello");
        // 对Student实例调用hello方法:
        h.invoke(new Student());
    }
}

class Person {
    public void hello() {
        System.out.println("Person:hello");
    }
}

class Student extends Person {
    public void hello() {
        System.out.println("Student:hello");
    }
}

实际上相当于：

Person p = new Student();
p.hello();

访问类构造器

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

public class Test {
    public static void main(String[] args) throws Exception {
        /**
         * getConstructor(Class...)：获取某个public的Constructor；
         * getDeclaredConstructor(Class...)：获取某个Constructor；
         * getConstructors()：获取所有public的Constructor；
         * getDeclaredConstructors()：获取所有Constructor。
         */
        // 参数为空可以返回空参构造器
        Constructor declaredConstructor = Person.class.getDeclaredConstructor(int.class);
        System.out.println(declaredConstructor);  // public com.study.Person(int)
    }
}

class Person {
    int i;
    public Person(int i) {
        this.i = i;
    }
}

访问非public 的构造器，并实例化对象

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

public class Test {
    public static void main(String[] args) throws Exception {
        Constructor declaredConstructor = Person.class.getDeclaredConstructor(int.class);
        declaredConstructor.setAccessible(true);
        Person o = (Person) declaredConstructor.newInstance(10);
        System.out.println(o.i);  // 10
    }
}

class Person {
    int i;

    private Person(int i) {
        this.i = i;
    }
}

访问类继承关系

public class Test {
    public static void main(String[] args) throws Exception {
        Class i = Integer.class;
        Class n = i.getSuperclass();
        System.out.println(n);  // class java.lang.Number
        Class o = n.getSuperclass();
        System.out.println(o);  // class java.lang.Object
        System.out.println(o.getSuperclass());  // null
    }
}

访问某个类实现的接口

public class Test {
    public static void main(String[] args) throws Exception {
        Class i = Integer.class;
        Class[] interfaces = i.getInterfaces();
        for (Class anInterface : interfaces) {
            System.out.println(anInterface);
        }
        // interface java.lang.Comparable
    }
}

访问泛型

class Demo2 {
    public void test01(Map<String, Integer[]> map, List<Integer> list) {

    }

    public Map<String, Integer> test02() {
        return null;
    }
}

public class Demo {
    public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InstantiationException, InvocationTargetException, NoSuchFieldException {
        // 获取参数泛型信息
        Method test01 = Demo2.class.getMethod("test01", Map.class, List.class);
        Type[] genericParameterTypes = test01.getGenericParameterTypes();
        for (Type genericParameterType : genericParameterTypes) {
            System.out.println("#"+genericParameterType);
            if(genericParameterType instanceof ParameterizedType){
                ParameterizedType genericParameterType1 = (ParameterizedType) genericParameterType;
                for (Type type : genericParameterType1.getActualTypeArguments()) {
                    System.out.println(type);
                    /**
                     * 输出结果:
                     * #java.util.Map<java.lang.String, java.lang.Integer[]>
                     * class java.lang.String
                     * class [Ljava.lang.Integer;
                     * #java.util.List<java.lang.Integer>
                     * class java.lang.Integer
                     */
                }
            }
        }
        // 获取返回值泛型信息
        Method test02 = Demo2.class.getMethod("test02");
        Type genericReturnType = test02.getGenericReturnType();
        if(genericReturnType instanceof ParameterizedType){
            ParameterizedType genericReturnType1 = (ParameterizedType) genericReturnType;
            for (Type type : genericReturnType1.getActualTypeArguments()) {
                System.out.println(type);
                /**
                 * 输出结果:
                 * class java.lang.String
                 * class java.lang.Integer
                 */
            }
        }
    }
}

访问注解信息

@Table("Student_table")
class Student {
    @TableField(table_column = "name", type = "varchat", length = 3)
    private String name;
    @TableField(table_column = "name", type = "varchat", length = 10)
    private int id;
    @TableField(table_column = "name", type = "varchat", length = 10)
    private int age;

    public Student() {
    }

    public String getName() {
        return name;
    }

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

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public int getAge() {
        return age;
    }

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

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

// 自定义注解将类结构映射成数据库表
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@interface Table {
    String value();
}

@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@interface TableField {
    String table_column();

    String type();

    int length();
}

public class Demo {
    public static void main(String[] args) throws NoSuchFieldException {
        Class<Student> studentClass = Student.class;
        // 获取注解
        Annotation[] annotations = studentClass.getAnnotations();
        for (Annotation annotation : annotations) {
            System.out.println(annotation);  // @src.com.study.Table(value=Student_table)
        }

        // 获取注解value
        Table annotation = studentClass.getAnnotation(Table.class);
        System.out.println(annotation.value());

        // 获取某个属性的注解
        Annotation[] annotations2 = studentClass.getDeclaredField("name").getAnnotations();
        for (Annotation a : annotations2) {
            System.out.println(a);  // @src.com.study.TableField(table_column=name, type=varchat, length=3)
        }

        TableField tf = studentClass.getDeclaredField("name").getAnnotation(TableField.class);
        System.out.println(tf.length());  // 3
        System.out.println(tf.table_column());  // name
        System.out.println(tf.type());  // varchat
    }
}

访问 ClassLoader类

classLoader，就是负责把磁盘上的.class文件加载到JVM内存中，如下图所示：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-OuhrRHNX-1653558138153)(imgclip.png "imgclip.png")]

获取资源（项目 src 下的配置文件）

import java.io.InputStream;
import java.util.Properties;

public class Test {
    public static void main(String[] args) throws Exception {
        ClassLoader classLoader = Test.class.getClassLoader();
        InputStream in = classLoader.getResourceAsStream("db.properties");
        Properties properties = new Properties();
        properties.load(in);  // 加载配置资源
//        properties.get([key]);
    }
}

关于反射的面试题

创建对象时，利用new 创建好还是反射？

new只能用于编译时就能确定的类型, 而反射可以在运行时才确定类型并创建其对象。也就是说如果一开始就确定类型用new 创建对象比用反射创建对象要好，如果一开始未能判断类型使用反射创建对象比较合适。

反射可以得到对象，new也可以得到对象，有什么区别？

首先new出来的对象我们无法访问其中的私有属性，但是通过反射出来的对象我们可以通过setAccessible()方法来访问其中的私有属性，比较灵活。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-NyiTm73Z-1653558172661)(imgclip.png "imgclip.png")]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-u1mfHRj5-1653558172662)(imgclip_1.png "imgclip_1.png")]

在使用new创建一个对象实例的时候必须知道类名，但是通过反射创建对象有时候不需要知道类名也可以。
在使用反射的时候，必须确保这个类已经加载并已经连接了。使用new的时候，这个类可以没有被加载，也可以已经被加载。
new关键字是强类型的，效率较高。反射是弱类型的，效率低。

反射是否破坏了面向对象的封装特性？

封装性是指对外隐藏对象的属性和实现细节，仅对外提供公共的访问方式。反射是通过对象找到类，既然找到类了，那么我们就可以得到这个类的成员结构了，例如这个类的属性和方法，即使是private的也能得到，现在这个类我都得到了，那么这个类中的所以东西我肯定是都得到了，我现在只是得到了这个类的成员，并不是说可以在外部访问这个类的private的东西。所以说这并没有破坏面向对象的封装性。