反射还可以这样学？

最新推荐文章于 2024-11-13 20:43:20 发布
最新推荐文章于 2024-11-13 20:43:20 发布
阅读量219 收藏
点赞数
分类专栏： 反射 文章标签： java 反射
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42870497/article/details/118338948
版权

反射

概念

将类的各个组成部分封装为其他对象，这就是反射机制。

java反射是可以让我们在运行时，通过类的class对象动态获取类的属性、方法等内部信息的机制

java代码在计算机中的经过三个阶段

  • 第一个阶段：.java文件经过编译之后变成.class文件。也称源代码阶段
  • 第二个阶段：类加载器加载.class文件到内存中。也称class类对象阶段
  • 第三个阶段：创建对象。也称运行时阶段

在这里插入图片描述

反射实现借助的四个类

Class:类的对象
Constructor:类的构造方法
Field:类中的属性对象
Method:类中的方法对象

原理

java语言经过编译之后会生成一个.class对象，反射就是通过字节码文件找到某一个类、类中的方法以及属性等。

好处

1、可以在程序的运行过程中操作对象

2、可以解耦，提高程序的可扩展性

获取Class对象的方式

  1. Class.forName(“全类名”)：将字节码文件加载进内存，返回Class对象（对应第一阶段，Source源代码阶段）
  2. 类名.class：通过类名的属性class获取（对应第二阶段，Class类对象阶段）
  3. 对象.getClass()：getClass()方法在Object对象中定义着（对应第三阶段，Runtime运行时阶段）
  • 结论：同一个字节码文件（*.class）在一次程序运行过程中，只会被加载一次。即无论通过哪一种方式获取的class对象都是同一个

Class对象的功能

获取功能

  1. 获取成员变量们
    • Field[] getFields()：获取所有public修饰的成员变量
    • Field getField(Stringname)：获取指定的public修饰的成员变量
    • Field[] getDeclaredFields()：获取所有的成员变量。不考虑修饰符
    • Field getDeclaredField(String name)：获取指定的成员变量
  2. 获取构造方法们
    • Constructor<?>[] getConstructors()：获取所有public修饰的构造方法
    • Constructor getConstructor(类<?>… parameterTypes)：获取指定的public修饰的构造方法
    • Constructor<?>[] getDeclaredConstructors()：获取所有的构造方法。不考虑修饰符
    • Constructor getDeclaredConstructor(类<?>… parameterTypes)：获取指定的构造方法
  3. 获取成员方法们
    • Method[] getMethods()：获取所有public修饰的成员方法
    • Method getMethod(String name, 类<?>… parameterTypes)：获取指定的public修饰的成员方法
    • Method[] getDeclaredMethods()：获取所有的成员方法。不考虑修饰符
    • Method getDeclaredMethod(String name, 类<?>… parameterTypes)：获取指定的成员方法
  4. 获取类名
    • String getName()

Field对象的常用方法

  • 设置值：void set(Object obj, Object value)
  • 获取值：Object get(Object obj)
  • 忽略访问权限修饰的安全检查：setAccessible(true)

Constructor对象的常用方法

  • 创建对象：T newInstance(Object… initargs)
  • 如果使用空参构造方法创建对象，操作可以简化：Class对象的newInstance方法

Method对象的常用方法

  • 执行方法：Object invoke(Object obj, Object… args)
  • 获取方法名称：String getName()

代码示例

Person类对象

package com.reflect;

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

    public String a;
    protected String b;
    String c;
    private String d;


    public Person() {
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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

    public void eat(){
        System.out.println("吃东西。。。");
    }

    public void eat(String food){
        System.out.println("吃东西。。。"+food);
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", a='" + a + '\'' +
                ", b='" + b + '\'' +
                ", c='" + c + '\'' +
                ", d='" + d + '\'' +
                '}';
    }
}

Class对象创建的三种方式

package com.reflect;


public class ReflectDemo01 {
    /*
    获取class对象的三种方式：
    1. Class.forName("全类名")：将字节码文件加载进内存，返回Class对象（对应第一阶段，Source源代码阶段）
    2. 类名.class：通过类名的属性class获取（对应第二阶段，Class类对象阶段）
    3. 对象.getClass()：getClass()方法在Object对象中定义着（对应第三阶段，Runtime运行时阶段）
     */
    public static void main(String[] args) throws Exception {
        //1. Class.forName("全类名")：将字节码文件加载进内存，返回Class对象（对应第一阶段，Source源代码阶段）
        Class cla1 = Class.forName("com.reflect.Person");
        System.out.println(cla1);

        //2. 类名.class：通过类名的属性class获取（对应第二阶段，Class类对象阶段）
        Class cla2 = Person.class;
        System.out.println(cla2);

        //3. 对象.getClass()：getClass()方法在Object对象中定义着（对应第三阶段，Runtime运行时阶段）
        Person p = new Person("Chocolate",24);
        Class cla3 = p.getClass();
        System.out.println(cla3);

        //结论：同一个字节码文件（*.class）在一次程序运行过程中，只会被加载一次。即无论通过哪一种方式获取的class对象都是同一个
        System.out.println(cla1==cla2);//true
        System.out.println(cla1==cla3);//true

    }
}

获取成员变量、成员方法、构造方法以及分别调用各自的方法

package com.reflect;

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

public class ReflectDemo02 {

    public static void main(String[] args) throws Exception {
        //获取成员变量
        //demo01();
        
        //获取构造方法
        //demo02();
        
        //获取成员方法
        demo03();
    }

    private static void demo03() throws Exception {
        /*
         * Method[]  getMethods()：获取所有public修饰的成员方法
         * Method getMethod(String name, 类<?>... parameterTypes)：获取指定的public修饰的成员方法
         * Method[]  getDeclaredMethods()：获取所有的成员方法。不考虑修饰符
         * Method getDeclaredMethod(String name, 类<?>... parameterTypes)：获取指定的成员方法
         */
        Class cla = Class.forName("com.reflect.Person");
        //Method[]  getMethods()：获取所有public修饰的成员方法
        Method[] methods = cla.getMethods();
        for (Method m:methods){
            System.out.println(m);
        }
        System.out.println("==============================");
        //Method getMethod(String name, 类<?>... parameterTypes)：获取指定的public修饰的成员方法
        Person p = new Person();
        Method eat = cla.getMethod("eat");
        Method eat1 = cla.getMethod("eat", String.class);
        System.out.println(eat);
        System.out.println(eat1);
        //执行方法
        eat.invoke(p);
        eat1.invoke(p,"饭");
        System.out.println("============================");
        //获取方法名
        System.out.println(eat.getName());
        System.out.println("============================");
        //获取类名
        System.out.println(cla.getName());

    }

    private static void demo02() throws Exception {
        /*
           * Constructor<?>[] getConstructors()：获取所有public修饰的构造方法
           * Constructor<T> getConstructor(类<?>... parameterTypes)：获取指定的public修饰的构造方法
           * Constructor<?>[] getDeclaredConstructors()：获取所有的构造方法。不考虑修饰符
           * Constructor<T> getDeclaredConstructor(类<?>... parameterTypes)：获取指定的构造方法
         */
        Class cla = Class.forName("com.reflect.Person");
        Constructor[] constructors = cla.getConstructors();
        for (Constructor c:constructors){
            System.out.println(c);
        }
        System.out.println("==========================");
        //获取指定的构造器
        Constructor cons = cla.getConstructor(String.class,int.class);
        System.out.println(cons);
        System.out.println("============================");
        //由构造器创建对象
        //创建对象：T   newInstance(Object... initargs)
        Object obj = cons.newInstance("科比", 24);
        System.out.println(obj);
        System.out.println("==========================");
        //如果使用空参构造方法创建对象，操作可以简化：Class对象的newInstance方法
        Object obj2 = cla.newInstance();
        System.out.println(obj2);
    }

    private static void demo01() throws Exception {
        /*
         * Field[]  getFields()：获取所有public修饰的成员变量
         * Field  getField(Stringname)：获取指定的public修饰的成员变量
         * Field[]  getDeclaredFields()：获取所有的成员变量。不考虑修饰符
         * Field  getDeclaredField(String name)：获取指定的成员变量
         */
        Class cla = Class.forName("com.reflect.Person");
        //getFields()：获取所有public修饰的成员变量
        Field[] f1 = cla.getFields();
        for (Field f:f1){
            System.out.println(f);
        }
        System.out.println("===========================");
        //getDeclaredFields()：获取所有的成员变量。不考虑修饰符
        Field[] f2 = cla.getDeclaredFields();
        for (Field f:f2){
            System.out.println(f);
        }
        System.out.println("===============================");
        //getField(Stringname)：获取指定的public修饰的成员变量
        //获取某个成员变量，并对其进行赋值
        /*
        Field：成员变量
            * 设置值：void 	set(Object obj, Object value)
            * 获取值：Object    get(Object obj)
            * 忽略访问权限修饰的安全检查：setAccessible(true)
         */
        Person p = new Person();
        Field a = cla.getField("a");
        a.set(p,"我是a");
        Object o = a.get(p);
        System.out.println(o);
        System.out.println(p);


    }
}
小Leetcode~
关注
专栏目录
Java学习之反射机制
01-20
虽然在这样的定义下java不是动态语言，但java的反射机制（Reflection）却是可实现动态的相关机制。java反射机制的作用有 　1、在运行时判断任意一个类所具有的成员变量和方法 　2、在运行时构造任意一个类的对象 ...
C#反射实例学习及注意内容
01-01
那么这样可以使用反射动态创建类型的实例，将类型绑定到现有对象，或从现有对象获取类型并调用其方法或访问其字段和属性。如果代码中使用了属性，可以利用反射对它们进行访问。 MSDN描述： 反射通常具有以下用途： ...
Java 学习之反射机制及应用场景
01-20
以下是自己使用反射的两个地方，感兴趣的同学可以看下：Android okHttp网络请求之Json解析，Android业务组件化之子模块SubModule的拆分以及它们之间的路由Router实现。 　什么是Java反射机制？ 　JAVA反射机制是在...
学习使用Go反射的用法示例
12-23
当需要一个类型、变量或者是函数时，可以直接定义它们： type Foo struct { A int B string } var x Foo func DoSomething(f Foo) { fmt.Println(f.A, f.B) }   但是有时你希望在运行时使用变量的在编写程序时还不...
Servlet的生命周期
最新发布
wyk的博客
11-13 968
Servlet 的生命周期包含四个主要阶段：加载与实例化、初始化、请求处理、销毁。开发者可以在这些生命周期方法中编写初始化、请求处理和资源清理的代码，确保 Web 应用程序的正常运行。
日常bug记录，easyexcel导入报错convert data ... to class java.math.BigDecimal error
mm
11-11 274
排查发现实体类中有BigDecimal属性，然而数据中这个属性为null，进行转换时报错。在实体类上加上自定义转换器。解决方法：自定义转换器类。
Java基础07
m0_74977981的博客
11-11 677
如图下图：每个case中都有一个break，如果没有这个break，就不会跳出case，直到遇见break为止。
1112--接口
kequanrrr的博客
11-12 382
interface + 接口名{ }。。。。implements 接口名{ }接口：接口中的抽象方法可以省略 abstract 关键字使用：要实现接口中的所有 抽象方法隐含三个修饰符：public+static+final2.单继承 多接口。
SpringBoot(五)
₍˄·͈༝·͈˄*₎◞ ̑̑的博客
11-13 712
Rest请求处理
刷题---顺序表算法题
weixin_63997543的博客
11-11 432
顺序算法题----力扣刷题
JAVA学习接口案例实例
shangan_3的博客
11-08 239
【代码】JAVA学习接口案例实例。
Java基于小程序公考学习平台的设计与实现（附源码，文档）
chusheng1840的博客
11-09 1307
Java基于小程序公考学习平台的设计与实现，小程序公考学习平台使用Java语言进行编码，使用Mysql创建数据表保存本系统产生的数据。系统可以提供信息显示和相应服务，其管理小程序公考学习平台信息，查看小程序公考学习平台信息，管理小程序公考学习平台。总之，小程序公考学习平台集中管理信息，有着保密性强，效率高，存储空间大，成本低等诸多优点。它可以降低信息管理成本，实现信息管理计算机化。关键词：小程序公考学习平台；Java语言；Mysql。
深入理解Java的类加载与卸载机制
Luffy的博客
11-12 1058
类加载是指JVM将.class文件中的二进制数据读入内存中，经过一系列验证、解析和初始化，最终在JVM中生成可以被使用的Class对象。JVM会为每个类加载并生成一个唯一的Class对象，这个对象封装了类的所有信息，包括方法、属性等。类加载的三大步骤：1.加载（Loading）：从不同的源（如文件、网络）获取类的二进制字节码，并生成Class对象。2.链接（Linking）：对类的二进制进行校验和解析，确保类文件格式正确。验证（Verification）：检查字节码是否符合JVM的规范。
ArkTS--应用状态
qq_63946637的博客
11-10 640
本文旨在帮助大家学习鸿蒙中的LocalStorage和AppStorage
JavaScript 高阶总结
qq_43787947的博客
11-11 895
JavaScript 高级总结
C++接口类， 抽象类和实体类简述
Joshua的专栏
11-09 338
在C++中，接口类通常是指只包含纯虚函数（pure virtual functions）的类。接口类的主要目的是定义一组通用的行为，但不提供任何具体的实现。通过上述示例可以看出，C++通过抽象类和多重继承实现了类似Java中的单一实体继承和多接口继承的效果。在C++中，虽然没有像Java那样明确的“接口”关键字，但可以通过抽象类和纯虚函数来实现接口的概念。实体类是指可以实例化的类，即类中所有的函数都有具体的实现，包括继承自抽象类的纯虚函数。单实体继承（多接口继承）的设计理念和好处。类继承和接口继承的比较。
@ComponentScan注解引发外部请求无法处理的解决办法
Kwoky的博客
11-12 911
@ComponentScan注解引发外部请求无法处理的解决办法
MQ的实际使用
2201_75397629的博客
11-12 686
在这一篇文章当中我会以RcoketMQ来对其的使用的场景进行一个仔细地说明,这个里面也会涉及到一些额外的知识,看完之后对面试而言的话那么就是直接拿捏,当然在看这篇文章之前要先看MQ的基础知识-CSDN博客毕竟基础才是王道,下面就是开始我们的正菜。
深入理解反射机制：Java学习资料及作用
反射的概念是由 Smith 在 1982 年首次提出的，主要是指程序可以访问、检测和修改它本身状态或行为的一种能力，通过反射可以调用私有方法和私有属性，大部分框架也都是运用反射原理的。java 通常是先有类再有对象，有...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值