Java 反射机制详解:入门、使用、实例

Java反射机制:从入门到实战 Java 反射机制是 Java 语言中一项强大的特性,它允许程序在运行时动态地获取类的信息、操作对象、调用方法、访问字段等。反射机制在动态加载类、框架开发、单元测试、注解处理、动态代理、序列化和反序列化等场景中有着广泛的应用。尽管反射机制提供了极大的灵活性,但也带来了性能开销和安全性问题。因此,在使用反射时应权衡利弊,遵循最佳实践,避免滥用反射,确保代码的性能和安全性。 阅读详情

反射概述

什么是反射

将类的各个组成部分封装为其他对象的过程就叫做 反射,其中 组成部分 指的是我们类的 成员变量(Field)、构造方法(Constructor)、成员方法(Method)。

使用反射的优缺点

  • 优点

    1. 在 程序运行过程中 可以操作类对象,增加了程序的灵活性;
    2. 解耦,从而提高程序的可扩展性,提高代码的复用率,方便外部调用;
    3. 对于任何一个类,当知道它的类名后,就能够知道这个类的所有属性和方法;而对于任何一个对象,都能够调用它的一个任意方法。
  • 缺点

    1. 性能问题:Java 反射中包含了一些动态类型,JVM 无法对这些动态代码进行优化,因此通过反射来操作的方式要比正常操作效率更低。
    2. 安全问题:使用反射时要求程序必须在一个没有安全限制的环境中运行,如果程序有安全限制,就不能使用反射。
    3. 程序健壮性:反射允许代码执行一些平常不被允许的操作,破坏了程序结构的抽象性,导致平台发生变化时抽象的逻辑结构无法被识别。

Class 对象的获取及使用

获取 Class 对象的方式

  1. Class.forName("全类名")

源代码阶段,它能将字节码文件加载进内存中,然后返回 Class 对象,多用于 配置文件 中,将类名定义在配置文件中,通过读取配置文件来加载类。

  1. 类名.class

类对象阶段,通过类名的 class 属性来获取,多用于 参数的传递。

  1. 对象.getClass()

运行时阶段,getClass() 定义在 Object 类中,表明所有类都能使用该方法,多用于 对象的获取字节码 的方式。

我们首先定义一个 Person 类,用于后续反射功能的测试;

package com.cunyu;

/**
 * @author : cunyu
 * @version : 1.0
 * @className : Person
 * @date : 2021/4/7 22:37
 * @description : Person 类
 */

public class Person {
    private int age;
    private String name;
    public long id;
    public long grade;
    protected float score;
    protected int rank;


    public Person(int age, String name, long id, long grade, float score, int rank) {
        this.age = age;
        this.name = name;
        this.id = id;
        this.grade = grade;
        this.score = score;
        this.rank = rank;
    }

    public Person() {
    }

    public int getAge() {
        return age;
    }

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

    public String getName() {
        return name;
    }

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

    public long getId() {
        return id;
    }

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

    public long getGrade() {
        return grade;
    }

    public void setGrade(long grade) {
        this.grade = grade;
    }

    public float getScore() {
        return score;
    }

    public void setScore(float score) {
        this.score = score;
    }

    public int getRank() {
        return rank;
    }

    public void setRank(int rank) {
        this.rank = rank;
    }

    @Override
    public String toString() {
        final StringBuffer sb = new StringBuffer("Person{");
        sb.append("age=").append(age);
        sb.append(", name='").append(name).append('\'');
        sb.append(", id=").append(id);
        sb.append(", grade=").append(grade);
        sb.append(", score=").append(score);
        sb.append(", rank=").append(rank);
        sb.append('}');
        return sb.toString();
    }
}

定义好 Person 类之后,我们尝试用 3 种不同的方式来获取 Class 对象,并比较它们是否相同。

package com.cunyu;

/**
 * @author : cunyu
 * @version : 1.0
 * @className : Demo1
 * @date : 2021/4/7 23:29
 * @description : Class 对象的获取
 */

public class Demo1 {
    public static void main(String[] args) throws ClassNotFoundException {
//        第一种方式,Class.forName("全类名")
        Class class1 = Class.forName("com.cunyu.Person");
        System.out.println(class1);

//        第二种方式,类名.class
        Class class2 = Person.class;
        System.out.println(class2);

//        第三种方式,对象.getName()
        Person person = new Person();
        Class class3 = person.getClass();
        System.out.println(class3);

//        比较三个对象是否相同
        System.out.println(class1 == class2);
        System.out.println(class1 == class3);
    }
}

上述代码中,会发现最后输出的比较结果返回的是两个 true,说明通过上述三种方式获取的 Class 对象都是同一个,同一个字节码文件(*.class)在一次运行过程中只会被加载一次。

Class 对象的使用

获取成员变量
方法说明
Field[] getFields()返回包含一个数组 Field对象反射由此表示的类或接口的所有可访问的公共字段类对象
Field getField(String name)返回一个 Field对象,它反映此表示的类或接口的指定公共成员字段类对象
Field[] getDeclaredFields()返回的数组 Field对象反映此表示的类或接口声明的所有字段类对象
Field getDeclaredField(String name)返回一个 Field对象,它反映此表示的类或接口的指定已声明字段类对象
  • Field[] getFields()
package com.cunyu;

import java.lang.reflect.Field;

/**
 * @author : cunyu
 * @version : 1.0
 * @className : Demo2
 * @date : 2021/4/7 23:39
 * @description : Class 对象的使用
 */

public class Demo2 {
    public static void main(String[] args) throws ClassNotFoundException {
        Class class1 = Class.forName("com.cunyu.Person");

        Field[] fields = class1.getFields();
        for (Field field : fields) {
            System.out.println(field);
        }

    }
}

回顾下我们的 Person 类,可以发现 id、grade 成员变量都是被 public 所修饰的,说明该方法是用于获取类中所有被 public 所修饰的成员变量(包括父类)。

  • Field getField(String name)
package com.cunyu;

import java.lang.reflect.Field;

/**
 * @author : cunyu
 * @version : 1.0
 * @className : Demo2
 * @date : 2021/4/7 23:39
 * @description : Class 对象的使用
 */

public class Demo2 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException {
        Class class1 = Class.forName("com.cunyu.Person");

        Field field1 = class1.getField("id");
        System.out.println(field1);
        Field field2 = class1.getField("age");
        System.out.println(field2);
        Field field3 = class1.getField("rank");
        System.out.println(field3);

    }
}

从上面的结果分析可知,该方法只能用于获取类中指定名称的 public 所修饰的成员变量,对于 protected、private 所修饰的成员变量,该方法是无法获取的(包括父类)。而获取或设置成员变量值时,可以通过 get/set 方法来操作,具体操作方法如下。

// 假设我们获取到的 Field 为上面的 id,获取和设置 id 的值就可以通过如下操作来进行
// 1. 获取
Field idField = personClass.getField("id");
Person person = new Person();
Object idValue = idField.get(person);
System.out.println("id:" + idValue);
// 2. 设置
idField.set(person, "1312120");
System.out.println("person:" + person);
  • Field[] getDeclaredFields()
package com.cunyu;

import java.lang.reflect.Field;

/**
 * @author : cunyu
 * @version : 1.0
 * @className : Demo2
 * @date : 2021/4/7 23:39
 * @description : Class 对象的使用
 */

public class Demo2 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException {
        Class class1 = Class.forName("com.cunyu.Person");

        Field[] fields = class1.getDeclaredFields();
        for (Field field : fields) {
            System.out.println(field);
        }
    }
}

观察上面的结果可知,该方法可用于获取所有的成员变量,不用考虑修饰符的限制(不包括父类)。

  • Field getDeclaredField(String name)
package com.cunyu;

import java.lang.reflect.Field;

/**
 * @author : cunyu
 * @version : 1.0
 * @className : Demo2
 * @date : 2021/4/7 23:39
 * @description : Class 对象的使用
 */

public class Demo2 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException {
        Class class1 = Class.forName("com.cunyu.Person");

        Field field1 = class1.getDeclaredField("id");
        System.out.println(field1);
        Field field3 = class1.getDeclaredField("rank");
        System.out.println(field3);
        Field field2 = class1.getDeclaredField("age");
        System.out.println(field2);
    }
}

观察上面的结果可知,该方法可用于获取指定的成员变量,不用考虑成员变量修饰符的限制(不包括父类)。但是在利用 set、get 方法来获取和设置 private、protected 修饰的成员变量时,需要利用 setAccessible() 来忽略访问全新啊修饰符的安全检查,否则程序将会报错。

获取构造方法
方法说明
Constructor<?>[] getConstructors()返回包含一个数组 Constructor对象反射由此表示的类的所有公共构造类对象
Constructor<T> getConstructor(类<?>... parameterTypes)返回一个 Constructor 对象,该对象反映 Constructor对象表示的类的指定的公共类函数
Constructor<?>[] getDeclaredConstructors()返回一个反映 Constructor 对象表示的类声明的所有 Constructor 对象的数组类
Constructor<T> getDeclaredConstructor(类<?>... parameterTypes)返回一个 Constructor 对象,该对象反映 Constructor 对象表示的类或接口的指定类函数
package com.cunyu;

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;

/**
 * @author : cunyu
 * @version : 1.0
 * @className : Demo3
 * @date : 2021/4/8 13:28
 * @description : 构造对象获取
 */

public class Demo3 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        Class personClass = Class.forName("com.cunyu.Person");

//        1. 获取所有构造方法
        System.out.println("所有构造方法");
        Constructor[] constructors = personClass.getConstructors();
        for (Constructor constructor : constructors) {
            System.out.println(constructor);
        }

//        2. 获取指定构造方法

//        空参构造方法
        System.out.println("空参构造方法");
        Constructor constructor1 = personClass.getConstructor();
        System.out.println(constructor1);
//        带参构造方法
        System.out.println("带参构造方法");
        Constructor constructor2 = personClass.getConstructor(int.class, String.class, long.class, long.class, float.class, int.class);
        System.out.println(constructor2);

//        获取构造方法后,可以利用它来创建对象
        System.out.println("空参创建对象");
//        第一种方法
        Object person = constructor1.newInstance();
        System.out.println(person);
//        第二种方法
        Object person1 = personClass.newInstance();
        System.out.println(person1);

        System.out.println("带参创建对象");
        Object object = constructor2.newInstance(20, "村雨遥", 1312020, 3, 99.0F, 2);
        System.out.println(object);
    }
}

  • Constructor<?>[] getConstructors()

    类似于通过 Class 实例来获取成员变量,该方法用于获取所有 public 所修饰的构造方法(包括父类);

  • Constructor<T> getConstructor(类<?>... parameterTypes)

该方法用于获取某一指定参数类型后的 public 所修饰的构造方法(包括父类);

  • Constructor<?>[] getDeclaredConstructors()

该方法用于获取所有 public 所修饰的构造方法(不包括父类);

  • Constructor<T> getDeclaredConstructor(类<?>... parameterTypes)

该方法用于获取某一指定参数类型后的 public 所修饰的构造方法(不包括父类);

而获取到构造方法之后,我们就可以利用 newInstance() 方法来创建类的实例。特殊的,如果我们的构造方法是无参的,此时则可以直接利用 Class.newInstance() 来构造实例。

获取成员方法
方法说明
Method[] getMethods()返回包含一个数组 方法对象反射由此表示的类或接口的所有公共方法 类对象,包括那些由类或接口和那些从超类和超接口继承的声明
Method getMethod(String name, 类<?>... parameterTypes)返回一个方法对象,它反映此表示的类或接口的指定公共成员方法 类对象
Method[] getDeclaredMethods()返回包含一个数组方法对象反射的类或接口的所有声明的方法,通过此表示 类对象,包括公共,保护,默认(包)访问和私有方法,但不包括继承的方法
Method getDeclaredMethod(String name, 类<?>... parameterTypes)返回一个方法对象,它反映此表示的类或接口的指定声明的方法类对象
package com.cunyu;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

/**
 * @author : cunyu
 * @version : 1.0
 * @className : Demo4
 * @date : 2021/4/8 13:51
 * @description : 成员方法获取
 */

public class Demo4 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, IllegalAccessException {
        Class personClass = Class.forName("com.cunyu.Person");

//        获取所有 public 成员方法
        System.out.println("获取所有成员方法");
        Method[] methods = personClass.getMethods();
        for (Method method : methods) {
            System.out.println(method);
        }

//        获取指定名称的方法
        System.out.println("获取指定名称的方法");
        Method getAgeMethod = personClass.getMethod("getAge");
        System.out.println(getAgeMethod);

//        执行方法
        Person person = new Person(20, "村雨遥", 1312020, 3, 99.0F, 2);
        int age = (int) getAgeMethod.invoke(person);
        System.out.println(age);

    }
}

  • Method[] getMethods()

用于获取当前类的所有 public 所修饰的成员方法(包括父类)。

  • Method getMethod(String name, 类<?>... parameterTypes)

用于获取当前类的某一个指定名称 public 所修饰的成员方法(包括父类)。

  • Method[] getDeclaredMethods()

用于获取当前类的所有 public 所修饰的成员方法(不包括父类)。

  • Method getDeclaredMethod(String name, 类<?>... parameterTypes)

用于获取当前类的某一个指定名称 public 所修饰的成员方法(不包括父类)。

而当我们获取到类的成员方法后,如果要执行某一个方法,可以使用 invoke() 方法来执行该方法。

获取类名
package com.cunyu;

/**
 * @author : cunyu
 * @version : 1.0
 * @className : Demo5
 * @date : 2021/4/8 14:06
 * @description : 获取类名
 */

public class Demo5 {
    public static void main(String[] args) throws ClassNotFoundException {
        Person person = new Person();
        Class personClass = person.getClass();

        String className = personClass.getName();
        System.out.println(className);
    }
}

  • String getName()

从上述程序的结果可知,当我们获取到 Class 对象之后,如果不知道类的全名,就可以使用 getName() 来获取该类的全名。

反射实例

假设我们有如下需求:在不改变类的代码的前提下,我们能够创建任意类的对象,并执行其中的方法。

此时,我们可以通过 配置文件 + 反射 的方式来实现这一效果,而这也就是我们现在所用框架中的基础,当我们使用反射后,只需要通过修改配置文件中的内容就能够不用去改代码就实现对应的功能。

假设我们有两个类,一个 Student,一个 Teacher,两者的定义如下;

package com.cunyu;

/**
 * @author : cunyu
 * @version : 1.0
 * @className : Teacher
 * @date : 2021/4/8 15:15
 * @description : 教师类
 */

public class Teacher {
    private String name;
    private int age;

    public void teach() {
        System.out.println("教书育人……");
    }
}
package com.cunyu;

/**
 * @author : cunyu
 * @version : 1.0
 * @className : Student
 * @date : 2021/4/8 15:16
 * @description : 学生类
 */

public class Student {
    private String name;
    private float score;

    public void study() {
        System.out.println("好好学习,天天向上……");
    }
}

要实现我们的需求,通常需要如下步骤:

  1. 将要创建对象的全类名和要执行的方法都配置在配置文件中;

定义的配置文件 prop.properties ,其中主要内容包括 className 和 methodName 两个属性,分别代表类的全类名和要调用方法的名字。一个具体实例如下,分别代表名为 Student 的类和名为 study 的方法。

className=com.cunyu.Student
methodName=study
  1. 然后在主方法中加载读取配置文件;
//        创建配置文件对象
Properties properties = new Properties();
//        加载配置文件
ClassLoader classLoader = ReflectTest.class.getClassLoader();
InputStream inputStream = classLoader.getResourceAsStream("prop.properties");
properties.load(inputStream);

//        获取配置文件中定义的数据
String className = properties.getProperty("className");
String methodName = properties.getProperty("methodName");
  1. 利用反射技术将类加载到内存中;
//        加载进内存
Class name = Class.forName(className);
  1. 接着利用 newInstance() 方法创建对象;
//        创建实例
Object object = name.newInstance();
  1. 最后则是利用 invoke() 方法来执行方法;
//        获取并执行方法
Method method = name.getMethod(methodName);
method.invoke(object);

将整个流程汇总起来就是:

package com.cunyu;

import java.io.IOException;
import java.io.InputStream;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.Properties;

/**
 * @author : cunyu
 * @version : 1.0
 * @className : ReflectTest
 * @date : 2021/4/8 15:27
 * @description : 测试
 */

public class ReflectTest {
    public static void main(String[] args) throws IOException, ClassNotFoundException, IllegalAccessException, InstantiationException, InvocationTargetException, NoSuchMethodException {
//        创建配置文件对象
        Properties properties = new Properties();
//        加载配置文件
        ClassLoader classLoader = ReflectTest.class.getClassLoader();
        InputStream inputStream = classLoader.getResourceAsStream("prop.properties");
        properties.load(inputStream);

//        获取配置文件中定义的数据
        String className = properties.getProperty("className");
        String methodName = properties.getProperty("methodName");

//        加载进内存
        Class name = Class.forName(className);

//        创建实例
        Object object = name.newInstance();

//        获取并执行方法
        Method method = name.getMethod(methodName);
        method.invoke(object);
    }
}

此时,我们只需要改动配置文件 prop.properties 中的配置即可输出不同结果;

总结

好了,感谢耐心看到这里的各位。如果您觉得本文对您有所帮助,那就给我点个赞吧!

最后,对于文中知识点有错误或欠缺的地方,还请大家见谅,欢迎大家评论留言给我指正~

Java新手入门200例119之Java反射机制得到类的包名和类名 文章目录作者简介引言导航热门专栏推荐小结导航热门专栏推荐 作者简介 作者名:编程界明世隐 简介:优快云博客专家,从事软件开发多年,精通Java、JavaScript,博主也是从零开始一步步把学习成长、深知学习和积累的重要性,喜欢跟广大ADC一起打野升级,欢迎您关注,期待与您一起学习、成长、起飞! 引言 很多Java初学者问我,新手明明很用心、很努力学习的Java知识,转头又忘记了,很让人犯愁,小白如何能够快速成长、成为大牛呢? 其实要成为大神的技巧只有一个:“多学多练”,于是明哥就整理了比较典型的练习 阅读详情

相关推荐

Python RPA 流程自动化快速上手

Python RPA 流程自动化快速上手

看花容易绣花难 1万+

反射机制

反射机制 反射机制是什么 1.反射机制是在运行状态中,对于任意一个类,都能够知道这个类的所有属性和方法; 2.对于任意一个对象,都能够调用它的任意一个方法和属性; 3.这种动态获取的信息以及动态调用对象的方法的功能就是反射机制; 4.也就是说通过反射机制,我们可以获取想要获取到的东西,对前面所学到的范围限定词的限制就可以打破约束 反射机制的作用 1.在运行时判断任意一个对象所属的类; 2.在运行时构造任意一个类的对象; 3.在运行时判断任意一个类所具有的成员变量和方法; 4.在运行时调用任意一个对象的方法;

qq_45874107的博客 1万+

【论文阅读】2021-(Pidinet)Pixel Difference Networks for Efficient Edge Detection

文章目录摘要1. Introduction 摘要 motivations: 基于CNN的边缘检测的高性能是通过一个大的预训练CNN主干来实现的,该主干占用大量内存和能量。传统边缘检测器(如Canny、Sobel和LBP)很少被研究。 contributions: 提出了一种简单、轻量级但有效的架构,称为像素差分网络(PiDiNet),用于有效的边缘检测。PiDiNet采用了新颖的像素差卷积,将传统的边缘检测算子集成到现代CNN中流行的卷积运算中,以增强任务性能。 experiments: 在BSDS500

轻舟的万重重山 1万+

反射机制详解(重点).

一、反射机制概述 反射机制 1.1、反射机制有什么用? 通过java语言中的反射机制可以操作字节码文件。 优点类似于黑客。(可以读和修改字节码文件。) 通过反射机制可以操作代码片段。( class文件。) 1.2、反射机制的相关类在哪个包下? java.lang.reflect.*; 1.3、反射机制相关的重要的类有哪些? java.lang.class; 代表整个字节码,代表一个类型,代表整个类 java.lang.reflect.Method; 代表字节码中...

lwj_07的博客 4763

eDP/DP接口简介

目前,在视频传输协议以及接口领域,外部接口主要是DP与HDMI两分天下,当然之前出现过很多接口-VGA, DVI等等,最新平台基本以这两个为主;笔记本内部接口就基本上使用eDP((Embedded Display Port))作为标准接口来驱动液晶屏了。那么问题来了,eDP和DP,是完全兼容的么?eDP,DP,HDMI,这三种接口的显示器,可以插在同一个接口上使用么?这篇文章,就会从硬件和一部分协议的角度分析一下这三大协议。

weixin_50518899的博客 2万+

【架构师面试-缓存与搜索-1】-缓存与缓存置换策略源码实现

1:什么是缓存 缓存:加速数据访问的存储,降低延迟(latency),提升吞吐量(Throughput)的利器。 1:缓存演进历史 1. 查库 2. ConcurrentHashMap 3. LRU 4. Guava Cache 5. 分布式缓存(redis,MemCache) 6. 多级缓存 2:在什么地方加缓存 缓存对于每个开发者来说是相当熟悉了,为了提高程序的性能我们会去加缓存,但是在什么地方加缓存,如何加缓存呢? 举个栗子:假设一个网站,需要提高性能,缓存可以放在浏览器,可以放

chongfa2008的博客 6443

Java基础篇:反射机制详解

版权声明:本文为博主原创文章,遵循 CC 4.0 BY-SA 版权协议,转载请附上原文出处链接和本声明。 本文链接:https://blog.youkuaiyun.com/a745233700/article/details/82893076 一、什么是反射: (1)Java反射机制的核心是在程序运行时动态加载类并获取类的详细信息,从而操作类或对象的属性和方法。本质是JVM得到class对象之后,再通过class对象进行反编译,从而获取t对象的各种信息。 (2)Java属于先编译再运行的语言,程序中对象的类型在编译期就

weixin_45438577的博客 610

Abaqus仿真进阶:如何准确计算气动软体机器人的抓取力(Blocking Force分析)

本文详细介绍了使用Abaqus进行气动软体机器人抓取力(Blocking Force)分析的进阶技巧。从材料模型验证、刚性目标物选择到接触对建立和充气加载优化,提供了一套完整的有限元仿真解决方案,帮助工程师准确预测软体执行器的抓取性能。

weixin_42528902的博客 403

JAVA中的反射机制

反射,当时经常听他们说,自己也看过一些资料,也可能在设计模式中使用过,但是感觉对它没有一个较深入的了解,这次重新学习了一下,感觉还行吧!            一,先看一下反射的概念:                主要是指程序可以访问,检测和修改它本身状态或行为的一种能力,并能根据自身行为的状态和结果,调整或修改应用所描述行为的状态和相关的语义。               反

学会改变自己——才能突破 44万+

小龙虾们的好伙伴专栏导航

本文系统解析了OpenClaw技术架构,包括Channel层和网关层的设计实现,并与AgentSkills等技术方案进行对比。同时提供了OpenClaw的系列实用指南,涵盖小龙虾培养、客户资源管理、系统自动化巡检以及技术趋势助手构建等应用场景,帮助用户从零成本入门到高效落地应用,实现业务全流程自动化管理。

wend的博客 216

基于Simulink的异步电机参数在线辨识与自适应控制仿真

本文基于Simulink平台,详细介绍了异步电机参数在线辨识与自适应控制系统的仿真实现。针对异步电机运行中参数时变问题,采用模型参考自适应系统(MRAS)实时辨识转子电阻和互感,并结合自适应PI控制策略动态调整控制器参数。通过搭建完整的矢量控制(FOC)仿真模型,验证了系统在稳态辨识、参数摄动和动态响应等工况下的性能:参数辨识误差<1.2%,转速跟踪误差<20rpm,动态响应时间<10ms。文章还提供了详细的Simulink建模步骤、核心代码实现及性能分析,为高级电机控制系统的设计与优化提

amy_mhd的博客 74

简述反射机制

反射机制 一:反射机制: 反射机制,是java中十分常用的重要特性。 运用反射机制,可以动态的调用某一个对象的特定方法,或读取任意一个JavaBean(公共类)的所有属性,进行赋值等操作。 二:反射的应用 反射可以访问 - - 构造方法,方法,成员变量 1.访问前需要获取Class对象: 获取Class对象的三种方法: 代码 1. 通过Object类的getClass()方法...

唔得够 2392

4.1 AI Agent对比分析:Coze、Dify、LangGraph,如何选择Agent框架

本文对比分析了三大主流AI Agent框架:Coze(字节跳动平台,可视化开发,适合快速企业应用)、Dify(开源企业级方案,支持定制部署)和LangGraph(代码开发灵活,适合复杂需求)。选择指南建议:需要快速开发选Coze,需开源定制选Dify,复杂灵活需求选LangGraph。核心要点包括理解各框架特点、根据需求评估选择,并提供了实践建议。下节将介绍Coze平台的实战应用。

yonggeit的博客 3151

java的反射机制入门

理解Java的反射机制对学习Java框架有很大帮助,比如Spring框架的核心就是使用Java反射实现的,同时对做一些Java底层操作也会有帮助,比如字节码操作、自定义注解等。 什么是反射 Java反射说的是在运行状态中,对于任何一个类,我们都能够直到这个类有哪些方法和属性。对于任何一个对象,我们都能够对它的方法和属性进行调用。这种动态获取对象信息和调用对象方法的功能就是Java的反...

weixin_30391339的博客 103

温度PID控制PLC程序

温度PID稳定控制程序,适用于欧姆龙PLC,对其他PLC也具有很大参考价值

Statistics and Machine Learning Toolbox

Statistics and Machine Learning Toolbox(带书签),MATLAB统计学习工具

Java 反射机制入门

认识反射机制 Java反射机制的核心是在程序运行时动态加载类并获取类的详细信息,从而操作类或对象的属性和方法。本质是java虚拟机得到class对象之后,再通过该class对象进行反编译,从而获取对象的各种信息。 Java属于先编译再运行的语言,程序中对象的类型在编译期就确定下来了,而当程序在运行时可能需要动态加载某些类,这些类因为之前用不到,所以没有被加载到java虚拟机。通过反射,可以在运行时动态地创建对象并调用其属性,不需要提前在编译期知道运行的对象是谁。 优点: 反射提高了程序的灵活性和扩展性,降低

一夜星尘 1万+

Data-Structures-and-Algorithm-Analysis-in-Java.pdf

作者: Weiss, Mark A. 出版社: Addison Wesley Data Structures and Algorithm Analysis in Java is an “advanced algorithms” book that fits between traditional CS2 and Algorithms Analysis courses. In the old ACM Curriculum Guidelines, this course was known as CS7. This text is for readers who want to learn good programming and algorithm analysis skills simultaneously so that they can develop such programs with the maximum amo...

java的反射机制(从入门到使用)

目录 一、反射的概述 二、查看Class类在java中的api详解(1.7的API) 三、反射的使用 反射的方法汇总: 1、获取Class对象的三种方式 2、通过反射获取构造方法并使用 3、获取成员变量并调用 4、获取成员方法并调用 5、反射main方法 6、反射方法的其它使用之—通过反射越过泛型检查 7、反射方法的其它使用之二利用反射读取配置文件 一、反射的概述 ...

方才coding 1603

jdk-8u144-linux-x64.tar.gz.

该资源为搭建Linux系统Java环境用,资源的后缀为tar.gz格式的压缩包

Java基础重点——反射机制入门、使用

如何定义反射:一句话定义反射就是在运行时才知道要操作的类是什么,并且可以在运行时获取类的完整构造,并调用对应的方法,所谓反射其实是获取类的字节码文件,也就是.class文件 如何理解反射:平时我们要调用某个类中的方法的时候都需要创建该类的对象,通过对象去调用类里面的方法,反射则是一开始并不知道我要初始化的类对象是什么,自然也无法使用 new 关键字来创建对象了,在这种情况下(没有创建对象)我们都能...

宜春 5785

Java 入门指南:反射机制

反射机制是指在运行时动态地获取类的信息并操作类和对象的方法和属性。它是一种 Java 语言的特性,可以让程序在运行时获取类的信息,包括类型、属性、方法等,并且可以在运行时动态地创建对象、调用对象的方法、修改属性等。

热带鱼的技术博客 1335

Java 反射机制详解(快速入门)

Java反射机制详解 本文系统介绍了Java反射机制的核心概念与应用。反射是Java提供的一种运行时动态分析类结构并操作对象的强大机制,在框架开发中具有重要作用。文章详细讲解了反射的五大核心类(Class、Field、Method、Constructor、Modifier)及其使用方法,包括获取类信息、成员变量、构造方法和成员方法的具体API操作。同时提供了获取Class对象的三种方式,并通过代码示例展示了如何利用反射动态创建对象、访问私有成员和调用方法。最后指出反射是理解Spring等框架底层实现的基础,

2403_82614686的博客 948

Java中反射机制入门

1.反射机制的作用:通过java语言中的反射机制可以直接操作字节码文件(读、改),直接操作代码片段class文件,注意字节码文件都是保存在方法区的,只有一个。 反射机制所在的包:java.lang.reflect.* 反射机制的相关重要类: ①java.lang.Class:代表字节码文件,即一个类型,整个类。 ②java.lang.reflect.Method:代表字节码中的方法字节码,即类中的方法。 ③java.lang.reflec...

xxyneymar的博客 219

Java反射机制入门

1.反射机制介绍 1.1编译期是指把源码交给编译器编译成计算机可以执行的文件的过程。在 Java 中也就是把 Java 代码编成 class 文件的过程。编译期只是做了一些翻译功能,并没有把代码放在内存中运行起来,而只是把代码当成文本进行操作,比如检查错误。 1.2运行期是,直把编译后的文件交给计算机执行到程序运行结束。所谓运行期就把在磁盘中的代码放到内存中执行起来。 1.3Java 反射机制是在运行状态中,对于任意一个类,都能够知道这个类的所有属性和方法;对于任意一个对象,都能够调用它的任意方法

weixin_44862178的博客 127

Java 反射机制详解:入门、使用

将类的各个组成部分封装为其他对象的过程就叫做反射,其中组成部分指的是我们类的成员变量(Field)构造方法(Constructor)成员方法(Method)。

2401_83703835的博客 1066

Java新手入门:反射机制详解——从获取类信息到动态调用方法

反射机制是Java中的一个强大又有点“神奇”的特性。这个机制允许我们在运行时获取类的各种信息,并且能动态地调用类的方法。听起来很神奇吧?别急,接下来我会尽量用通俗易懂的语言,结合案例和使用场景,带大家一步步走进反射的世界。好了,今天关于Java反射机制的分享就到这里了。希望大家通过这篇文章,能够对反射机制有一个初步的了解,并能够在实际开发中灵活运用。当然,反射机制还有很多深入的内容等待大家去探索和学习。如果你对这方面感兴趣,不妨多查阅一些相关资料,相信通过不断的学习和实践,你一定能够掌握这个强大的工具!

Jz_Stu的博客 2097

一、JAVA反射机制--入门篇详解

目录 一、JAVA反射机制基本概念 二、获取Class对象的三种方式 三、三种方式代码实例 四、基础语法--获取类方法及调用 1、基本语法 2、有无参构造函数调用及使用 3、公共、私有、保护函数的获取及调用 一、JAVA反射机制基本概念 反射:动态获取类中信息,动态调用其方法,相当于对类的剖析。 通过反射机制+配置文件,可以提高应用程序的扩展性。毕竟面对配置文件比...

lanshan1111的博客 344

Java 反射机制全解:从入门到实践

Java 反射机制是指程序在运行时动态获取类的信息,并且能够对类的属性、方法、构造器等进行操作的能力。通俗来说,就是“运行时查看和修改类的能力反射是 Java 提供的一组 API,位于包中,配合Class获取类的字段、方法、构造函数等元信息;动态创建对象;动态调用方法;操作属性值(包括私有属性)。优点缺点灵活、强大,适合框架底层性能差、类型不安全可以突破访问限制可读性差,易出错支持运行时动态操作类依赖字符串,不利于重构建议:在业务层代码中谨慎使用反射;在底层框架中合理利用反射。

子冉冰清的博客 689
上一篇: Java 版学生成绩管理系统,附源码
下一篇: 【Java 从入坑到放弃】No 3. 变量与数据类型
村雨遥
村雨遥 优质创作者: Java技术领域 优质创作者: Java技术领域 领域专家: 算法与数据结构技术领域 领域专家: 算法与数据结构技术领域
博客等级 码龄9年 2万+粉丝 372原创
评论 2
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

村雨遥

众筹一毛买键盘!

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值