首页 > 编程语言 >Java反射

Java反射

时间：2024-03-30 22:31:16浏览次数：28  
标签：反射 Java String class Class test import public

1. 反射的基本概念

Java的反射（reflection）机制是在运行状态中对于任意一个类，都能够知道这个类的所有属性和方法，反射允许对成员变量、成员方法、构造方法的信息进行编程式访问。这种动态获取信 息以及动态调用对象方法的功能称为java语言的反射（reflection）机制。

反射允许对成员变量，成员方法和构造方法的信息进心编程式访问。
可以获取的信息具体包括：

  • 成员变量：修饰符、名称、类型，获取值/赋值
  • 构造方法：修饰符、名称、形参，创建对象
  • 成员方法：修饰符、名称、形参、返回值、抛出的异常、注解，运行方法

1.1 如何理解反射？

举个例子：
把一个类看作一个密封的盒子，这个盒子里面有成员变量、构造方法、成员方法这几样东西，把反射看作是一个人，这个人可以把这几样东西拿取出来给程序猿用。在这里插入图片描述在这里插入图片描述

1.2 反射的基本信息

Java程序中许多对象在运行时会出现两种类型：运行时类型(RTTI)和编译时类型，例如Person p = new Student()；这句代码中p在编译时类型为Person，运行时类型为Student。程序需要在运行时发现对象和类的真实 信息。而通过使用反射程序就能判断出该对象和类属于哪些类。

1.3 反射机制的起源

Class代表类的实体，在运行的Java应用程序中表示类和接口 。Java文件被编译后，生成了.class文件，JVM此时就要去解读.class文件 ,被编译后的Java文件.class也被JVM解析为 一个对象，这个对象就是java.lang.Class 。这样当程序在运行时，每个java文件就最终变成了Class类对象的一个实例。我们通过Java的反射机制应用到这个实例，就可以去获得甚至去添加改变这个类的属性和动作，使得这个类成为一个动态的类 。

  • Class类中的相关方法：
    • 获取类相关的方法：
      在这里插入图片描述
    • 获取类中属性的相关方法：
      在这里插入图片描述
    • 获取类中注解的相关方法：
      在这里插入图片描述
    • 获取类中构造方法的相关方法：
      在这里插入图片描述
    • 获取类中成员方法的相关方法：
      在这里插入图片描述

2. 获取Class对象的三种方法

  1. Class.forName(“全类名”)
  2. 类名.class
  3. 对象.getClass()

创建一个Student类

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


    public Student(){

    }
    public Student(int age) {
        this.age = age;
    }
    private Student(int age,String name) {
        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;
    }

    private String eat (String food) {
        System.out.println("正在吃" + food);
        return "吃完" + food+"好开心";
    }

    @Override
    public String toString() {
        return "Student{" +
                "age=" + age +
                ", name='" + name + '\'' +
                '}';
    }
}

2.1 Class.forName(“全类名”)

public class Reflection {
    public static void main(String[] args) throws ClassNotFoundException {
        // 获取指定类的Class文件对象
        Class test1 = Class.forName("Student");
        System.out.println("test1:"+test1);
       
    }
}

运行结果：
在这里插入图片描述

2.2 类名.class

public class Reflection {
    public static void main(String[] args) throws ClassNotFoundException {
        // 或者直接使用类的class属性获取Class对象
        Class test2 = Student.class;
        System.out.println("test2:"+test2);
       
    }
}

运行结果：
在这里插入图片描述

2.3 对象.getClass()

public class Reflection {
    public static void main(String[] args) throws ClassNotFoundException {
        // 获取当前对象的Class对象
        Student student = new Student();
        Class test3 = student.getClass();
        System.out.println("test3:"+test3);
       
    }
}

运行结果：
在这里插入图片描述

3. 获取构造方法

获取构造方法主要用到Constructor类，

  1. 获取public构造方法
  2. 获取所有构造方法
  3. 获取单个public构造方法
  4. 获取单个非public修饰的构造方法
    Constructor类中用于创建对象的方法

newInstance()：根据指定的构造方法创建对象
setAccessible()：设置为true取消非public构造方法的访问检查，否则无法创建对象。

3.1 获取所有public构造方法

public class Reflection2 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
        //使用反射获取类的Class对象
        Class test = Class.forName("Student");

        // 获取反射对象的所有public构造方法
        Constructor cons[] = test.getConstructors();
        for (Constructor coni: cons) {
            System.out.println(coni);
        }
    }
}

运行结果：
在这里插入图片描述

3.2 获取所有构造方法

import java.lang.reflect.Constructor;

public class Reflection5 {
    public static void main(String[] args) throws ClassNotFoundException {
        Class test = Class.forName("Student");
        Constructor cons[] = test.getDeclaredConstructors();
        for (Constructor con :cons) {
            System.out.println(con);
        }
    }
}

运行结果：
在这里插入图片描述

3.3 获取单个public修饰的构造方法

import java.lang.reflect.Constructor;

public class Reflection6 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException {
        Class test = Class.forName("Student");
        Constructor con = test.getConstructor();
        System.out.println(con);
    }
}

运行结果：

在这里插入图片描述

3.3.1 获取方法的权限修饰符

这里用一个固定的整型数字表示权限修饰符

import java.lang.reflect.Constructor;

public class Reflection6 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException {
        Class test = Class.forName("Student");
        Constructor con = test.getConstructor();
        int num = con.getModifiers();
        System.out.println(num);
    }
}

在这里插入图片描述

3.4 获取单个非public修饰的构造方法

import java.lang.reflect.Constructor;

public class Reflection8 {
    public static void main(String[] args) throws ClassNotFoundException,
                                                  NoSuchMethodException {
        Class test = Class.forName("Student");
        Constructor con = test.getDeclaredConstructor(int.class,String.class);
        System.out.println(con);
    }
}

运行结果：
在这里插入图片描述

3.4.1 获取方法的权限修饰符

这里用一个固定的整型数字表示权限修饰符

import java.lang.reflect.Constructor;

public class Reflection6 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException {
        Class test = Class.forName("Student");
        Constructor con = test.getConstructor();
        int num = con.getModifiers();
        System.out.println(num);
    }
}

运行结果：
在这里插入图片描述

3.4.2 获取方法的所有参数

import java.lang.reflect.Constructor;
import java.lang.reflect.Parameter;

public class Reflection6 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException {
        Class test = Class.forName("Student");
        Constructor con = test.getDeclaredConstructor(int.class, String.class);
        Parameter p[] = con.getParameters();
        for (Parameter pa : p) {
            System.out.println(pa);
        }
    }
}

运行结果：
在这里插入图片描述

3.5 根据指定的构造方法创建对象

import javax.swing.plaf.synth.SynthOptionPaneUI;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;

public class Reflection9 {
    public static void main(String[] args) throws ClassNotFoundException,
            NoSuchMethodException, InvocationTargetException,
            InstantiationException, IllegalAccessException {

        Class test = Class.forName("Student");
        Constructor con = test.getDeclaredConstructor(int.class, String.class);
        con.setAccessible(true);//设置访问权限
        Student stu = (Student) con.newInstance(20, "张三");
        System.out.println(stu);
    }
}

运行结果：
在这里插入图片描述

4. 获取成员变量

获取成员变量主要是通过Field类：

  1. 获取所有public修饰的成员变量
  2. 获取所有成员变量
  3. 获取单个public修饰的成员变量
  4. 获取单个非public修饰的成员变量

Field类中用于创建对象的方法：

  1. set()：赋值
  2. get()：获取值

新建一个Student2类

public class Student2 {
    private int age;
    private String name;
    public int id;

    public int getAge() {
        return age;
    }

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


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

    public String getName() {
        return name;
    }

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

    public int getId() {
        return id;
    }

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

    public String sleep(int hours) {
        return "sleeping for"+hours+"hours";
    }

    private String eat(String food) {
        return "eating " + food;
    }

    @Override
    public String toString() {
        return "Student2{" +
                "age=" + age +
                ", name='" + name + '\'' +
                ", id=" + id +
                '}';
    }
}

4.1 获取所有public修饰的成员变量

import java.lang.reflect.Field;

public class Reflection10 {
    public static void main(String[] args) throws ClassNotFoundException {
        Class test = Class.forName("Student2");
        Field f[] = test.getFields();
        for (Field field : f) {
            System.out.println(field);
        }
    }
}

运行结果：
在这里插入图片描述

4.2 获取所有成员变量

import java.lang.reflect.Field;

public class Reflection10 {
    public static void main(String[] args) throws ClassNotFoundException {
        Class test = Class.forName("Student2");
        Field f[] = test.getDeclaredFields();
        for (Field field : f) {
            System.out.println(field);
        }
    }
}

运行结果：
在这里插入图片描述

4.3 获取单个public修饰的成员变量

import java.lang.reflect.Field;

public class Reflection10 {
    public static void main(String[] args) throws ClassNotFoundException,
                                                   NoSuchFieldException {

        Class test = Class.forName("Student2");
        Field f = test.getField("id");
        System.out.println(f);
    }
}

运行结果：
在这里插入图片描述

4.4 获取单个非public修饰的成员变量

import java.lang.reflect.Field;

public class Reflection10 {
    public static void main(String[] args) throws ClassNotFoundException,
                                                   NoSuchFieldException {

        Class test = Class.forName("Student2");
        Field f = test.getDeclaredField("age");
        System.out.println(f);
    }
}

运行结果：
在这里插入图片描述

4.4.1 获取成员变量的修饰符

import java.lang.reflect.Field;

public class Reflection10 {
    public static void main(String[] args) throws ClassNotFoundException,
                                                   NoSuchFieldException {

        Class test = Class.forName("Student2");
        Field f = test.getDeclaredField("age");
        int modifiers = f.getModifiers();
        System.out.println(modifiers);
    }
}

运行结果：
在这里插入图片描述

4.4.2 获取成员变量的名字

import java.lang.reflect.Field;

public class Reflection10 {
    public static void main(String[] args) throws ClassNotFoundException,
                                                   NoSuchFieldException {

        Class test = Class.forName("Student2");
        Field f = test.getDeclaredField("age");
        String n = f.getName();
        System.out.println(n);
    }
}

运行结果：
在这里插入图片描述

4.4.3 获取成员变量的数据类型

import java.lang.reflect.Field;

public class Reflection10 {
    public static void main(String[] args) throws ClassNotFoundException,
                                                   NoSuchFieldException {
        Class test = Class.forName("Student2");
        Field f = test.getDeclaredField("age");
        Object o = f.getType();
        System.out.println(o);
    }
}

运行结果：
在这里插入图片描述

4.4.4 获取成员变量记录的值

import java.lang.reflect.Field;

public class Reflection10 {
    public static void main(String[] args) throws ClassNotFoundException,
            NoSuchFieldException, IllegalAccessException {

        Class test = Class.forName("Student2");
        Field f = test.getDeclaredField("age");
        Student2 s = new Student2(20,"张三",001);
        f.setAccessible(true);
        Object value = f.get(s);
        System.out.println(value);
    }
}

运行结果：
在这里插入图片描述

4.4.4 修改成员变量记录的值

import java.lang.reflect.Field;

public class Reflection10 {
    public static void main(String[] args) throws ClassNotFoundException,
            NoSuchFieldException, IllegalAccessException {

        Class test = Class.forName("Student2");
        Field f = test.getDeclaredField("age");
        Student2 s = new Student2(20,"张三",001);
        f.setAccessible(true);
        f.set(s,108);
        Object value = f.get(s);
        System.out.println(value);
    }
}

修改之后的结果：在这里插入图片描述

5. 获取成员方法

通过Method类获取成员方法

  1. 获取所有public修饰的成员方法，包括继承的
  2. 获取所有成员方法，不包括继承的
  3. 获取单个public修饰的成员方法
  4. 获取单个非public修饰的方法

Method类中用于运行成员方法的方法：
invoke()：运行成员方法

5.1 获取所有public修饰的成员方法，包括继承的

import java.lang.reflect.Method;

public class Reflection11 {
    public static void main(String[] args) throws ClassNotFoundException {
        Class test = Class.forName("Student2");
        Method m[] = test.getMethods();
        for (Method method:m) {
            System.out.println(method);
        }
    }
}

运行结果：
在这里插入图片描述

5.2 获取所有成员方法，不包括继承的

import java.lang.reflect.Method;

public class Reflection11 {
    public static void main(String[] args) throws ClassNotFoundException {
        Class test = Class.forName("Student2");
        Method m[] = test.getDeclaredMethods();
        for (Method method:m) {
            System.out.println(method);
        }
    }
}

运行结果：
在这里插入图片描述

5.3 获取单个public修饰的成员方法

import javax.swing.plaf.synth.SynthOptionPaneUI;
import java.lang.reflect.Method;

public class Reflection11 {
    public static void main(String[] args) throws ClassNotFoundException,
                                                 NoSuchMethodException {
        Class test = Class.forName("Student2");
        //通过 方法名+参数类型 获取指定成员方法
        Method m = test.getMethod("sleep",int.class);
        System.out.println(m);
    }
}

运行结果：
在这里插入图片描述

5.4 获取单个非public修饰的成员方法

import javax.swing.plaf.synth.SynthOptionPaneUI;
import java.lang.reflect.Method;

public class Reflection11 {
    public static void main(String[] args) throws ClassNotFoundException,
                                                 NoSuchMethodException {
        Class test = Class.forName("Student2");
        //通过 方法名+参数类型 获取指定成员方法
        Method m = test.getDeclaredMethod("eat",String.class);
        System.out.println(m);
    }
}

运行结果：
在这里插入图片描述

5.4.1 获取成员方法的修饰符

import javax.swing.plaf.synth.SynthOptionPaneUI;
import java.lang.reflect.Method;

public class Reflection11 {
    public static void main(String[] args) throws ClassNotFoundException,
                                                 NoSuchMethodException {
        Class test = Class.forName("Student2");
        //通过 方法名+参数类型 获取指定成员方法
        Method m = test.getDeclaredMethod("eat",String.class);
        int n = m.getModifiers();
        System.out.println(n);
    }
}

运行结果：
在这里插入图片描述

5.4.2 获取成员方法的名字

import javax.swing.plaf.synth.SynthOptionPaneUI;
import java.lang.reflect.Method;

public class Reflection11 {
    public static void main(String[] args) throws ClassNotFoundException,
                                                 NoSuchMethodException {
        Class test = Class.forName("Student2");
        //通过 方法名+参数类型 获取指定成员方法
        Method m = test.getDeclaredMethod("eat",String.class);
        String n = m.getName();
        System.out.println(n);
    }
}

运行结果：
在这里插入图片描述

5.4.3 获取成员方法的参数

import javax.swing.plaf.synth.SynthOptionPaneUI;
import java.lang.reflect.Method;
import java.lang.reflect.Parameter;

public class Reflection11 {
    public static void main(String[] args) throws ClassNotFoundException,
                                                 NoSuchMethodException {
        Class test = Class.forName("Student2");
        //通过 方法名+参数类型 获取指定成员方法
        Method m = test.getDeclaredMethod("eat",String.class);
        Parameter p[] = m.getParameters();
        for (Parameter par:p) {
            System.out.println(par);
        }
    }
}

运行结果：
在这里插入图片描述

5.4.4 获取成员方法抛出的异常

import javax.swing.plaf.synth.SynthOptionPaneUI;
import java.lang.reflect.Method;
import java.lang.reflect.Parameter;

public class Reflection11 {
    public static void main(String[] args) throws ClassNotFoundException,
                                                 NoSuchMethodException {
        Class test = Class.forName("Student2");
        //通过 方法名+参数类型 获取指定成员方法
        Method m = test.getDeclaredMethod("eat",String.class);
        Class exception[] = m.getExceptionTypes();
        for (Class exc:exception) {
            System.out.println(exc);
        }
    }
}

运行方法：
在这里插入图片描述

5.5 运行成员方法

import javax.swing.plaf.synth.SynthOptionPaneUI;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Parameter;

public class Reflection11 {
    public static void main(String[] args) throws ClassNotFoundException,
            NoSuchMethodException, InvocationTargetException, IllegalAccessException {
        Class test = Class.forName("Student2");
        //通过 方法名+参数类型 获取指定成员方法
        Method m = test.getDeclaredMethod("eat",String.class);

        Student2 s = new Student2(20,"zhangsan",100);
        m.setAccessible(true);
        // s:方法的调用者，apple：向被调用方法传入的参数
        Object o = m.invoke(s,"apple");
        System.out.println(o);

    }
}

运行结果：
在这里插入图片描述

6. 反射的用途

  1. 在日常的第三方应用开发过程中，经常会遇到某个类的某个成员变量、方法或是属性是私有的或是只对系统 应用开放，这时候就可以利用Java的反射机制通过反射来获取所需的私有成员或是方法 。
  2. 反射最重要的用途就是开发各种通用框架，比如在spring中，我们将所有的类Bean交给spring容器管理，无 论是XML配置Bean还是注解配置，当我们从容器中获取Bean来依赖注入时，容器会读取配置，而配置中给的
    就是类的信息，spring根据这些信息，需要创建哪些Bean，spring就动态的创建这些类。

7. 反射的优点和缺点

  • 优点：
    1. 对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法
    2. 增加程序的灵活性和扩展性，降低耦合性，提高自适应能力
    3. 反射已经运用在了很多流行框架如：Struts、Hibernate、Spring 等等。
  • 缺点：
    1. 使用反射会有效率问题。会导致程序性能降低。
    2. 反射技术绕过了源代码的技术，因而会带来维护问题。反射代码比相应的直接代码更复杂 。

标签：反射,Java,String,class,Class,test,import,public
From： https://blog.csdn.net/qq_45559559/article/details/137071723

相关文章

  • Java 递归算法系列：建议收藏的 13 个经典问题的代码实现详解
    递归算法题求阶乘（Factorial）斐波那契数列（FibonacciSequence）汉诺塔（TowerofHanoi）遍历树节点（TreeTraversal）数组反转（ArrayReversal）爬楼梯问题（ClimbingStairsProblem）回文数检测（PalindromeChecking）找出数组中的最大值（FindingMaximumValueinanArray）分治算法......
  • java 项目线上拉代码，打包
    pos-admin.sh#!/bin/shecho=================================echo自动化部署脚本启动echo=================================echo停止原来运行中的工程APP_NAME=pos-admin.jar###APP_NAME=test.jar###这个地方的名称就是pom文件中的artifactId，但最好是写......
  • Java(static)
    1.在类创建完后，接下来就是创建对象，用同一个类去创建不同对象。如果用这个类去为一整个学校创建学生对象，假如有2000名学生都来自这个学校，那么开辟空间时就要为这个学校重复存储2000次，如果要进行修改，那么也要操作2000次。所以为了解决这个问题去节省内存空间，提高效率，Java提供了......
  • java来了嗷！
    题目一：Java中的重载（Overload）和重写（Override）有何区别？题目二：什么是Java中的异常处理机制？请解释try-catch-finally块的工作原理，并提供一个示例。题目三：Java中的静态方法（StaticMethod）和实例方法（InstanceMethod）有何区别？题目四：Java中的多线程（Multithreading）是如何实现的？请解释一下J......
  • java毕业设计企业人事管理系统（Springboot+mysql+jdk1.8+maven3.39）
    本系统（程序+源码）带文档lw万字以上 文末可领取本课题的JAVA源码参考系统程序文件列表系统的选题背景和意义选题背景：随着信息技术的快速发展，企业管理逐渐向数字化、智能化方向迈进。人事管理作为企业内部管理的重要组成部分，其信息化水平直接关系到企业的运行效率和管理水......
  • java毕业设计汽车零件厂绩效管理（Springboot+mysql+jdk1.8+maven3.39）
    本系统（程序+源码）带文档lw万字以上 文末可领取本课题的JAVA源码参考系统程序文件列表系统的选题背景和意义选题背景：在现代企业管理中，绩效管理是连接企业战略目标与员工个人目标的桥梁，它对于提升员工工作积极性、优化团队协作效率以及推动企业持续发展具有重要作用。对于......
  • 使用Jep在Java中调用Conda虚拟环境下的Python
    为了解决毕设中需要用到在Java中调用Python的问题，我在网上寻找对应的解决方案。似乎没有太好的解决方案：Jython至今仍是Python2，Py4J似乎也不再活跃更新。所幸我找到了Jep这一神器。正当我雀跃不已，却又发现了一些问题，在两个小时的艰难攻关之下，这些问题逐渐迎刃而解。问题一：无法找到......
  • java反序列化-CC1
    CC1目录CC11、Transformer接口2、Transformer的实现类ConstantTransformerChainedTransformerInvokerTransformer3、寻找调用链TransformedMap(功能理解)LazyMap(调用链分析)1、Transformer接口从Transformer接口开始，对于这个接口是这么介绍的：它被实现为一个将一个对象转换为......
  • 2024年3月30号java学习
    集合 集合中的长度不固定，集合中只能存储引用数据类型，不能够存放基本数据类型,需要变成基本数据类型对应的包装类。基本数据类型的包装类ArrayListArrayList<类型>变量名=newArrayList<>();示例代码packagearrayList;importjava.util.ArrayList;publicclassar......
  • Java基础 TCP协议下，收发数据代码实现
     --------------------------------------------------------------------------------------------------------------------------------- 代码实现：1.发送数据：publicstaticvoidmain(String[]args)throwsException{//1.创建Socket对象。细节：在创建对象的同......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99