Java基础---反射

最新推荐文章于 2024-10-06 20:16:20 发布
最新推荐文章于 2024-10-06 20:16:20 发布
阅读量1k 收藏 13
点赞数 31
文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jlihan/article/details/141863646
版权

目录

反射

1.反射是什么？

2.为什么会有反射？ 

3.反射是如何工作的？

4.进入第二阶段的三种方案

 5.获取变量信息

6.获取方法信息 

7.获取构造器信息 

 8.获取构造器，然后使用

9.获取方法，然后调用 

 10.获取变量，并赋值

 11.测试题

前言

反射（Reflection）是Java编程语言中的一种强大机制，它允许程序在运行时检查或修改类的行为。通过使用反射，程序可以访问类的内部属性和方法，即使这些属性和方法是在编译时未知的。

反射

1.反射是什么？

 反射是一种获取类信息的能力

类信息包括：方法、变量、接口、父类、构造器、类名....

2.为什么会有反射？ 

 需要获取类信息

3.反射是如何工作的？

程序运行有三个阶段：磁盘阶段、类对象阶段、运行时阶段

想要反射获取类信息就必须进入第二阶段：类对象阶段

4.进入第二阶段的三种方案

在磁盘阶段：Class.forName("全类名")        全类名：包名加类名

在类对象阶段：类名.class

在运行时阶段：对象名.getClass()

 示例：

package 反射;

public class Student {
    private String name="张三";
    public Integer age=18;
    Character sex='男';
    protected Double height =170.0;
}


package 反射;

public class Test {
    public static void main(String[] args) throws Exception{
        //想要获取类信息就必须进入类对象阶段
        Class class1=Class.forName("反射.Student");

        Class class2=Student.class;

        Student student=new Student();
        Class class3=student.getClass();

        System.out.println(class1==class2);
        System.out.println(class2==class3);

    }
}

输出结果为：

true

true 

 ==比较的是指向的地址是否相同，说明class1，class2，class3全指向了同一区域，方法区中

同一个对象，会在方法区里面留下同一个类对象  

 5.获取变量信息

 获取全部的全局变量信息 getDeclaredFields()

 获取public修饰的全局变量信息 getFields()

 获取指定的全局变量信息 getDeclaredField()

 获取指定的public修饰的全局变量信息 getField()

package 反射;

public class Student {
    private String name="张三";
    public Integer age=18;
    Character sex='男';
    protected Double height =170.0;
    public String color = "蓝色";
}

package 反射;

import java.lang.reflect.Field;
import java.util.Arrays;

public class Test {
    public static void main(String[] args) throws Exception {
        //想要获取类信息就必须进入类对象阶段
        Class class1 = Class.forName("反射.Student");
        //获取全部的全局变量信息，并且打印
        Field[] fields = class1.getDeclaredFields();
        System.out.println(Arrays.toString(fields));

        //获取public修饰的全局变量信息，并且打印
        Field[] fields1 = class1.getFields();
        System.out.println(Arrays.toString(fields1));
        System.out.println("-----------------");

        //获取指定的全局变量信息并且打印
        Field nameField = class1.getDeclaredField("name");
        System.out.println(nameField);
        Field heightField = class1.getDeclaredField("height");
        System.out.println(heightField);
        Field ageField = class1.getDeclaredField("age");
        System.out.println(ageField);
        System.out.println(".........................");

        //获取指定的public修饰的全局变量信息并且打印
//        Field nameField1 = class1.getField("name");//此行代码报错 因为name为private访问修饰符修饰而非public修饰
//        System.out.println(nameField1);
//        Field heightField1 = class1.getField("height");//此行代码报错 因为height为protected访问修饰符修饰而非public修饰
//        System.out.println(heightField1);
        Field ageField1 = class1.getField("age");
        System.out.println(ageField1);
        System.out.println("//");
    }
}

 输出结果为：

[private java.lang.String 反射.Student.name, public java.lang.Integer 反射.Student.age, java.lang.Character 反射.Student.sex, protected java.lang.Double 反射.Student.height, public java.lang.String 反射.Student.color]
[public java.lang.Integer 反射.Student.age, public java.lang.String 反射.Student.color]
-----------------
private java.lang.String 反射.Student.name
protected java.lang.Double 反射.Student.height
public java.lang.Integer 反射.Student.age
.........................
public java.lang.Integer 反射.Student.age
//

6.获取方法信息 

获取所有方法的信息 getDeclaredMethods()

获取public修饰的所有的方法的信息 getMethods()

获取指定的方法信息 getDeclaredMethod()

获取指定的，且是public的方法信息 getMethod()

package 反射;

public class Student {
    private String name="张三";
    public Integer age=18;
    Character sex='男';
    protected Double height=170.0;
    public String color = "蓝色";

    public void run(){}

    private int getAge(int age){
        return age;
    }
    
    void aaa(String name,Integer height){
        
    }
    
    protected void haha(String name,int age){
        
    }
}
package 反射;

import java.lang.reflect.Method;
import java.util.Arrays;

public class Test {
    public static void main(String[] args) throws Exception {
        //想要获取类信息就必须进入类对象阶段
        Class class1 = Class.forName("反射.Student");

        //获取所有方法的信息
        Method[] declaredMethods = class1.getDeclaredMethods();
        System.out.println(Arrays.toString(declaredMethods));

        //获取public修饰的所有的方法的信息
        Method[] methods = class1.getMethods();
        System.out.println(Arrays.toString(methods));

        //获取指定的方法
        Method getAge = class1.getDeclaredMethod("getAge", int.class);//要把参数写上
        Method aaa = class1.getDeclaredMethod("aaa", String.class, Integer.class);
        Method run = class1.getDeclaredMethod("run");
        Method hhh = class1.getDeclaredMethod("haha" ,String.class,int.class);
        System.out.println(hhh);
        System.out.println(run);
        System.out.println(aaa);
        System.out.println(getAge);

        //获取指定的，且是public的方法
        Method run1 = class1.getMethod("run");
        System.out.println(run1);
    }
}

输出结果为：

7.获取构造器信息 

 获取所有构造器的信息 getDeclaredConstructors()

获取所有pubulic修饰的构造器的信息 getConstructors()

获取指定构造器的信息 getDeclaredConstructor()

获取指定且被public修饰的构造器的信息 getConstructor()

package 反射;

public class Student {
    private String name="张三";
    public Integer age=18;
    Character sex='男';
    protected Double height=170.0;
    public String color = "蓝色";

    public void run(){}

    private int getAge(int age){
        return age;
    }

    void aaa(String name,Integer height){

    }

    protected void haha(String name,int age){

    }

    public Student() {
    }

    public Student(String name, Integer age) {
        this.name = name;
        this.age = age;
    }

    public Student(String name, Integer age, Character sex, Double height, String color) {
        this.name = name;
        this.age = age;
        this.sex = sex;
        this.height = height;
        this.color = color;
    }

}
package 反射;

import java.lang.reflect.Constructor;
import java.util.Arrays;

public class Test {
    public static void main(String[] args) throws Exception {
        //想要获取类信息就必须进入类对象阶段
        Class class1 = Class.forName("反射.Student");

        //获取所有构造器的信息
        Constructor[] declaredConstructors = class1.getDeclaredConstructors();
        System.out.println(Arrays.toString(declaredConstructors));
        //获取所有pubulic修饰的构造器的信息
        Constructor[] constructors = class1.getConstructors();
        System.out.println(Arrays.toString(constructors));
        //获取指定构造器的信息
        Constructor declaredConstructor = class1.getDeclaredConstructor();
        System.out.println(declaredConstructor);
        Constructor declaredConstructor1 = class1.getDeclaredConstructor(String.class, Integer.class);
        System.out.println(declaredConstructor1);
        Constructor declaredConstructor2 = class1.getDeclaredConstructor(String.class, Integer.class, Character.class, Double.class, String.class);
        System.out.println(declaredConstructor2);
        //获取指定且被public修饰的构造器的信息
        Constructor constructor = class1.getConstructor();
        System.out.println(constructor);
        Constructor constructor1 = class1.getConstructor(String.class, Integer.class);
        System.out.println(constructor1);
        Constructor constructor2 = class1.getConstructor(String.class, Integer.class, Character.class, Double.class, String.class);
        System.out.println(constructor2);


    }
}

 输出的结果为：

 8.获取构造器，然后使用

package 反射;

public class Student {
    private String name="张三";
    public Integer age=18;
    Character sex='男';
    protected Double height=170.0;
    public String color = "蓝色";

    public void run(){}

    private int getAge(int age){
        return age;
    }

    void aaa(String name,Integer height){

    }

    protected void haha(String name,int age){

    }
    //私有的构造器
    private Student() {
    }

    public Student(String name, Integer age) {
        this.name = name;
        this.age = age;
    }

    public Student(String name, Integer age, Character sex, Double height, String color) {
        this.name = name;
        this.age = age;
        this.sex = sex;
        this.height = height;
        this.color = color;
    }

}
package 反射;

import java.lang.reflect.Constructor;

public class Test {
    public static void main(String[] args) throws Exception {
        //想要获取类信息就必须进入类对象阶段
        Class class1 = Class.forName("反射.Student");
        //获取指定构造器的信息
        Constructor declaredConstructor = class1.getDeclaredConstructor(String.class, Integer.class);
        //创建对象
        Student student1 = (Student) declaredConstructor.newInstance("aaa",18);//需要使Object类型强转为Student类型

        Constructor declaredConstructor1 = class1.getDeclaredConstructor();
        //private修饰的数据，想要使用就必须暴力反射
        declaredConstructor1.setAccessible(true);
        Student student2 = (Student) declaredConstructor1.newInstance();
    }
}

9.获取方法，然后调用 

package 反射;

public class Student {
    private String name="张三";
    public Integer age=18;
    Character sex='男';
    protected Double height=170.0;
    public String color = "蓝色";

    public void run(){
        System.out.println("这是run()");
    }

    private int getAge(int age){
        System.out.println("这是age()");
        return age;
    }

    void aaa(String name,Integer height){
        System.out.println("这是aaa()");
    }

    protected void haha(String name,int age){
        System.out.println("这是haha()");
    }

    private Student() {
    }

    public Student(String name, Integer age) {
        this.name = name;
        this.age = age;
    }

    public Student(String name, Integer age, Character sex, Double height, String color) {
        this.name = name;
        this.age = age;
        this.sex = sex;
        this.height = height;
        this.color = color;
    }

}
package 反射;

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

public class Test {
    public static void main(String[] args) throws Exception{
        //想要获取类信息就必须进入类对象阶段
        Class class1 = Class.forName("反射.Student");
        //获取构造器的类信息
        Constructor declaredConstructor = class1.getDeclaredConstructor(String.class, Integer.class);
        //创建对象
        Student student1=(Student)declaredConstructor.newInstance("aaa",18);//给构造器传入数据
        //需要使Object类型强转为Student类型


        Method run = class1.getDeclaredMethod("run");//获取指定的run()方法
        Object invoke = run.invoke(student1);
        //invoke()中传对象和给方法的参数，这里使用的是run()一个无参方法，所以只写对象
        //传对象的原因，方法要想使用就必须在内存中开辟空间

        Method getAge = class1.getDeclaredMethod("getAge", int.class);//获取指定的getAge()方法
        getAge.setAccessible(true);//暴力反射 getAge是private修饰的
        getAge.invoke(student1,18);//传对象，传参数

        Method aaa=class1.getDeclaredMethod("aaa",String.class,Integer.class);
        aaa.invoke(student1,"admin",199);

        Method haha=class1.getDeclaredMethod("haha",String.class,int.class);
        haha.invoke(student1,"admin",99);

    }
}

输出结果为：

这是run()
这是getAge()
这是aaa()
这是haha() 

 10.获取变量，并赋值

package 反射;

public class Student {
    private String name="张三";
    public Integer age=18;
    Character sex='男';
    protected Double height=170.0;
    public String color = "蓝色";
}
package 反射;

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

public class Test {
    public static void main(String[] args) throws Exception {
        //想要获取类信息就必须进入类对象阶段
        Class class1 = Class.forName("反射.Student");
        //获取构造器的类信息
        Constructor declaredConstructor = class1.getDeclaredConstructor(String.class, Integer.class);
        //创建对象
        Student student1=(Student)declaredConstructor.newInstance("aaa",18);//给构造器传入数据
        //需要使Object类型强转为Student类型

        Field name = class1.getDeclaredField("name");//指定获取变量name的信息
        //暴力反射
        name.setAccessible(true);
        name.set(student1,"admin");//赋值
        System.out.println(name.get(student1));

        Field age = class1.getDeclaredField("age");
        age.set(student1,88);
        System.out.println(age.get(student1));

        Field sex = class1.getDeclaredField("sex");
        sex.set(student1,'女');
        System.out.println(sex.get(student1));

        Field height = class1.getDeclaredField("height");
        height.set(student1,175.5);
        System.out.println(height.get(student1));
    }
}

输出结果为：

admin
88
女
175.5 

 11.测试题

Student类 

获取该类的构造方法来构造对象，获取该类的名称和该类中每一个变量的名称和方法的名称，并执行相关方法，给每一个变量赋值，并获取值，执行每一个构造方法，执行相应的方法 

package 反射test;
//获取该类的构造方法来构造对象，获取该类的名称和该类中每一个变量的名称和方法的名称，并执行相关方法，给每一个变量赋值，并获取值，执行每一个构造方法，执行相应的方法
public class Student {
    private String name;
    private int age;
    private String address;
    public Student(String name,int age,String address){
        this.address = address;
        this.age = age;
        this.name = name;
    }
    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 String getAddress(){
        return address;
    }
    public void setAddress(String address){
        this.address = address;
    }
}

Test类

package 反射test;

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

public class Test {
    public static void main(String[] args) throws Exception {
        Class class1 = Class.forName("反射test.Student");
        //执行构造方法
        Constructor declaredConstructor = class1.getDeclaredConstructor(String.class, int.class, String.class);
        //创建对象
        Student student1 = (Student) declaredConstructor.newInstance("保定", 23, "li");
        //获取类名
        String className = class1.getSimpleName();
        System.out.println(className);
        System.out.println("-------------------");
        //获取所有变量名
        Field[] declaredFields = class1.getDeclaredFields();
        for (Field declaredField : declaredFields) {
            System.out.println(declaredField.getName());
        }
        System.out.println("+++++++++++++++++++");
        //获取所有的方法名
        Method[] declaredMethods = class1.getDeclaredMethods();
        for (Method declaredMethod : declaredMethods) {
            System.out.println(declaredMethod.getName());
        }
        System.out.println("````````````````````");
        //给每一个变量赋值
        Field name = class1.getDeclaredField("name");
        name.setAccessible(true);
        name.set(student1,"zhangsan");
        System.out.println(name.get(student1));

        Field age = class1.getDeclaredField("age");
        age.setAccessible(true);
        age.set(student1,27);
        System.out.println(age.get(student1));

        Field address = class1.getDeclaredField("address");
        address.setAccessible(true);
        address.set(student1,"河北");
        System.out.println(address.get(student1));
        System.out.println("~~~~~~~~~~~~~~~~~~~~~");

        //执行每一个方法
        Method setName = class1.getDeclaredMethod("setName", String.class);
        setName.invoke(student1,"li");
        Method setAge = class1.getDeclaredMethod("setAge", int.class);
        setAge.invoke(student1,32);
        Method setAddress = class1.getDeclaredMethod("setAddress", String.class);
        setAddress.invoke(student1,"北京");
        Method getName = class1.getDeclaredMethod("getName");
        System.out.println(getName.invoke(student1));
        Method getAge = class1.getDeclaredMethod("getAge");
        System.out.println(getAge.invoke(student1));
        Method getAddress = class1.getDeclaredMethod("getAddress");
        System.out.println(getAddress.invoke(student1));

 输出结果为：

Student
-------------------
name
age
address
+++++++++++++++++++
getAddress
getName
setName
setAge
getAge
setAddress
````````````````````
zhangsan
27
河北
~~~~~~~~~~~~~~~~~~~~~
li
32
北京

lihan_freak
关注
Java基础[08-反射].ppt
12-09
JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。...
Java基础-注解和反射
09-11
### Java基础-注解和反射 #### 注解(Annotation) 从JDK5开始，Java引入了一个重要的特性——元数据支持，即注解。这是一项强大的功能，它允许开发者在不改变原有代码逻辑的情况下向源代码中添加额外的信息。注解在...
大学课程讲义-Java基础-反射.pptx
08-14
Java基础-反射机制详解 本文将详细介绍Java基础中的反射机制，包括Class类、ClassLoader类、Constructor、Method、Field类的用法，以及动态代理机制。 Class类 Class类是Java中一个特殊的类，用于描述类本身的...
java基础教程----精华版
09-22
这个"java基础教程----精华版"显然是一份精心整理的资料，旨在帮助初学者快速掌握Java编程的基础知识。下面将详细介绍Java语言的核心概念和关键知识点。 1. **Java语法基础**： - **变量**：在Java中，变量是存储...
JAVA基础-尚硅谷课件资料
02-21
【Java基础-尚硅谷课件资料】是一套全面讲解Java编程语言的学习资源，适用于初学者和进阶者。课程内容涵盖了从Java语言的基础概念到高级特性的深入理解，旨在帮助学习者掌握Java开发的核心技能。 在Java编程语言的...
JDK1.0主要特性
最新发布
FoolRabbit的专栏
10-06 243
JDK1.0主要特性。
JavaScript ArrayBuffer的读写与类型转换
白瑕 的博客
10-01 471
所有视图的基本单位是ArrayBuffer, ArrayBuffer中只存储二进制格式的数据.ArrayBuffer不可直接读写, 必须通过视图(比如DataView)暴露的API.
java将word转pdf
紫月7575的博客
09-30 569
java将word转pdf
spring-boot 整合 mybatis
m0_72168501的博客
09-29 570
spring boot 整合 mybatis
Java内存布局
阿呆的专栏
10-01 817
64位 JVM 不启用指针压缩时：Object Header 大小是16字节。64位 JVM 启用指针压缩时（默认）：Object Header 大小是12字节。32位 JVM：Object Header 大小是8字节。JVM在默认情况下启用指针压缩，但如果堆内存超过32GB，就会禁用指针压缩。32GB是压缩指针的最大寻址范围。超过32GB的堆内存中，压缩指针带来的性能提升并不显著，而且需要解压指针反而可能增加开销。
进程管理工具：非daemon进程管理工具supervisor
happy_king_zi的博客
09-29 1116
supervisor是一个 Client/Server模式的系统，允许用户在类unix操作系统上监视和控制多个进程，或者可以说是多个程序。supervisor与launchd，daemontools，runit等程序有着相同的功能，与其中某些程序不同的是，它并不作为“id 为 1的进程”而替代init。相反，它用于控制应用程序，像启动其它程序一样，通俗理解就是，把Supervisor服务管理的进程程序，它们作为supervisor的子进程来运行，而supervisor是父进程。
【RocketMQ】RocketMQ应用难点
记录一名在读研究生的学习笔记、感悟、开发产物
09-30 897
本文探讨了RocketMQ中消息重复消费的问题及其解决方案，尤其是在CLUSTERING模式下的扩容影响。文章分析了重复消费的原因，如广播模式、负载均衡模式下的多consumerGroup消费、消费者组内的动态变化及网络延迟等，并提出了利用唯一标识进行去重的方法。此外，还讨论了如何选择合适的存储机制以高效处理大量消息标识，如HashMap、MySQL、Redis以及推荐的布隆过滤器等方案。对于防止消息堆积与确保消息不丢失，也给出了相应的策略和技术措施。
第十三届蓝桥杯真题Java 斐波那契与7(持续更新)
音符犹如代码的博客
09-29 332
这是一道结果填空的题, 你只需要算出结果后提交即可。本题的结果为一 个整数, 在提交答案时只填写这个整数, 填写多余的内容将无法得分。斐波那契数列的递推公式为: Fn=Fn−1+Fn−2Fn​=Fn−1​+Fn−2​, 其中 F1=F2=1F1​=F2​=1。请问, 斐波那契数列的第 1 至 202202011200 项（含）中, 有多少项的个位 是 7。
JAVA开源项目 旅游管理系统 计算机毕业设计
as230627的博客
10-03 1292
旅游管理系统基于Springboot框架、JAVA编程语言、MYSQL数据库开发完成，“操作简单，功能实用”这是本软件设计的核心理念，本系统力求创造最好的用户体验。
【hot100-java】【合并两个有序链表】
m0_73629042的博客
09-30 391
记忆中，两个指针合并即可。
Spring Boot新闻推荐系统设计与实现
2402_85758936的博客
10-04 1205
目前，界面设计已经成为对软件质量进行评价的一条关键指标，一个好的用户界面可以使用户使用系统的信心和兴趣增加，从而使工作效率提高，JSP技术是将JAVA语言作为脚本语言的，JSP网页给整个服务器端的JAVA库单元提供了一个接口用来服务HTTP的应用程序。一旦输入系统的数据不正确，那么处理后的输出就会扩大这些错误，因此输入的数据的准确性对整个系统的性能起着决定性意义。输出是由电脑对输入的基本信息进行解决，生成高质量的有效信息，并使之具有一定的格式，提供给管理者使用，这是输出设计的主要责任和目标。
Python并发编程(1)——Python并发编程的几种实现方式
一点
10-03 1043
Python 并发编程是指在 Python 中编写能够同时执行多个任务的程序。并发编程在任何一门语言当中都是比较难的，因为会涉及各种各样的问题，在Python当中也不例外。Python 提供了多种方式来实现并发，包括多线程（threading）、多进程（multiprocessing）、异步编程（asyncio），以及一些高级用法concurrent.futures和第三方库如gevent。
英语词汇小程序小程序|英语词汇小程序系统|基于java的四六级词汇小程序设计与实现(源码+数据库+文档)
伟庭的博客
10-02 1608
四六级词汇小程序，可以实现目标用户群需要的功能，四六级词汇小程序的设计主要是对系统所要实现的功能进行详细考虑，确定所要实现的功能后进行界面的设计，四六级词汇小程序的开发利用现有的成熟技术参考，以源代码为模板，分析功能调整与四六级词汇小程序管理的实际需求相结合，讨论了基于四六级词汇小程序管理的使用。词汇是英语永恒的话题，单词太多记不住是孩子永远的难题。为方便用户能够可以随时进行四六级词汇小程序的数据信息管理，特开发了基于四六级词汇小程序的管理系统。
[C++][程序退出]详细讲解
SnowK博客
09-30 3800
[C++][程序退出]详细讲解
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值