Java-反射

已于 2024-10-11 16:15:32 修改
阅读量1.1k 收藏 13
点赞数 12
文章标签： java python 开发语言
于 2024-09-11 19:03:09 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_64689713/article/details/142138784
版权

  Java反射是Java编程语言中的一个重要特性，它允许程序在运行时获取类的信息，操作对象的内部结构，甚至动态地创建和操作对象。反射机制使得Java程序具有了更高的灵活性和扩展性，可以在不修改代码的情况下实现一些动态的功能。

一、 获取Class对象

要使用反射机制，首先需要获取一个Class对象，它表示我们要操作的类。获取Class对象的方式如下：

（1）、类名.class。
（2）、包名+类名：Class.forName("全类名")。
（3）、对象名.getclass。

例：

package com.wedu.Reflect1;

public class Person {
    public   Integer id;
    private String color;
    private  Integer age;

    public Integer getId() {
        return id;
    }

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

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    public Integer getAge() {
        return age;
    }

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

public class ReflectDemo1 {
    //获取class对象的方式
    public static void main(String[] args) throws ClassNotFoundException {
       //类名.class
        Class<Person> class1= Person.class;
        System.out.println(class1);
       //包名+类名
        Class<?> class2 = Class.forName("com.wedu.Reflect1.Person");
        System.out.println(class2);
       //对象.getClass
        Person person = new Person();
        Class<? extends Person> class3 = person.getClass();
        System.out.println(class3);

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

二、反射获取构造方法

1、方法介绍

Constructor<?>[] getConstructors()返回所有公共构造方法对象的数组
Constructor<?>[] getDeclaredConstructors()返回所有构造方法对象的数组
Constructor<T> getConstructor(Class<?>... parameterTypes)返回单个公共构造方法对象
Constructor<T> getDeclaredConstructor(Class<?>... parameterTypes)返回单个构造方法对象
package com.wedu.Reflect1;

public class Student {
    private String name;
    private int age;
    //共有的无参
    public Student() {
    }

    //共有的有参构造方法
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
        System.out.println("name的值为："+name+"age的值为："+age);
        System.out.println("共有的有参构造方法");
    }

    //私有的有参构造方法
    private Student(String name){
        System.out.println("name的值为："+name);
        System.out.println("私有的有参构造方法");
    }

    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 study(){
        System.out.println("学生在学习");
    }

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

package com.wedu.Reflect1;

import java.lang.reflect.Constructor;

public class ReflectDemo2 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException {
        //获取字节码对象
        Class clazz = Class.forName("com.wedu.Reflect1.Student");
       //返回所有的公共的构造方法的数组对象
        Constructor[] constructors1= clazz.getConstructors();
        for (Constructor constructor : constructors1) {
            System.out.println(constructor);
        }
      
        //返回所有的构造方法的数组对象
        Constructor[] constructors2 = clazz.getDeclaredConstructors();
        for (Constructor constructor : constructors2) {
            System.out.println(constructors2);
        }
       
        //返回单个公共构造方法对象
        Constructor constructor1 = clazz.getConstructor();
        System.out.println(constructor1);
       
        Constructor constructor2 = clazz.getConstructor(String.class, int.class);
        System.out.println(constructor2);
       
        //返回单个构造方法的对象
        Constructor constructor = clazz.getDeclaredConstructor(String.class);
        System.out.println(constructor);

    }
}

2、Constructor类用于创建对象的方法

方法名说明
T newInstance(Object...initargs)根据指定的构造方法创建对象
setAccessible(boolean flag)设置为true,表示取消访问检查
package com.wedu.Reflect1;

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

    public Student3() {
    }

    public Student3(String name) {
        this.name = name;
    }

    protected Student3(int age) {
        this.age = age;
    }

    private Student3(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;
    }

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

package com.wedu.Reflect1;

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

public class ReflectDemo3 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
        //获取class字节码文件对象
        Class clazz = Class.forName("com.wedu.Reflect1.Student3");
        //获取公共的构造方法
        Constructor[] cons1 = clazz.getConstructors();
        for (Constructor con : cons1) {
            System.out.println(con);
        }
        System.out.println("---------------------------------------------------------------------");

        //获取所有的构造方法
        Constructor[] cons2 = clazz.getDeclaredConstructors();
        for (Constructor con : cons2) {
            System.out.println(con);
        }
        System.out.println("------------------------------------------------------------------------");
        //获取单个构造方法
        Constructor con1 = clazz.getDeclaredConstructor();
        System.out.println(con1);

        Constructor con2 = clazz.getDeclaredConstructor(String.class);
        System.out.println(con2);

        Constructor con3 = clazz.getDeclaredConstructor(int.class);
        System.out.println(con3);

        Constructor con4 = clazz.getDeclaredConstructor(String.class,int.class);
        System.out.println(con4);
        System.out.println("--------------------------------------------------------------------------");

        con4.setAccessible(true);//表示临时取消权限校验
        Student3 stu = (Student3) con4.newInstance("张三", 23);
        System.out.println(stu);


    }
}

三、反射获取成员属性

Field[] getFields()返回所有公共成员变量对象的数组
Field[] getDeclaredFields()返回所有成员变量对象的数组
Field getField(String name)返回单个公共成员变量对象
Field getDeclaredField(String name)返回单个成员变量对象
package com.wedu.Reflect1;

public class Student4 {
    private String name;
    private  int age;
    public String gender;

    public Student4() {
    }

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

    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 getGender() {
        return gender;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }

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

package com.wedu.Reflect1;

import java.lang.reflect.Field;

public class ReflectDemo4 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, IllegalAccessException {
        //获取字节码
        Class clazz = Class.forName("com.wedu.Reflect1.Student4");
        //获取所有的成员变量
        Field[] declaredFields = clazz.getDeclaredFields();
        for (Field declaredField : declaredFields) {
            System.out.println(declaredField);

        }
        //获取单个的成员变量
        Field name = clazz.getDeclaredField("name");
        System.out.println(name);

        //获取权限修饰符
        int modifiers = name.getModifiers();
        System.out.println(modifiers);

        //获取成员变量的名字
        String n = name.getName();
        System.out.println(n);

        //获取成员变量的数据类型
        Class<?> type = name.getType();
        System.out.println(type);

        //获取成员变量记录的值
        Student4 s=new Student4("zhangsan",23,"男");
        name.setAccessible(true);//暴力反射
        Object value = name.get(s);
        System.out.println(value);


    }

}

四、反射获取成员方法

Method[] getMethods()返回所有公共成员方法对象的数组，包括继承的
Method[] getDeclaredMethods()返回所有成员方法对象的数组，不包括继承的
Method getMethod(String name, Class<?>... parameterTypes)返回单个公共成员方法对象
Method getDeclaredMethod(String name, Class<?>... parameterTypes)返回单个成员方法对象

         

package com.wedu.Reflect1;

import java.io.IOException;

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

    public Student5() {
    }

    public Student5(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 sleep(){
        System.out.println("睡觉");
    }

    private String eat(String something)throws IOException,NullPointerException {
        System.out.println("在吃"+something);
        return "好好吃";
    }

    private void eat(String something,int a){
        System.out.println("在吃"+something);
    }


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

     

package com.wedu.Reflect1;

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

public class ReflectDemo5 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, IllegalAccessException {
        //获取字节码文件
        Class clazz = Class.forName("com.wedu.Reflect1.Student5");
        //获取所有的成员方法（包括父类中的所有公共方法）
        Method[] methods = clazz.getMethods();
        for (Method method : methods) {
            System.out.println(method);
        }
        System.out.println("-------------------------------------------------------");

        //获取所有的方法对象（不能获取父类的，但是可以本类中私有的）
        Method[] declaredMethods = clazz.getDeclaredMethods();
        for (Method declaredMethod : declaredMethods) {
            System.out.println(declaredMethod);

        }
        System.out.println("-------------------------------------------------------");


        //获取指定的单一方法
        Method m = clazz.getDeclaredMethod("eat", String.class);
        System.out.println(m);
        System.out.println("-------------------------------------------------------");

        //获取方法的修饰符
        int modifiers = m.getModifiers();
        System.out.println(modifiers);
        System.out.println("-------------------------------------------------------");

        //获取方法的名字
        String name = m.getName();
        System.out.println(name);
        System.out.println("-------------------------------------------------------");

        //获取方法的形参
        Class[] parameterTypes = m.getParameterTypes();
        for (Class parameterType : parameterTypes) {
            System.out.println(parameterType);
        }
        System.out.println("-------------------------------------------------------");

        //获取方法的抛出的异常
        Class[] exceptionTypes = m.getExceptionTypes();
        for (Class exceptionType : exceptionTypes) {
            System.out.println(exceptionType);
        }
        System.out.println("-------------------------------------------------------");

        //运行方法
        Student5 s=new Student5();
        m.setAccessible(true);
        //s表示方法的调用者，“蛋糕”表示在调用方法的时候传递的实际参数
        String result = (String) m.invoke(s, "蛋糕");
        System.out.println(result);
    }
}

五、应用场景

Java反射机制有很多应用场景，例如：

1、动态代理：通过反射机制，我们可以动态地生成代理类，实现对方法的拦截和增强。
2、 插件化开发：通过反射机制，我们可以动态地加载和卸载插件，实现程序的扩展和定制。
3、ORM框架：通过反射机制，我们可以将Java对象和数据库表进行映射，实现对象的持久化和查询。

六、 总结

  Java反射机制是Java编程语言中的一个重要特性，它允许程序在运行时获取类的信息，操作对象的内部结构，甚至动态地创建和操作对象。反射机制使得Java程序具有了更高的灵活性和扩展性，可以在不修改代码的情况下实现一些动态的功能。本文通过实例介绍了Java反射的使用方法和应用场景，希望对你有所帮助。

安girl
关注
java中反射的使用
wopoli的博客
07-09 884
框架：半成品软件。可以在框架的基础上进行软件开发，达到简化代码的目的。 反射：将类的各个部分封装为其他对象进行使用。 反射优点： 1 可以在程序运行过程中操作这些对象。 2 可以解耦、提高程序的可扩展性。功能：将字节码文件加载到内存中，返回Class对象。 格式：Class 变量名 = Class.forName(类路径); 示例：Class person_class1 = Class.forName(“domain.Person”); 用途：多用于配置文件，将类名定义在配置文件中，用于读取文件加载类。 注
9-java进阶-反射1
08-03
1.获取该运行时类的Class：Class clazz = Person.class 2.获取该运行时类的抽象属性：Field age = clazz.getD
Java基础[08-反射].ppt
12-09
JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。 要想解剖一个类,必须先要获取到该类的字节码文件对象。而解剖使用的就是Class类中的方法.所以先要获取到每一个字节码文件对应的Class类型的对象。
Java 反射 使用总结
weixin_34218579的博客
11-17 59
转载请标明出处：http://www.cnblogs.com/zhaoyanjun/p/6074887.html1 本文出自【赵彦军的博客】 反射机制是什么 反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。 反射机制能做什么 反射机制主要提供了...
反射基础
起feng了~'s blog
10-09 78
反射 反射的概述 概念：是指在运行时获取一个类的变量和方法。然后通过获取到的信息来创建对象，调用方法的一种机制，由于这种动态性，可以极大的增强程序的灵活性，程序不用在编译期就完成确定，在运行期仍然可以扩展 获取类对象的三种方式 类名.class属性 对象名.getClass()方法 Class.forName(全类名) 方法 ...
Java高级编程：反射
soulmate______的博客
08-16 637
文章目录本章的主要内容关于反射的理解体会反射机制的“动态性”反射机制能提供的功能相关APIClass类的理解与获取Class的实例Class类的理解获取Class实例的几种方式：（前三种方式需要掌握）总结：创建类的对象的方式Class实例可以是哪些结构的说明了解ClassLoader类的加载过程----了解类的加载器的作用类的加载器的分类Java类编译、运行的执行的流程使用Classloader加载src目录下的配置文件反射应用一：创建运行时类的对象说明反射应用二：获取运行时类的完整结构反射应用三：调用运行
java 反射的使用方式
liujun2son
08-23 1801
反射的简介 反射常用的类对象 Class: 表示所有类 Constructor: 表示所有构造器 Method: 表示所有方法 Field: 表示所有字段 1.创建类的Class的对象 方式一： //方式一：使用class的属性 Class date1=Date.class; 方式二： //方式二：通过对象中的getClass的方法 Date date = new
java-反射机制-源码
04-12
Java反射机制是Java编程语言中的一个强大工具，它允许运行时动态访问类的信息，包括类名、属性、方法以及构造器等。通过反射，我们可以在程序执行过程中创建和操作任何类的对象，即使在编译时未知其具体类型。这种...
13.java-反射.md
最新发布
08-18
13.java-反射
java-反射总结【从入门到项目总结】
10-18
关于java反射的总结： 从入门介绍到项目使用的实际经验归纳总结得出！ 从jdk5到jdk8！
JAVA-反射面试题及答案
lzqiang2011的博客
01-26 2665
一、什么是反射？ 在Java运行时环境中，对于任意一个类，可以知道这个类有哪些属性和方法。对于任意一个对象，可以调用它的任意一个方法。这种动态获取类的信息以及动态调用对象的方法的功能来自于Java 语言的反（Reflection）机制。 反射的核心是 JVM 在运行时才动态加载类或调用方法/访问属性，它不需要事先（写代码的时候或编译期）知道运行对象是谁。 二、Java 反射主要提供以下功能： 1.在运行时判断任意一个对象所属的类； 2.在运行时构造任意一个类的对象； 3.在运行时判断任意一个类所具有的成员变
Java - 反射和枚举
旧时言的博客
03-06 1584
反射 1定义 Java的反射（reflection）机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意方法和属性，既然能拿到那么，我们就可以修改部分类型信息；这种动态获取信息以及动态调用对象方法的功能称为java语言的反射（reflection）机制。 2用途(了解) 1、在日常的第三方应用开发过程中，经常会遇到某个类的某个成员变量、方法或是属性是私有的或是只对系统应用开放，这时候就可以利用Java的反射机制通过反射来获取所需的私有成员或是方法。 2、
Java反射使用
鹏鹏2077
05-02 806
目录反射如何使用 反射 Java的反射（reflection）机制是指在程序的运行状态中，可以构造任意一个类的对象，可以了解任意一个对象所属的类，可以了解任意一个类的成员变量和方法，可以调用任意一个对象的属性和方法。这种动态获取程序信息以及动态调用对象的功能称为Java语言的反射机制。反射被视为动态语言的关键。 以上这些是百度百科的描述。 首先我们要知道一个类到对象正常的方式是这样的： 引入需要的”包类“名称——>通过new关键字实例化——>取得实例化对象 但是反射的方式是这样的： 实例化对象—
Java反射的使用
m0_61771461的博客
08-22 484
是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。
JAVA 反射的实现
夜雪天曦的博客
11-15 796
一、创建一个实体类 package com.yy.entity; public class Student { private String name; private int age; private String add; public String getName() { return name; } public void setName(String name...
java反射机制调用带参数的方法_Java反射机制：跟着代码学反射
weixin_32056343的博客
02-23 2960
1. 前言在OOP的世界里，万物皆对象。也就是说，我们可以将任何东西抽象成一个对象。比如人，可以抽象成一个Person类，通过new Person()来实例化一个对象；再比如鸭子，可以抽象成一个Duck类，也可以对其进行实例化……那么这一个个类本身是不是也可以抽象成一个类呢？Java提供了一个特殊的类Class，用来描述类的内部信息，是反射的核心类。下图是本篇讲述内容：2. Java反射机制概述J...
Java反射怎么用，反射的原理及简单使用实例
dkz97的博客
10-26 1197
JAVA反射机制反射机制的概要通过反射创建类获取Class的方式通过Class实例化对象通过反射调用类方法通过Class获取类中的方法通过Method调用方法通过反射修改类属性通过Class获取属性通过Class修改对象属性 反射机制的概要  JAVA的反射机制，就是可以通过全类名，获取当前类、调用当前类方法，以及获取或修改当前类属性的一个机制。  总结来说：就是通过类对象来获取类信息的一个途径。  如示例：若A类无法引用B类的话，但是又要调用B类的方法，其实就可以调用反射获取B类并且执行B类的方法。 通
深入理解Java反射机制
Java反射机制是Java编程语言中的一个重要特性，它允许程序在运行时动态地获取类的信息并操作类的对象。这种机制使得Java具有高度的灵活性和强大的元数据处理能力。下面将详细阐述Java反射机制的关键知识点。 1. **...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值