（圣诞快乐）Java封神路之反射机制，老师跟我说“简单“，我当场就笑了

小馒头爱学Java

于 2021-12-10 00:16:21 发布

阅读量1.1k

点赞数 3

分类专栏： Java基础文章标签： java 开发语言后端

本文链接：https://blog.csdn.net/qq_45769329/article/details/121801536

版权

Java基础专栏收录该内容

6 篇文章 1 订阅

订阅专栏

目录

反射机制需要掌握的基本知识

1.反射机制的基本概念

2.Java中的类反射

3.反射机制有什么用？

4.反射机制的相关类在哪个包下？

5.反射机制相关的重要的类有哪些？

6.关于JDK中自带的类加载器

一、怎么获取java.lang.Class实例

1.Class.forName()获取实例

2.getClass()获取实例

3.Class c = int.class; 获取实例

二、获取到Class，能干什么？

三、关于文件路径问题

四、反射类中的Field（属性）

五、通过反射机制，反编译一个类（了解）

六、通过反射机制访问一个对象的属性（重点）

小插曲：可变长度参数

七、通过反射机制访问一个对象的Method

1.常用方法

2.反编译Method

3.通过反射机制怎么调用一个对象的方法？（重点）

八、反射构造方法Constructor

九、通过反射机制new对象

十、通过反射机制获取父类和父接口

反射机制需要掌握的基本知识

1.反射机制的基本概念

反射的概念是由 Smith 在 1982 年首次提出的，主要是指程序可以访问、检测和修改它本身状态或行为的一种能力，并能根据自身行为的状态和结果，调整或修改应用所描述行为的状态和相关的语义。Java 中，反射是一种强大的工具。它使您能够创建灵活的代码，这些代码可以在运行时装配，无需在组件之间进行源代码链接。反射允许我们在编写与执行时，使我们的程序代码能够接入装载到 JVM 中的类的内部信息，而不是源代码中选定的类协作的代码。这使反射成为构建灵活的应用的主要工具。 但需注意的是：如果使用不当，反射的成本很高

2.Java中的类反射

Reflection 是 Java 程序开发语言的特征之一，它允许运行中的 Java 程序对自身进行检查，或者说“ 自审 ” 或“自省”，并能直接操作程序的内部属性。 Java 的这一能力在实际应用中也许用得不是很多，但是在其它的程序设计语言中根本就不存在这一特性。例如，Pascal 、 C 或者 C++ 中就没有办法在程序中获得函数定义相关的信息

3.反射机制有什么用？

通过Java语言中的反射机制可以操作字节码文件
优点类似于黑客（可以读和修改字节码文件）
通过反射机制可以操作代码片段（class文件）

4.反射机制的相关类在哪个包下？

java.lang.reflect.*;

5.反射机制相关的重要的类有哪些？

java.lang.Class：代表整个字节码，代表一个类型，代表整个类
java.lang.reflect.Method：代表字节码中的方法字节码代表类中的方法 (了解内容)
java.lang.reflect.Constructor：代表字节码中的构造方法字节码代表类中的构造方法
java.lang.reflect.Field：代表字节码中的属性字节码代表类中的成员变量（静态变量+实例变量）

6.关于JDK中自带的类加载器

     6.1、什么是类加载器？

          专门负责加载类的命令/工具（ClassLoader）

     6.2、JDK中自带的3个类加载器

          启动类加载器:rt.jar

          扩展类加载器:ext/*.jar

          应用类加载器:classpath

     6.3、假设有这样一段代码：String s = "abc";

          代码在开始执行之前，会将所需要的类全部加载到JVM当中，通过类加载器加载，看到以上代码，类加载器会找String.class文件，找到就加载，那么是怎么进行加载的呢？

          首先通过“启动类加载器”加载（注意：启动类加载器专门加载：C:\Program Files\Java\jdk1.8.0_101\jre\lib\rt.jar ——rt.jar中都是JDK最核心的类库）

          如果通过“启动类加载器”加载不到的时候，会通过"扩展类加载器"加载（注意：扩展类加载器专门加载：C:\Program Files\Java\jdk1.8.0_101\jre\lib\ext\*.jar）

          如果“扩展类加载器”没有加载到，那么会通过“应用类加载器”加载（注意：应用类加载器专门加载：classpath中的类）

     6.4、双亲委派机制

          java中为了保证类加载的安全，使用了双亲委派机制：优先从启动类加载器中加载，这个称为“父”，“父”无法加载到，再从扩展类加载器中加载，这个称为“母”

          如果都加载不到，才会考虑从应用类加载器中加载，直到加载成功为止

一、怎么获取java.lang.Class实例

要操作一个类的字节码，需要首先获取到这个类的字节码，那么怎么获取java.lang.Class实例？有下面的这三种方式

1.Class.forName()获取实例

1.这是一个静态方法
2.方法的参数是一个字符串
3.字符串需要的是一个完整的类名
4.完整类名必须带有包名，java.lang包也不能省略
package com.java.javase.reflect;

public class ReflectTest {
    public static void main(String[] args) throws ClassNotFoundException {
        // c1代表String.class文件，或者说c1代表String类型
        Class c1=Class.forName("java.lang.String");
        // c2代表Date类型
        Class c2=Class.forName("java.util.Date");
        // c3代表Integer类型
        Class c3=Class.forName("java.lang.Integer");
        // c4代表System类型
        Class c4=Class.forName("java.lang.System");
    }
}
5.Class.forName这个方法的执行会导致 : 类加载，如果你只是希望一个类的静态代码块执行，其它代码一律不执行，你可以使用： Class.forName("完整类名")
package com.java.javase.reflect;

public class ReflectTest {
    public static void main(String[] args) throws Exception {
        Class.forName("com.java.javase.reflect.MyClass");
    }
}

class MyClass {
    // 静态代码块在类加载时执行，并且只执行一次
    static {
        System.out.println("MyClass类的静态代码块执行了!");
    }
}

输出结果：
MyClass类的静态代码块执行了!
2.getClass()获取实例

Java中任何一个对象都有的一个方法：getClass()
package com.java.javase.reflect;

public class ReflectTest {
    public static void main(String[] args) throws ClassNotFoundException {
        // c1代表String.class文件，或者说c1代表String类型
        Class c1=Class.forName("java.lang.String");
        String s="abc";

        // x代表String.class字节码文件，x代表String类型
        Class x=s.getClass();

        System.out.println(c1==x);
    }
}

运行结果为true
内存图

3.Class c = int.class; 获取实例
package com.java.javase.reflect;

public class ReflectTest {
    public static void main(String[] args) throws Exception {
        Class c=int.class;
        System.out.println(c);
    }
}

二、获取到Class，能干什么？

🍅1、通过反射机制，获取Class，通过Class来实例化对象

实例化需要用到newInstance()这个方法，该方法会调用User这个类的无参数构造方法，完成对象的创建，如果没有无参数构造方法，则会抛出异常，因此必须保证无参构造是存在的

package com.java.javase.reflect.bean;
public class User {
    public User() {
        System.out.println("无参数构造方法执行！");
    }
}


package com.java.javase.reflect;
public class ReflectTest {
    public static void main(String[] args) throws ClassNotFoundException {
        Class c=Class.forName("com.java.javase.reflect.bean.User");
        try {
            // newInstance()这个方法会调用User这个类的无参数构造方法，完成对象的创建
            Object obj=c.newInstance();
            // com.java.javase.reflect.bean.User@10f87f48
            System.out.println(obj);
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
    }
}

没有无参数构造方法的情况演示

package com.java.javase.reflect.bean;

public class User {
    //public User() {
    //    System.out.println("无参数构造方法执行！");
    //}

    // 定义了有参数的构造方法之后，无参数构造方法就没了
    public User(String s){

    }
}

抛出实例化对象异常

🍅2、反射机制的灵活运用

java代码只需要写一遍，在不改变java源代码的基础之上，可以做到不同对象的实例化，非常之灵活，符合OCP开闭原则（对拓展开放，对修改关闭！）

下面我们新建一个属性配置文件***.properties，里面的内容如下：

className=com.java.javase.reflect.bean.User

编写下面的代码并运行，查看输出结果

package com.java.javase.reflect;

import java.io.FileReader;
import java.util.Properties;

public class ReflectTest {
    public static void main(String[] args) throws Exception {
        // 通过IO流读取classinfo.properties文件
        FileReader fileReader=new FileReader("chapter8/classinfo.properties");
        // 创建属性类对象Map
        Properties pro=new Properties();
        // 加载
        pro.load(fileReader);
        // 关闭流
        fileReader.close();
        // 通过key获取value
        String className=pro.getProperty("className");

        // 通过反射机制实例化对象
        Class c=Class.forName(className);
        Object obj=c.newInstance();
        System.out.println(obj);
    }
}

输出结果:
无参数构造方法执行！
com.java.javase.reflect.bean.User@1d81eb93

三、关于文件路径问题

我们在上一个例子中写了这样一个路径（"chapter8/classinfo.properties）来读取配置文件，这种方式有什么问题？

这种方式的路径缺点是：移植性查，在IDEA中默认的当前路径是project的根，这个代码假设离开了IDEA，换到了其它位置，可能当前路径就不是project的根了，这个时候这个路径就无效了
package com.java.javase.reflect;

import java.io.FileReader;
import java.util.Properties;

public class ReflectTest {
    public static void main(String[] args) throws Exception {
        // 通过IO流读取classinfo.properties文件
        FileReader fileReader=new FileReader("chapter8/classinfo.properties");
      
    }
}
接下来说一种比较通用的路径写法，即使代码换位置了，该种方式的编写仍然有效，注意：使用下面这种方式的前提是：这个文件必须在类路径下（凡是在src下的都是类路径下，src是类的根路径）

编写代码，采用以下代码可以拿到一个文件的绝对路径（从类的根路径下src作为起点开始）
package com.java.javase.reflect;

public class ReflectTest {
    public static void main(String[] args) throws Exception {
        // String path = Thread.currentThread().getContextClassLoader().getResource("写相对路径，但是这个相对路径从src出发开始找").getPath();
        /**
         * Thread.currentThread() 当前线程对象
         * getContextClassLoader() 是线程对象的方法，可以获取到当前线程的类加载器对象
         * getResource() 【获取资源】 这是类加载器对象的方法，当前线程的类加载器默认从类的根路径下加载资源
         */
        // 采用以下代码可以拿到一个文件的绝对路径（从类的根路径下作为起点开始）
        String path = Thread.currentThread().
                getContextClassLoader().getResource("classinfo.properties").getPath();
        // 输出结果：/E:/02javadaima/out/production/chapter8/classinfo.properties
        System.out.println(path);
    }
}
当配置文件在其它位置（例如下面这几个位置）时的写法如下，前提都是要在src根路径下
 String path = Thread.currentThread().getContextClassLoader().getResource("abc").getPath();	// 必须保证src下有abc文件

String path = Thread.currentThread().getContextClassLoader().getResource("a/db").getPath();	// 必须保证src下有a目录，a目录下有db文件

String path=Thread.currentThread().getContextClassLoader()
.getResource("com/bjpowernode/test.properties").getPath();
// 必须保证src下有com目录，com目录下有bjpowernode目录，bjpowernode目录下有test.properties文件
这种方式是为了获取一个文件的绝对路径（通用方式，不会受到环境移植的影响）但是该文件要求放在类路径下，换句话说：也就是放到src下面——src下是类的根路径
改进1：上面这种方式是先拿到一个文件的绝对路径，然后自己new了一个流，再将这个绝对路径传入，下面还有一种方式，直接以流的形式返回，不需要自己再new一个流
package com.java.javase.reflect;

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

public class ReflectTest {
    public static void main(String[] args) throws Exception {
        // 直接以流的形式返回
        InputStream reader = Thread.currentThread().getContextClassLoader()
                .getResourceAsStream("classinfo.properties");
        Properties properties=new Properties();
        properties.load(reader);
        reader.close();
        // 通过key获取value
        String className=properties.getProperty("className");
        System.out.println(className);
    }
}
改进2：IO + Properties，快速绑定属性资源文件（资源绑定器）

java.util包下提供了一个资源绑定器，便于获取属性配置文件中的内容，使用以下这种方式的时候，属性配置文件xxx.properties必须放到类路径下，要求有下面三点

第一这个文件必须在类路径下
第二这个文件必须是以.properties结尾
第三 ResourceBundle bundle = ResourceBundle.getBundle("com/bjpowernode/test"); 不需要写成test.properties
package com.java.javase.reflect;

import java.util.ResourceBundle;

public class ReflectTest {
    public static void main(String[] args) throws Exception {
        // 资源绑定器，只能绑定xxx.properties文件，并且这个文件必须在类路径下，文件拓展名也必须是properties
        // 并且在写路径的时候，路径后面的拓展名不能写出来
        ResourceBundle bundle=ResourceBundle.getBundle("classinfo");
        // 通过key获取value
        String className=bundle.getString("className");
        System.out.println(className);
    }
}

四、反射类中的Field（属性）

下面有这么一个Student类，里面有四个不同的属性，我们该怎么获取其访问控制权限修饰符

package com.java.javase.reflect;

// 反射属性Field
// Field翻译为字段，其实就是属性/成员
// 4个Field，分别采用了不同的访问控制权限修饰符
public class Student {
    public int no;
    private String name;
    protected int age;
    boolean sex;
}

我们可以通过getFields() 方法获取所有公开的（public修饰的）属性

package com.java.javase.reflect;
// 怎么通过反射机制访问一个java对象的属性

import java.lang.reflect.Field;

public class ReflectTest {
    public static void main(String[] args) throws Exception{
        // 获取整个类
        Class studentClass=Class.forName("com.java.javase.reflect.Student");
        // 获取类中所有的公开的（public)Field
        Field[] fields=studentClass.getFields();
        // 输出结果为 1
        System.out.println(fields.length);
        Field f=fields[0];
        // 取出这个Field它的名字
        String fieldName=f.getName();
        // 输出结果为 no
        System.out.println(fieldName);
    }
}

如果我们想要获取所有的Field（包括public），可以使用下面的这个方法

getDeclaredFields()获取类中所有的Field

package com.java.javase.reflect;
// 怎么通过反射机制访问一个java对象的属性

import java.lang.reflect.Field;

public class ReflectTest {
    public static void main(String[] args) throws Exception{
        // 获取整个类
        Class studentClass=Class.forName("com.java.javase.reflect.Student");
        // 获取类中所有的Field
        Field[] fields=studentClass.getDeclaredFields();
        // 输出结果为 4
        System.out.println(fields.length);

        // 取出所有Field的名字
        for(Field fd : fields){
            System.out.println(fd);
        }
    }
}

输出结果：

4
public int com.java.javase.reflect.Student.no
private java.lang.String com.java.javase.reflect.Student.name
protected int com.java.javase.reflect.Student.age
boolean com.java.javase.reflect.Student.sex

属性.getType()，获取属性的类型

package com.java.javase.reflect;
// 怎么通过反射机制访问一个java对象的属性

import java.lang.reflect.Field;

public class ReflectTest {
    public static void main(String[] args) throws Exception{
        // 获取整个类
        Class studentClass=Class.forName("com.java.javase.reflect.Student");
        // 获取类中所有的Field
        Field[] fields=studentClass.getDeclaredFields();

        // 获取属性的类型
        for(Field fd : fields){
            Class fieldType=fd.getType();
            System.out.println(fieldType.getName());
        }
    }
}

输出结果：
int
java.lang.String
int
boolean

将getName()换为getSimpleName()

输出结果如下：

int
String
int
boolean

属性.getModifiers()，获取属性的修饰符列表

返回的修饰符是一个数字

每个数字是修饰符的代号！

package com.java.javase.reflect;
// 怎么通过反射机制访问一个java对象的属性

import java.lang.reflect.Field;

public class ReflectTest {
    public static void main(String[] args) throws Exception{
        // 获取整个类
        Class studentClass=Class.forName("com.java.javase.reflect.Student");
        // 获取类中所有的Field
        Field[] fields=studentClass.getDeclaredFields();

        // 获取属性的修饰符列表
        for(Field fd : fields){
            Class fieldType=fd.getType();
            System.out.println(fieldType.getSimpleName());
            int i=fd.getModifiers();
            System.out.println(i);
        }

    }
}
输出结果：
int
1
String
2
int
4
boolean
0
Student是这样定义的：
public int no;
private String name;
protected int age;
boolean sex;

Modifier.toString(i)

传入一个类型（int、String...）的“代号"

输出字符串

        // 获取属性的修饰符列表
        for(Field fd : fields){
            int i=fd.getModifiers();
            // 将这个“代号”数字转换成“字符串”
            String modifierString=Modifier.toString(i);
            System.out.println(modifierString);
        }
    
        输出结果：
        public
        private
        protected

五、通过反射机制，反编译一个类（了解）

也就是说给出一个class文件，我们可以通过反编译拿到java源码（就是东拼西凑将这个类的源码拼接出来），具体编写代码如下

package com.java.javase.reflect;

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

public class ReflectTest {
    public static void main(String[] args) throws Exception{
        // 创建字符串拼接对象
        StringBuilder s=new StringBuilder();
        // 获取整个类
        Class studentClass=Class.forName("com.java.javase.reflect.Student");
        s.append(Modifier.toString(studentClass.getModifiers())+" class "+studentClass.getSimpleName()+" {"+"\n");

        // 获取类中所有的Field
        Field[] fields=studentClass.getDeclaredFields();
        for (Field fd : fields){
            s.append("\t");
            s.append(Modifier.toString(fd.getModifiers()));
            s.append(" ");
            s.append(fd.getType().getSimpleName());
            s.append(" ");
            s.append(fd.getName());
            s.append(";\n");
        }
        s.append("}");
        System.out.println(s);

    }
}

输出结果

public class Student {
	public int no;
	private String name;
	protected int age;
	 boolean sex;
}

六、通过反射机制访问一个对象的属性（重点）

使用反射机制，怎么去访问一个对象的属性？

```
要素1：obj对象
```
```
要素2：属性
```
```
要素3：要赋的值
```

package com.java.javase.reflect;

import java.lang.reflect.Field;

public class ReflectTest {
    public static void main(String[] args) throws Exception{
        // 获取整个类
        Class studentClass=Class.forName("com.java.javase.reflect.Student");
        Object obj=studentClass.newInstance();      // obj就是Student对象

        // 拿到no属性(根据属性的名称来获取Field)
        Field noField= studentClass.getDeclaredField("no");
        // 给obj对象（Student对象）的no属性赋值
        noField.set(obj,2222);
        // 输出属性的值
        System.out.println(noField.get(obj));
    }
}

反射机制可以访问私有属性吗？在没有打破封装之前，答案是不可以！

package com.java.javase.reflect;

import java.lang.reflect.Field;

public class ReflectTest {
    public static void main(String[] args) throws Exception{
        // 获取整个类
        Class studentClass=Class.forName("com.java.javase.reflect.Student");
        Object obj=studentClass.newInstance();      // obj就是Student对象

        // 反射机制可以访问私有属性吗？
        Field nameField=studentClass.getDeclaredField("name");
        nameField.set(obj,"Tom");
        System.out.println(nameField.get(obj));
    }
}

程序报出异常：
Exception in thread "main" java.lang.IllegalAccessException: class com.java.javase.reflect.reflectTest07 cannot access a member of class com.java.javase.reflect.Student with modifiers "private"
	at java.base/jdk.internal.reflect.Reflection.newIllegalAccessException(Reflection.java:376)
	at java.base/java.lang.reflect.AccessibleObject.checkAccess(AccessibleObject.java:642)
	at java.base/java.lang.reflect.Field.checkAccess(Field.java:1075)
	at java.base/java.lang.reflect.Field.set(Field.java:778)
	at com.java.javase.reflect.reflectTest07.main(reflectTest07.java:14)

nameField.setAccessible(true)

打破封装（反射机制的缺点，可能会给不法分子留下机会）

这样设置完之后，在外部也是可以访问private的！

package com.java.javase.reflect;

import java.lang.reflect.Field;

public class ReflectTest {
    public static void main(String[] args) throws Exception{
        // 获取整个类
        Class studentClass=Class.forName("com.java.javase.reflect.Student");
        Object obj=studentClass.newInstance();      // obj就是Student对象
        // 反射机制可以访问私有属性吗？
        Field nameField=studentClass.getDeclaredField("name");
        // nameField.setAccessible(true); 打破封装
        nameField.setAccessible(true);
        nameField.set(obj,"Tom");
        System.out.println(nameField.get(obj));
    }
}

小插曲：可变长度参数

 可变长度参数
       int ...args 这就是可变长度参数
       注意（一定是3个点）
 1.可变长度参数要求的个数是：0到n个
 2.可变长度参数在参数列表中的最后一个位置
 3.可变长度参数只能有一个

package com.java.javase.reflect;

public class ArgsTest {
    public static void main(String[] args) {
        m1();
        m1(10);
        m1(10,20);

        m2(10,"chen");
        m2(10,"a","b");
    }
    public static void m1(int...args1){
        System.out.println("m1方法执行了");
    }
    public static void m2(int a,String...args2){
        System.out.println("m2方法执行了");
    }
}

args有length属性，说明args是一个数组

package com.java.javase.reflect;

public class ArgsTest {
    public static void main(String[] args) {
        m3("ab","cd","ef","mn");
    }

    public static void m3(String...args3){
        // args有length属性，说明args是一个数组
        for (int i=0;i< args3.length;i++){
            System.out.println(args3[i]);
        }
    }
}

输出结果：
ab
cd
ef
mn

七、通过反射机制访问一个对象的Method

1、常用方法

getDeclaredMethods()
获取所有的Method（包括私有的）

method.getReturnType().getSimpleName();
获取方法的返回值类型

Modifier.toString(method.getModifiers());
获取修饰符列表

method.getParameterTypes();
获取形参类型列表
返回的是一个Class数组

package com.java.javase.reflect;

import java.lang.reflect.Method;

public class ReflectTest {
    public static void main(String[] args) throws ClassNotFoundException {
        Class userServiceClass=Class.forName("com.java.javase.reflect.UserService");
        // 获取所有的Method（包括私有的）
        Method[] methods=userServiceClass.getDeclaredMethods();

        // 遍历Method
        for(Method method : methods){
            // 获取方法名
            System.out.println(method.getName());
        }
    }
}

class UserService {
    /**
     * 登录方法
     * @param name
     * @param password
     * @return
     */
    public boolean login(String name,String password){
        if("admin".equals(name)&&"123".equals(password)){
            return true;
        }
        return false;
    }
    public void logout(){
        System.out.println("系统已安全退出！");
    }
}

获取形参类型列表的代码

        for(Method method : methods){
            // 获取形参类型列表，返回的是一个 Class 数组
            Class[] parameterTypes=method.getParameterTypes();
            for (Class parameterType : parameterTypes){
                System.out.println(parameterType.getSimpleName());
            }
        }

2、反编译Method

package com.java.javase.reflect;

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

public class ReflectTest {
    public static void main(String[] args) throws ClassNotFoundException {
        StringBuilder s=new StringBuilder();
        Class userServiceClass=Class.forName("com.java.javase.reflect.UserService");
        s.append(Modifier.toString(userServiceClass.getModifiers())+"class"+" "
                +userServiceClass.getSimpleName()+"{"+"\n");

        Method[] methods= userServiceClass.getDeclaredMethods();
        for (Method method : methods){
            s.append("\t");
            s.append(Modifier.toString(method.getModifiers()));
            s.append(" ");
            s.append(method.getReturnType().getSimpleName());
            s.append(" ");
            s.append(method.getName());
            s.append("(");
            // 追加形参
            Class[] parameterTypes= method.getParameterTypes();
            if (parameterTypes.length!=0){
                for (Class parameterType : parameterTypes){
                    s.append(parameterType.getSimpleName());
                    s.append(",");
                }
                s.deleteCharAt(s.length()-1);
            }
            s.append("){}"+"\n");
        }

        s.append("}");
        System.out.println(s);
    }
}

class UserService {
    /**
     * 登录方法
     * @param name
     * @param password
     * @return
     */
    public boolean login(String name,String password){
        if("admin".equals(name)&&"123".equals(password)){
            return true;
        }
        return false;
    }
    public void logout(){
        System.out.println("系统已安全退出！");
    }
}

输出结果

class UserService{
	public boolean login(String,String){}
	public void logout(){}
}

3、通过反射机制怎么调用一个对象的方法？（重点）

调用方法所需要素：
    要素1：对象
    要素2：方法名
    要素3：实参列表
    要素4：返回值

package com.java.javase.reflect;

import java.lang.reflect.Method;

public class ReflectTest {
    public static void main(String[] args) throws Exception {
        Class userServiceClass=Class.forName("com.java.javase.reflect.UserService");
        Object obj=userServiceClass.newInstance();
        // 获取方法
        Method loginMethod=userServiceClass.getDeclaredMethod("login", String.class, String.class);
        // 调用方法
        // loginMethod 方法
        // obj 对象
        // "admin"、"123" 实参
        // retValue 返回值
        Object retValue=loginMethod.invoke(obj,"admin","123");
        System.out.println(retValue);
    }
}

class UserService {
    /**
     * 登录方法
     * @param name
     * @param password
     * @return
     */
    public boolean login(String name,String password){
        if("admin".equals(name)&&"123".equals(password)){
            return true;
        }
        return false;
    }
    public void logout(){
        System.out.println("系统已安全退出！");
    }
}

八、反射构造方法Constructor

现在有这样一个Vip类，如何反编译这个类的Constructor构造方法？

class Vip {
    int no;
    String name;
    String birth;
    boolean sex;

    public Vip() {
    }

    public Vip(int no) {
        this.no = no;
    }

    public Vip(int no, String name) {
        this.no = no;
        this.name = name;
    }

    public Vip(int no, String name, String birth) {
        this.no = no;
        this.name = name;
        this.birth = birth;
    }

    public Vip(int no, String name, String birth, boolean sex) {
        this.no = no;
        this.name = name;
        this.birth = birth;
        this.sex = sex;
    }
}

反编译代码

package com.java.javase.reflect;

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

public class ReflectTest {
    public static void main(String[] args) throws Exception {
        StringBuilder s=new StringBuilder();
        Class vipClass=Class.forName("com.java.javase.reflect.Vip");
        s.append(Modifier.toString(vipClass.getModifiers()));
        s.append("class ");
        s.append(vipClass.getSimpleName());
        s.append("{\n");

        // 拼接构造方法
        Constructor[] constructors= vipClass.getDeclaredConstructors();
        for (Constructor constructor : constructors){
            s.append("\t");
            s.append(Modifier.toString(constructor.getModifiers()));
            s.append(" ");
            s.append(vipClass.getSimpleName());
            s.append("(");
            // 追加形参
            Class[] parameterTypes= constructor.getParameterTypes();
            if (parameterTypes.length!=0){
                for (Class parameterType : parameterTypes){
                    s.append(parameterType.getSimpleName());
                    s.append(",");
                }
                s.deleteCharAt(s.length()-1);
            }
            s.append("){}"+"\n");
        }
        s.append("}\n");
        System.out.println(s);
    }
}

输出结果

class Vip{
	public Vip(int,String,String,boolean){}
	public Vip(int,String,String){}
	public Vip(int,String){}
	public Vip(int){}
	public Vip(){}
}

九、通过反射机制new对象

 第一步：获取到有参数的构造方法

 第二步：调用构造方法new对象

编写代码

package com.java.javase.reflect;

import java.lang.reflect.Constructor;

public class ReflectTest {
    public static void main(String[] args) throws Exception {
        Class vipClass=Class.forName("com.java.javase.reflect.Vip");
        Object obj=vipClass.newInstance();
        
        Constructor con=vipClass.getDeclaredConstructor(int.class,String.class,String.class,boolean.class);
        // 第二步：调用构造方法new对象
        Object newObj=con.newInstance(100,"zhangsan","2021-12",true);
        System.out.println(newObj);
    }
}

也可以通过无参数的构造方法new对象

package com.java.javase.reflect;

import java.lang.reflect.Constructor;

public class ReflectTest {
    public static void main(String[] args) throws Exception {
        Class vipClass=Class.forName("com.java.javase.reflect.Vip");
        Object obj=vipClass.newInstance();
        // 第一步：获取到无参数的构造方法，不传入任何参数
        Constructor con=vipClass.getDeclaredConstructor();
        // 第二步：调用构造方法new对象
        Object newObj=con.newInstance();
        System.out.println(newObj);
    }
}

十、通过反射机制获取父类和父接口

getSuperclass()

getInterfaces()

package com.java.javase.reflect;

public class ReflectTest {
    public static void main(String[] args) throws Exception {
        // String举例
        Class stringClass=Class.forName("java.lang.String");

        // 获取String的父类
        Class superClass=stringClass.getSuperclass();
        // java.lang.Object
        System.out.println(superClass.getName());

        // 获取String类实现的所有接口（一个类可以实现多个接口)
        Class[] interfaces=stringClass.getInterfaces();
        for(Class in : interfaces){
            System.out.println(in.getName());
        }
    }
}