在 Java 中，使用反射来创建对象、创建数组、调用方法

已于 2023-08-13 19:58:36 修改
阅读量1.3k 收藏 3
点赞数 2
分类专栏： 方法/其它教程 文章标签： java 反射
于 2021-07-15 01:24:43 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wangpaiblog/article/details/118742943
版权

文章目录

  假设已有下面的类：

  • 示例类：Demo
package org.wangpai.reflectionuses.model;

/**
 * @since 2022-9-11
 */
public class Demo {
    private FieldA fieldA;

    private FieldB fieldB;

    /**
     * 无参构造器
     *
     * @since 2022-9-11
     */
    public Demo() {
        System.out.println("无参构造器 Demo() 被调用");
        System.out.println();
    }

    /**
     * 有参构造器
     *
     * @since 2022-9-11
     */
    public Demo(ParaA paraA, ParaB paraB) {
        System.out.println("构造器 Demo(ParaA paraA, ParaB paraB) 被调用");
        System.out.println("  > paraA：" + paraA);
        System.out.println("  > paraB：" + paraB);
        System.out.println();
        this.fieldA = new FieldA(paraA.toString());
        this.fieldB = new FieldB(paraB.toString());
    }

    /**
     * 公有静态方法
     *
     * @since 2022-9-11
     */
    public static void publicStaticFun(ParaA paraA, ParaB paraB) {
        System.out.println("公有静态方法 publicStaticFun(ParaA paraA, ParaB paraB) 被调用");
        System.out.println("  > paraA：" + paraA);
        System.out.println("  > paraB：" + paraB);
        System.out.println();
    }

    /**
     * 私有有静态方法
     *
     * @since 2022-9-11
     */
    private static void privateStaticFun(ParaA paraA, ParaB paraB) {
        System.out.println("私有有静态方法 privateStaticFun(ParaA paraA, ParaB paraB) 被调用");
        System.out.println("  > paraA：" + paraA);
        System.out.println("  > paraB：" + paraB);
        System.out.println();
    }

    /**
     * 公有非静态方法
     *
     * @since 2022-9-11
     */
    public void publicFun(ParaA paraA, ParaB paraB) {
        System.out.println("公有方法 publicFun(ParaA paraA, ParaB paraB) 被调用");
        System.out.println("  > paraA：" + paraA);
        System.out.println("  > paraB：" + paraB);
        System.out.println();
    }

    /**
     * 私有非静态方法
     *
     * @since 2022-9-11
     */
    private void privateFun(ParaA paraA, ParaB paraB) {
        System.out.println("私有方法 privateFun(ParaA paraA, ParaB paraB) 被调用");
        System.out.println("  > paraA：" + paraA);
        System.out.println("  > paraB：" + paraB);
        System.out.println();
    }

    /**
     * 公有非静态可变参方法（无前面的固定参数）
     *
     * @since 2022-9-11
     */
    public void publicVarParaFunWithNoFixedPara(ParaA... paraAS) {
        System.out.println("公有可变参方法（无前面的固定参数） publicVarParaFunWithNoFixedPara(ParaA... paraAS) 被调用");
        for (int order = 0; order < paraAS.length; ++order) {
            System.out.println(String.format("  > 可变参参数，第 %d 参数是：", order + 1) + paraAS[order]);
        }
        System.out.println();
    }

    /**
     * 公有非静态可变参方法（有前面的固定参数）
     *
     * @since 2022-9-11
     */
    public void publicVarParaFunWithFixedPara(ParaA paraA, ParaB... paraBs) {
        System.out.println("公有可变参方法（有前面的固定参数） publicVarParaFunWithFixedPara(ParaA paraA, ParaB... paraBs) 被调用");
        System.out.println("  > 固定参数 paraA：" + paraA);
        for (int order = 0; order < paraBs.length; ++order) {
            System.out.println(String.format("  > 可变参参数，第 %d 参数是：", order + 1) + paraBs[order]);
        }
        System.out.println();
    }

    /**
     * 私有非静态可变参方法（无前面的固定参数）
     *
     * @since 2022-9-11
     */
    private void privateVarParaFunWithNoFixedPara(ParaA... ParaAs) {
        System.out.println("私有可变参方法（无前面的固定参数） privateVarParaFunWithNoFixedPara(ParaA... ParaAs) 被调用");
        for (int order = 0; order < ParaAs.length; ++order) {
            System.out.println(String.format("  > 可变参参数，第 %d 参数：", order + 1) + ParaAs[order]);
        }
        System.out.println();
    }

    /**
     * 私有非静态可变参方法（有前面的固定参数）
     *
     * @since 2022-9-11
     */
    private void privateVarParaFunWithFixedPara(ParaA paraA, ParaB... paraBs) {
        System.out.println("私有可变参方法 privateVarParaFunWithFixedPara(ParaA paraA, ParaB... paraBs) 被调用");
        System.out.println("  > 固定参数 paraA：" + paraA);
        for (int order = 0; order < paraBs.length; ++order) {
            System.out.println(String.format("  > 可变参参数，第 %d 参数：", order + 1) + paraBs[order]);
        }
        System.out.println();
    }

    /**
     * @since 2023-8-13
     */
    public void showFields() {
        System.out.println("公有方法 showFields() 被调用");
        System.out.println("  > fieldA：" + this.fieldA);
        System.out.println("  > fieldB：" + this.fieldB);
        System.out.println();
    }
}
  • 字段类：FieldA
package org.wangpai.reflectionuses.model;

/**
 * 参数类 FieldA
 *
 * @since 2023-8-13
 */
public class FieldA {
    private String info;

    /**
     * @since 2023-8-13
     */
    public FieldA() {
        super();
    }

    /**
     * @since 2023-8-13
     */
    public FieldA(String str) {
        super();
        this.info = str;
    }

    /**
     * @since 2023-8-13
     */
    @Override
    public String toString() {
        return this.info;
    }
}
  • 字段类：FieldB
package org.wangpai.reflectionuses.model;

/**
 * 参数类 FieldB
 *
 * @since 2023-8-13
 */
public class FieldB {
    private String info;

    /**
     * @since 2023-8-13
     */
    public FieldB() {
        super();
    }

    /**
     * @since 2023-8-13
     */
    public FieldB(String str) {
        super();
        this.info = str;
    }

    /**
     * @since 2023-8-13
     */
    @Override
    public String toString() {
        return this.info;
    }
}
  • 参数类：ParaA
package org.wangpai.reflectionuses.model;

/**
 * 参数类 ParaA
 *
 * @since 2022-9-11
 */
public class ParaA {
    private String info;

    public ParaA() {
        super();
    }

    public ParaA(String str) {
        super();
        this.info = str;
    }

    @Override
    public String toString() {
        return this.info;
    }
}
  • 参数类：ParaB
package org.wangpai.reflectionuses.model;

/**
 * 参数类 ParaB
 *
 * @since 2022-9-11
 */
public class ParaB {
    private String info;

    public ParaB() {
        super();
    }

    public ParaB(String str) {
        super();
        this.info = str;
    }

    @Override
    public String toString() {
        return this.info;
    }
}

反射访问字段

ParaA paraA = new ParaA("这是 ParaA");
ParaB paraB = new ParaB("这是 ParaB");
Demo demo = new Demo(paraA, paraB);
Field fA = demo.getClass().getDeclaredField("fieldA");
fA.setAccessible(true); // 设置允许反射读写私有字段
FieldA fieldA = (FieldA) fA.get(demo);
System.out.println("fieldA：" + fieldA);

构造器 Demo(ParaA paraA, ParaB paraB) 被调用
  > paraA：这是 ParaA
  > paraB：这是 ParaB

fieldA：这是 ParaA

反射修改字段

ParaA paraA1 = new ParaA("这是 ParaA1");
ParaB paraB1 = new ParaB("这是 ParaB1");
Demo demo = new Demo(paraA1, paraB1);
FieldA fieldA2 = new FieldA("这是 FieldA2");
Field fA = demo.getClass().getDeclaredField("fieldA");
fA.setAccessible(true); // 设置允许反射读写私有字段
fA.set(demo, fieldA2);
demo.showFields();

构造器 Demo(ParaA paraA, ParaB paraB) 被调用
  > paraA：这是 ParaA1
  > paraB：这是 ParaB1

公有方法 showFields() 被调用
  > fieldA：这是 FieldA2
  > fieldB：这是 ParaB1

反射创建对象

ParaA paraA = new ParaA("这是 ParaA");
ParaB paraB = new ParaB("这是 ParaB");
Demo demo = Demo.class
        .getConstructor(ParaA.class, ParaB.class)
        .newInstance(paraA, paraB);

构造器 Demo(ParaA paraA, ParaB paraB) 被调用
  > paraA：这是 ParaA
  > paraB：这是 ParaB

反射调用方法

反射调用公有静态方法

ParaA paraA = new ParaA("这是 ParaA");
ParaB paraB = new ParaB("这是 ParaB");
Demo.class.getMethod("publicStaticFun", ParaA.class, ParaB.class)
        .invoke(null, paraA, paraB);

公有静态方法 publicStaticFun(ParaA paraA, ParaB paraB) 被调用
  > paraA：这是 ParaA
  > paraB：这是 ParaB

反射调用私有静态方法

ParaA paraA = new ParaA("这是 ParaA");
ParaB paraB = new ParaB("这是 ParaB");
var privateFun = Demo.class.getDeclaredMethod("privateStaticFun", ParaA.class, ParaB.class);
privateFun.setAccessible(true); // 如果此处的类本来就有权限调用用反射调用的方法，则此行代码可以省略
privateFun.invoke(null, paraA, paraB);

私有有静态方法 privateStaticFun(ParaA paraA, ParaB paraB) 被调用
  > paraA：这是 ParaA
  > paraB：这是 ParaB

反射调用公有非静态方法

  调用上述 Test 对象的可变参私有方法的办法是：

Demo demo = new Demo();
ParaA paraA = new ParaA("这是 ParaA");
ParaB paraB = new ParaB("这是 ParaB");
Demo.class.getMethod("publicFun", ParaA.class, ParaB.class)
        .invoke(demo, paraA, paraB);

无参构造器 Demo() 被调用

公有方法 publicFun(ParaA paraA, ParaB paraB) 被调用
  > paraA：这是 ParaA
  > paraB：这是 ParaB

反射调用私有非静态方法

Demo demo = new Demo();
ParaA paraA = new ParaA("这是 ParaA");
ParaB paraB = new ParaB("这是 ParaB");
var privateFun = Demo.class.getDeclaredMethod("privateFun", ParaA.class, ParaB.class);
privateFun.setAccessible(true); // 如果此处的类本来就有权限调用用反射调用的方法，则此行代码可以省略
privateFun.invoke(demo, paraA, paraB);

无参构造器 Demo() 被调用

私有方法 privateFun(ParaA paraA, ParaB paraB) 被调用
  > paraA：这是 ParaA
  > paraB：这是 ParaB

反射调用公有非静态可变参方法（无前面的固定参数）

Demo demo = new Demo();
ParaA paraAOne = new ParaA("这是第一个 ParaA");
ParaA paraATwo = new ParaA("这是第二个 ParaA");
ParaA[] paraAs = new ParaA[]{paraAOne, paraATwo};
/**
 * 虽然 paraAs 已经是数组，但此处还是要将可变参数组再封装到一个数组中。
 * 不过，如果固定参数存在时，可以不用再外加数组，改为直接将各个元素列出。
 * 此处因为固定参数不存在，所以需再套一层数组
 */
Demo.class.getMethod("publicVarParaFunWithNoFixedPara", ParaA[].class)
        .invoke(demo, new Object[]{paraAs});

无参构造器 Demo() 被调用

公有可变参方法（无前面的固定参数） publicVarParaFunWithNoFixedPara(ParaA... paraAS) 被调用
  > 可变参参数，第 1 参数是：这是第一个 ParaA
  > 可变参参数，第 2 参数是：这是第二个 ParaA

反射调用私有非静态可变参方法（有前面的固定参数）

Demo demo = new Demo();
ParaA paraA = new ParaA("这是 ParaA");
ParaB paraBOne = new ParaB("这是第一个 ParaB");
ParaB paraBTwo = new ParaB("这是第二个 ParaB");
ParaB[] paraBs = new ParaB[]{paraBOne, paraBTwo};
Demo.class.getDeclaredMethod("publicVarParaFunWithFixedPara", ParaA.class, ParaB[].class)
        .invoke(demo, paraA, paraBs); // 因为固定参数有 1 个及以上，所以此处可以不用数组来包装

无参构造器 Demo() 被调用

公有可变参方法（有前面的固定参数） publicVarParaFunWithFixedPara(ParaA paraA, ParaB... paraBs) 被调用
  > 固定参数 paraA：这是 ParaA
  > 可变参参数，第 1 参数是：这是第一个 ParaB
  > 可变参参数，第 2 参数是：这是第二个 ParaB

反射调用私有非静态可变参方法（无前面的固定参数）

Demo demo = new Demo();
ParaA paraAOne = new ParaA("这是第一个 ParaA");
ParaA paraATwo = new ParaA("这是第二个 ParaA");
ParaA[] paraAs = new ParaA[]{paraAOne, paraATwo};
var privateFun = Demo.class.getDeclaredMethod(
        "privateVarParaFunWithNoFixedPara", ParaA[].class);
privateFun.setAccessible(true);
/**
 * 虽然 paraAs 已经是数组，但此处还是要将可变参数组再封装到一个数组中。
 * 不过，如果固定参数存在时，可以不用再外加数组，改为直接将各个元素列出。
 * 此处因为固定参数不存在，所以需再套一层数组
 */
privateFun.invoke(demo, new Object[]{paraAs});

无参构造器 Demo() 被调用

私有可变参方法（无前面的固定参数） privateVarParaFunWithNoFixedPara(ParaA... ParaAs) 被调用
  > 可变参参数，第 1 参数：这是第一个 ParaA
  > 可变参参数，第 2 参数：这是第二个 ParaA

反射调用私有非静态可变参方法（有前面的固定参数）

Demo demo = new Demo();
ParaA paraA = new ParaA("这是 ParaA");
ParaB paraBOne = new ParaB("这是第一个 ParaB");
ParaB paraBTwo = new ParaB("这是第二个 ParaB");
ParaB[] paraBs = new ParaB[]{paraBOne, paraBTwo};
var privateFun = Demo.class.getDeclaredMethod(
        "privateVarParaFunWithFixedPara", ParaA.class, ParaB[].class);
privateFun.setAccessible(true);
// 因为固定参数有 1 个及以上，所以此处可以不用数组来包装
privateFun.invoke(demo, paraA, paraBs);

无参构造器 Demo() 被调用

私有可变参方法 privateVarParaFunWithFixedPara(ParaA paraA, ParaB... paraBs) 被调用
  > 固定参数 paraA：这是 ParaA
  > 可变参参数，第 1 参数：这是第一个 ParaB
  > 可变参参数，第 2 参数：这是第二个 ParaB

反射创建数组

int arrayLength = 10;
// 注意：这样创建之后，得到的是一个空有长度无内容的空数组，因此，后续使用该数组，还需要依次初始化该数组的各个元素
Demo[] targetArray = (Demo[]) Array.newInstance(Demo[].class.getComponentType(), arrayLength);

反射调用的方法自身可以抛出异常的情形

  如果反射调用的方法本身可以抛出异常，则当其抛出异常时，此异常会被反射“吞掉”，封装成 InvocationTargetException 异常重新抛出。可以使用该封装异常的方法 getTargetException 或 getCause 来获取被吞掉的异常。例如，

try {
    /**
     * 此处为某反射调用代码
     */
} catch (InvocationTargetException exception) {
    Throwable realException = exception.getTargetException();
    if (realException instanceof MyXXXException) {
        throw (MyXXXException) realException;
    } else {
        // TODO：可以选择再抛出 InvocationTargetException 异常，也可以抛出自己想抛出的异常。或者做其它事情。
    }
}

完整源代码

  已上传至 GitHub 中，可免费下载：https://github.com/wangpaiblog/20210715_reflection-sample

暗诺星刻
关注
  • 2
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java invoke 泛型_如何通过java反射调用含有泛型数组参数的方法
weixin_35698738的博客
02-13 712
最近在看一个算法课程，老师用的是c++的template和函数指针来完成一个实现，于是我想用java通过反射和泛型来完成，但是出现了问题。希望通过java反射以及泛型来实现动态测试SortClass中的各种排序函数，这时getmethod方法和invoke方法的参数不知道如何解决了。我写的这个实现一直报参数异常代码class SortClass{//选择排序public void selectSo...
反射创建对象_反射
weixin_39612332的博客
12-08 470
在Java中一切皆对象，其实所有的类底层都有一个字节码对象，可以使用反射来描述着一个个类底层的字节码对象。在运行时期，动态地去获取类中的信息（类的信息，方法的信息，构造方法的信息，字段等信息）。一个类中，包括构造方法，字段，方法。Class：描述类Method：描述方法Constructor：描述构造方法Field：描述字段获取类的Class实例三种方式1.类名.class2.类的对象.getCl...
【注解和反射】通过反射动态创建对象、调用普通方法、操作属性
最新发布
水w的博客
04-25 1129
通过反射动态创建对象、调用普通方法、操作属性
Java中反射机制详解
asdfgha14的博客
05-27 1307
解释：需要明白servlet的生命周期，也就是service方法，因为是servlet，所以在访问的时候，会经过service方法，而子类MyServlet001中并没有，所以就到父类BaseServlet中找，发现有，然后获取参数即知道了需要调用什么方法，因为方法的编写都在子类中，所以通过反射，获取到子类中对应的方法并运行，其中需要注意的是this这个参数在BaseServlet中的用法。注意newProxyInstance的三个参数，第一个，类加载器，第二个被代理对象的接口，第三个代理对象。
如何通过反射创建对象
星空
11-09 3733
通过反射创建对象的两种方法： 通过Class字节码对象newInstance();（默认通过无参构造创建） 通过获取构造器getConstructor(Class<?>…parameterTypes);（通过有参的构造器，参数可以指定具体类型和多个数量） 代码： 假设我们有一个用户类User package test.java.zxj.test_project; pub...
JAVA反射机制创建对象的三种方式
weixin_36873225的博客
11-04 1438
1.获取其中方法和参数并在控制台打印。JAVA反射机制创建对象的三种方式。2.激活对象中的方法。
【Java】反射获取类对象、构造器对象、成员变量对象、成员方法对象的方式
m0_64210833的博客
03-27 3182
反射第一步 获取Class类对象，这样才能获取类中的所有属性、行为...; 获取Class类的三种方式 方式一：Class c1 = 类名.class； 方式二：Class c2 = 对象名.getClass age去调用set方法喊对象s去进行赋值（反射） 以前是s，setage（18）主动去赋值 关系反转（age调用get方法喊s对象获取年龄） 注解的作用 元注解：注解注解的注解 ...
java 反射创建对象并赋值_java使用反射创建并操作对象的方法
weixin_30581253的博客
02-13 2122
Class 对象可以获得该类里的方法(由 Method 对象表示)、构造器(由 Constructor 对象表示)、成员变量(由 Field 对象表示)，这三个类都位于 java.lang.reflect 包下，并实现了 java.lang.reflect.Member 接口。程序可以通过对象来执行对应的方法，通过 Constructor 对象来调用对应的构造器创建实例，能通过 Field 对象直...
关于java反射机制创建Class对象、创建实例对象，调用方法
weixin_47803168的博客
12-12 1011
关于java反射机制创建Class对象、创建实例对象，调用方法 通过反射机制创建Class对象使用最多的方法就是通过Class.forName返回Class对象，因为这种方法需要传递的参数是一个字符串，字符串可以写入配置文件，方便修改。 /** * 创建一个Text类作为反射机制的练习 * Text类有一个int类型的参数和一个String类型的参数 * 一个pr方法，形参是三个String类型的，返回值是String的 */ public class Text {
实例讲解Java编程中数组反射的使用方法
09-02
在Java编程中，反射是一个强大的工具，它允许我们在运行时检查和操作类、接口、字段和方法。反射机制使得程序能够动态地获取类的信息并执行相关操作，这在处理未知类型的数据或者实现通用代码时非常有用。数组反射是...
Java反射根据不同方法名动态调用不同的方法(实例)
09-01
一旦我们获取到了`Method`对象，就可以通过`invoke()`方法来调用它。`invoke()`方法的第一个参数是调用该方法的对象，第二个参数是传递给方法的参数（在这个例子中，getter方法不需要参数，所以我们传递了一个空的`...
Java的反射机制---动态调用对象的简单方法
09-01
在本文中，我们将深入探讨如何使用反射来动态调用对象的简单方法。 首先，让我们了解Java反射机制的主要功能： 1. **运行时获取类信息**：在运行时，可以获取任意类的所有属性（字段）和方法，包括私有（private）...
通过java反射机制动态调用某方法的总结(推荐)
09-01
Java反射机制是Java语言提供的一种强大功能，允许程序在运行时检查类的信息并动态地调用类的方法。这种机制使得程序具有很高的灵活性和扩展性，特别是在框架开发、插件系统和元编程等场景中有着广泛的应用。下面我们...
java反射拼接方法名动态执行方法实例
09-01
Java反射机制是Java语言提供的一种强大的工具，它允许运行中的Java程序对自身进行检查并且可以直接操作程序的内部属性。在上述实例中，我们看到如何利用反射动态地拼接方法名并执行相应的方法，从而避免了大量的if-...
java利用反射创建数组_使用反射在Java中创建，填充和显示数组
weixin_39754915的博客
03-02 492
使用java.lang.reflect.Array.newInstance()方法创建一个数组。此方法基本上会创建一个具有所需组件类型和长度的新数组。使用java.lang.reflect.Array.setInt()方法填充数组。此方法在为数组指定的索引处设置所需的整数值。使用for循环显示的数组。演示此的程序如下所示-示例importjava.lang.reflect.Array;publi...
Java中的反射的作用以及详解
m0_72568404的博客
07-17 2751
java反射的作用以及详解
java反射-获取类的Class对象方式
一起coding，一起嗨。
10-12 1077
获取的Class对象hashCode都是一样的，Class对象是单例。
Java反射之创建对象的四种方式
热门推荐
shijinjins的博客
04-25 1万+
Java反射之创建对象的四中方式，反射的优点和缺点。
反射创建对象的3种方式
m0_59000898的博客
07-30 516
【代码】反射创建对象的3种方式。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值