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

原创 已于 2025-09-30 08:10:08 修改 · 1.6k 阅读 · 5 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
标签
#java #反射
于 2021-07-15 01:24:43 首次发布
本文详细介绍了Java反射如何访问私有字段、修改对象状态、创建对象、调用不同类型的公开和私有方法，包括可变参数方法，并展示了完整源代码实例。通过反射，开发者可以在运行时动态操作对象，深入理解反射机制的应用。

文章目录

  假设已有下面的类：

  • 示例类：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 异常，也可以抛出自己想抛出的异常。或者做其它事情。
    }
}

反射识别重载方法

反射获取一个类的每个方法的重载个数

/**
 * 获取一个类的每个方法的重载个数
 *
 * @return HashMap<方法名, 该方法的重载个数>
 * @since 2024-10-11
 */
public static Map<String, Integer> getMethodOverloadCount(Class<?> clazz) {
    Map<String, Integer> methodCountMap = new HashMap<>();
    Method[] methods = clazz.getMethods();
    for (Method method : methods) {
        String methodName = method.getName();
        methodCountMap.put(methodName, methodCountMap.getOrDefault(methodName, 0) + 1);
    }
    return methodCountMap;
}

反射获取一个类每个方法的方法名和方法签名

/**
 * 获取一个类每个方法的方法名和其所有的方法签名。对于重载方法，这会将每个重载方法都列出来
 *
 * @return HashMap<方法名, 该方法的所有重载方法的方法签名>
 * @since 2024-10-11
 */
public static Map<String, List<String>> getMethodSignatures(Class<?> clazz) {
    Map<String, List<String>> methodSignaturesMap = new HashMap<>();
    Method[] methods = clazz.getMethods();
    for (Method method : methods) {
        String methodName = method.getName();
        String methodSignature = generateMethodSignature(methodName, method.getParameterTypes());
        methodSignaturesMap.computeIfAbsent(methodName, k -> new ArrayList<>()).add(methodSignature);
    }
    return methodSignaturesMap;
}

/**
 * 生成一个重载方法的方法签名字符串
 *
 * @since 2024-10-11
 */
private static String generateMethodSignature(String methodName, Class<?>[] parameterTypes) {
    StringBuilder signature = new StringBuilder();
    signature.append(methodName).append("(");
    String params = Arrays.stream(parameterTypes)
            .map(Class::getSimpleName)
            .reduce((a, b) -> a + ", " + b)
            .orElse("");
    signature.append(params).append(")");
    return signature.toString();
}

反射打印一个类每个方法的方法名和方法签名

/**
 * 打印一个类每个方法的方法名和方法签名。对于重载方法，这会将每个重载方法都打印出来
 *
 * @since 2024-10-11
 */
public static void printMethodSignatures(Class<?> clazz) {
    Method[] methods = clazz.getMethods();
    for (Method method : methods) {
        String methodName = method.getName();
        Class<?>[] parameterTypes = method.getParameterTypes();
        System.out.println("方法名: " + methodName + ", 方法签名: " + generateMethodSignature(methodName, parameterTypes));
    }
}

/**
 * 生成一个重载方法的方法签名字符串
 *
 * @since 2024-10-11
 */
private static String generateMethodSignature(String methodName, Class<?>[] parameterTypes) {
    StringBuilder signature = new StringBuilder();
    signature.append(methodName).append("(");
    boolean seen = false;
    String acc = null;
    for (Class<?> parameterType : parameterTypes) {
        String simpleName = parameterType.getSimpleName();
        if (!seen) {
            seen = true;
            acc = simpleName;
        } else {
            acc = acc + ", " + simpleName;
        }
    }
    String params = seen ? acc : "";
    signature.append(params).append(")");
    return signature.toString();
}

完整源代码

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

【檀越剑指大厂--反射】反射总结
CSDN站内信: https://i.csdn.net/#/msg/chat/qyj19920704
08-13 8728
💝💝💝欢迎来到我的博客，很高兴能够在这里和您见面！希望您在这里可以感受到一份轻松愉快的氛围，不仅可以获得有趣的内容和知识，也可以畅所欲言、分享您的想法和见解。非常期待和您一起在这个小小的网络世界里共同探索、学习和成长。💝💝💝 ✨✨ 欢迎订阅本专栏 ✨✨。
基于LoRA与vLLM的大模型微调与高效部署实战指南
最新发布
weixin_30753873的博客
05-11 670
大语言模型（LLM）的微调是让通用模型适应特定领域任务的关键技术。其核心原理是通过在预训练模型的基础上，使用领域数据进行有监督训练，从而调整模型参数，使其掌握新的知识或技能。为了在有限的计算资源下实现高效微调，参数高效微调（PEFT）技术应运而生，其中LoRA（低秩适应）通过引入可训练的低秩矩阵来近似全参数更新，大幅降低了显存和计算开销。结合QLoRA等量化技术，使得在消费级GPU上微调超大规模模型成为可能，其技术价值在于显著降低了领域模型定制化的门槛和成本。在应用场景上，微调后的模型需通过高性能推理引擎进
Java中反射机制详解
asdfgha14的博客
05-27 1521
解释：需要明白servlet的生命周期，也就是service方法，因为是servlet，所以在访问的时候，会经过service方法，而子类MyServlet001中并没有，所以就到父类BaseServlet中找，发现有，然后获取参数即知道了需要调用什么方法，因为方法的编写都在子类中，所以通过反射，获取到子类中对应的方法并运行，其中需要注意的是this这个参数在BaseServlet中的用法。注意newProxyInstance的三个参数，第一个，类加载器，第二个被代理对象的接口，第三个代理对象。
Java~反射机制、获取Class的三种方式、利用反射获取字段、方法、创建对象
zxc的博客
05-15 4243
文章目录反射机制获取Class的三种方式利用反射实例化对象Class.forName方法反射获取Field反编译Field利用反射访问类字段插入知识点：可变长参数使用反射机制来调用方法使用反射创建对象 反射机制 反射机制有什么用？ 通过Java语言中的反射机制可以操作字节码文件 有点类似于黑客，可以读和修改字节码文件 通过反射机制可以操作代码片段（ class文件） 反射机制的相关类在哪个包下？ java.lang.reflect.*; 反射机制相关的类有哪些？ java.lang.Class
反射创建对象_反射
weixin_39612332的博客
12-08 586
在Java中一切皆对象，其实所有的类底层都有一个字节码对象，可以使用反射来描述着一个个类底层的字节码对象。在运行时期，动态地去获取类中的信息（类的信息，方法的信息，构造方法的信息，字段等信息）。一个类中，包括构造方法，字段，方法。Class：描述类Method：描述方法Constructor：描述构造方法Field：描述字段获取类的Class实例三种方式1.类名.class2.类的对象.getCl...
如何通过反射创建对象
星空
11-09 3896
通过反射创建对象的两种方法： 通过Class字节码对象newInstance();（默认通过无参构造创建） 通过获取构造器getConstructor(Class<?>…parameterTypes);（通过有参的构造器，参数可以指定具体类型和多个数量） 代码： 假设我们有一个用户类User package test.java.zxj.test_project; pub...
网易云课堂java 反射_反射——反射API,使用反射创建数组
weixin_30516429的博客
02-27 239
反射APIJava.lang.Reflect库① Class类与Java.lang.Reflect类库一起对反射的概念进行支持。② java.lang包下：a) Class：表示对一个正在运行的Java应用程序中的类和接口，是Reflection的起源。③ java.lang.reflect包下：a) Field类：代表类的成员变量(成员变量也称类的属性...
反射(反射的介绍、获取源头Class、创建对象、属性和方法)
姓程名序种族猿
08-15 479
一、1. 反射的介绍 1.反射的定义 JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意方法和属性；这种动态获取信息以及动态调用对象方法的功能称为java语言的反射机制。 Java反射机制，可以实现以下功能： ①在运行时判断任意一个对象所属的类； ②在运行时构造任意一个类的对象； ③在运行时判断任意一个类所具有的成员变量和方法； ④在运行时调用任意一个对象的方法； ⑤生成动态代理； 二、获取源头Class(重点) 所有类的对象其实都是Cla
反射机制总结 - Java
Clearlight's Blog
09-07 496
文章目录一、反射的作用二、反射的用法2.1 类2.1.1 修饰符2. 1.2 类名2.1.3 继承的父类2.1.3 实现的接口2.1.4 包信息2.2 变量2.2.1 特定变量2.2.2 变量类型和变量名2.3 构造器2.3.1 获取Constructor对象以及对象的参数列表2.3.2 利用Constructor对象实例化一个类2.4 方法2.4.1 获取类中所有方法2.4.2 调用指定方法2....
[Java] - 非Java核心技术卷I笔记 - 反射（八）
呐呐呐呐呐的博客
07-11 1000
反射 来源 https://www.jianshu.com/p/9be58ee20dee 定义 JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意方法和属性；这种动态获取信息以及动态调用对象方法的功能称为java语言的反射机制。 反射机制的相关类 类名 用途 Class类 代表类的实体，在运行的Java应用程序中表示类和接口 Field类 代表类的成员变量（成员变量也称为类的属性） Method类 代表类的方法
JAVA反射机制创建对象的三种方式
weixin_36873225的博客
11-04 1895
1.获取其中方法和参数并在控制台打印。JAVA反射机制创建对象的三种方式。2.激活对象中的方法。
【Java】反射获取类对象、构造器对象、成员变量对象、成员方法对象的方式
m0_64210833的博客
03-27 3950
反射第一步 获取Class类对象，这样才能获取类中的所有属性、行为...; 获取Class类的三种方式 方式一：Class c1 = 类名.class； 方式二：Class c2 = 对象名.getClass age去调用set方法喊对象s去进行赋值（反射） 以前是s，setage（18）主动去赋值 关系反转（age调用get方法喊s对象获取年龄） 注解的作用 元注解：注解注解的注解 ...
java利用反射创建数组_使用反射在Java中创建，填充和显示数组
weixin_39754915的博客
03-02 602
使用java.lang.reflect.Array.newInstance()方法创建一个数组。此方法基本上会创建一个具有所需组件类型和长度的新数组。使用java.lang.reflect.Array.setInt()方法填充数组。此方法在为数组指定的索引处设置所需的整数值。使用for循环显示的数组。演示此的程序如下所示-示例importjava.lang.reflect.Array;publi...
Java反射之创建对象的四种方式
热门推荐
shijinjins的博客
04-25 1万+
Java反射之创建对象的四中方式，反射的优点和缺点。
Java中的反射的作用以及详解
m0_72568404的博客
07-17 3108
java反射的作用以及详解
java反射-获取类的Class对象方式
一起coding，一起嗨。
10-12 1284
获取的Class对象hashCode都是一样的，Class对象是单例。
反射创建对象的3种方式
m0_59000898的博客
07-30 729
【代码】反射创建对象的3种方式。
使用反射创建数组
LiuXiaoXueer的博客
08-05 1123
使用反射可以动态地创建数组 java.lang.reflect包中Array类允许动态地创建数组，其中，newInstance方法可以创建与原数组类型相同的新数组。在调用newInstance方法时，需要传入两个参数，一个是数组的元素类型， 一个是数组的长度。 Object newArray == Array.newInstance(ComponentType, newLength); import java.lang.reflect.Array; import java.util.Arrays; pu
通过反射创建对象
weixin_46031071的博客
07-13 2259
上面我们已经看完调用postProcessMergedBeanDefinition方法，接着我们继续往下走，调用findResourceMetadata，其实这个方法和findLifecycleMetadata方法类似，只是处理的对象不一样，上面是针对Lifecycle，接下来是针对Resource的。可以看到，在这里面做了设置转换服务注册值处理器。在这里做这些操作的原因是：我们在配置文件中设置的值都是string类型的，但这个值不一定是string类型的，所以对设置的值需要进行类型转换等处理操作。
【Java】面试常问知识点（Java基础）
weixin_46601559的博客
05-01 2082
JMM就是Java内存模型(java memory model)。因为在不同的硬件生产商和不同的操作系统下，内存的访问有一定的差异，所以会造成相同的代码运行在不同的系统上会出现各种问题。所以java内存模型(JMM)屏蔽掉各种硬件和操作系统的内存访问差异，以实现让java程序在各种平台下都能达到一致的并发效果。Java内存模型规定所有的变量都存储在主内存中，包括实例变量，静态变量，但是不包括局部变量和方法参数。每个线程都有自己的工作内存，
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值