Java反射技术

最新推荐文章于 2024-04-18 09:39:19 发布
最新推荐文章于 2024-04-18 09:39:19 发布
阅读量345 收藏
点赞数
分类专栏： java 文章标签： java 反射 框架 Constructor Method
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/chen158158/article/details/41047781
版权


java的反射机制：

          我们都知道，一个java类中，有成员变量、成员方法、构造方法等等，反射机制，就是动态的获取这些类中的信息，并动态的调用对象的方法。通常只有要设计框架的过程中，才会使用java反射相关的api，但是了解java反射机制的基本原理与基本方法，可以帮忙我们在日后对框架的学习与应用提供很大的帮忙。
反射的使用，简单的讲，就是通过类的Class对象，获取对应的Field、Method 和 Constructor 对象，并进行相关操作。通常jdk中的关于反射的api我们一般使用与框架的编写。

1获得类的字节码文件的三种方法。 
<span style="font-size:18px;">package com.reflect;

import com.reflect.bean.Person;

/**
 * User: OF895
 * Date: 14-11-11
 * Time: 下午1:43
 */
public class GetClazzDemo {
    public static void main(String[] args) {

        //反射，加载类，获得类的字节码文件
        try {
            //第一种获得“类的字节码”文件的方法，将类的字节码文件加载到"内存中"
            Class clazz = Class.forName("com.reflect.bean.Person");
            System.out.println(clazz);
            //第二种获得“类的字节码”文件的方法
            Class clazz1 = new Person().getClass();
            System.out.println(clazz1);
            //第三种获得“类的字节码”文件的方法，将类的字节码文件加载到内存中
            Class clazz2 = Person.class;
            System.out.println(clazz2);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}
</span>

2利用反射技术反射出类中的方法的构造函数。
Person类，用于被反射的类： 
<span style="font-size:18px;">package com.reflect.bean;

import java.io.InputStream;
import java.util.List;

/**
 * User: OF895
 * Date: 14-11-11
 * Time: 下午1:44
 */
public class Person {
    public int age;
    public String name = "小明";
    public String height = "100";
    private String gender = "男";
    public static String weight = "300";

    //私有的构造方法
    private Person(List<String> list) {
        System.out.println("这个一个私有的构造方法！");
    }

    public Person() {
        System.out.println("new person!");
    }

    public Person(int age, String name) {
        this.age = age;
        this.name = name;
        System.out.println("这是含有参数的构造方法!");
    }

    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 void say() {
        System.out.println("这是一个不带参数的say方法!");
    }

    public void say(String name, int age) {
        System.out.println(name + ":" + age);
    }

    public Class[] say(String name, int[] password) {
        return new Class[]{String.class, int.class};
    }


    private void say(InputStream in) {
        System.out.println(in);
    }

    //静态方法的反射
    public static void say(int num) {
        System.out.println(num);
    }

    //如何反射main方法，注意一下main方法的参数是一个String类型的数组
    public static void main(String[] args) {
        System.out.println("main...................");
    }
}
</span>


 


<span style="font-size:18px;">package com.reflect;

import com.reflect.bean.Person;
import org.junit.Test;

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.util.ArrayList;
import java.util.List;

/**
 * 利用反射技术反射出类中的方法的构造函数
 * User: OF895
 * Date: 14-11-11
 * Time: 下午5:35
 */
public class GetConstructDemo {

    //反射类中的无参数的构造方法
    @Test
    public void test1() {
        try {

            Class clazz = Class.forName("com.reflect.bean.Person");
            //反射类中的无参数的构造方法
            Constructor constructor = clazz.getConstructor(null);
            //构造函数的主要作用是实例化一个对象，所以在这里我们拿到一个Constructor对象后，我们可以通过调用他的newInstance()方法，实例化一个对象！
            Person person = (Person) constructor.newInstance();
            System.out.println(person.height);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
    }

    //反射类的含有参数的构造方法
    @Test
    public void test2() throws Exception {
        Class clazz = Class.forName("com.reflect.bean.Person");
        //反射类中含有参数的构造方法,这里不要写成Integer.class，int.class
        Constructor constructor = clazz.getConstructor(int.class, String.class);
        Person person = (Person) constructor.newInstance(20, "xiaoming");
        person.say();
    }

    //反射类中的私有的的构造方法
    @Test
    public void test3() throws Exception {
        Class clazz = Class.forName("com.reflect.bean.Person");
        //反射类中的私有的构造方法
        Constructor constructor = clazz.getDeclaredConstructor(List.class);
        //不管被反射的类的构造方法是什么样的访问权限，这里强制允许访问，如果这里不这样设置，那么在类外是无法访问Person类的“私有的”构造方法的。
        constructor.setAccessible(true); //反射类的私有的构造函数，那么这个设置一定要加上！
        Person person = (Person) constructor.newInstance(new ArrayList());
    }


    //反射类，创建类的对象的另外一种方法
    @Test
    public void test4() throws Exception {
        Class clazz = Class.forName("com.reflect.bean.Person");
        //通过clazz类的newInstance（）方法我们也可以直接反射出类的对象
        //与上面的例子区别开来，原理：其实这个类的源码也就是先反射出一个无参数的Constructor对象
        //然后再通过这个Constructor的newInstance（）方法得到
        //这个就是sun公司给我们提供的一种简便的方法
        Person person = (Person) clazz.newInstance();
    }

}
</span>

3利用反射技术去反射类的“方法”（这里被反射的类，仍然使用的是例子2中的Person对象）： 
<span style="font-size:18px;">package com.reflect;

import com.reflect.bean.Person;
import org.junit.Test;

import java.io.FileInputStream;
import java.io.InputStream;
import java.lang.reflect.Method;

/**
 * 利用反射技术去反射类的“方法”
 * User: OF895
 * Date: 14-11-11
 * Time: 下午10:09
 */
public class GetMethodDemo {

    /**
     * public void say() {
     * System.out.println("这是一个不带参数的say方法!");
     * }
     *
     * @throws Exception
     */
    //反射“无参数”的方法
    @Test
    public void test1() throws Exception {
        Class clazz = Class.forName("com.reflect.bean.Person");
        //因为在下面使用invoke方法的时候，我们需要指定反射那个对象下面的那个方法，所以我们需要先“反射”出一个对象！
        Person p = (Person) clazz.newInstance();
        //查阅api可以知道第一个参数是“方法名”，第二个参数是方法的参数类型
        Method method = clazz.getMethod("say", null);//得到无参数的方法的Method对象
        //查阅api可以看到，在调用invoke方法的时候，我们必须要执行我们要
        method.invoke(p, null);
    }

    //反射“带参数”的方法

    /**
     * public Class[] say(String name, int[] password) {
     * return new Class[]{String.class, int.class};
     * }
     *
     * @throws Exception
     */
    @Test
    public void test2() throws Exception {
        Class clazz = Class.forName("com.reflect.bean.Person");
        //因为在下面使用invoke方法的时候，我们需要指定反射那个对象下面的那个方法，所以我们需要先“反射”出一个对象！
        Person p = (Person) clazz.newInstance();
        Method method = clazz.getMethod("say", String.class, int[].class);
        //这里注意一下“反射”的方法的返回类型是Class[]类型的，字节码类型的数组！
        Class[] array = (Class[]) method.invoke(p, "小明", new int[]{1, 2, 3});
        System.out.println(array.length);
    }


    /**
     * 要反射的方法：
     * private void say(InputStream in) {
     * System.out.println(in);
     * }
     *
     * @throws Exception
     */
    @Test
    public void test3() throws Exception {
        Class clazz = Class.forName("com.reflect.bean.Person");
        //因为在下面使用invoke方法的时候，我们需要指定反射那个对象下面的那个方法，所以我们需要先“反射”出一个对象！
        Person p = (Person) clazz.newInstance();
        //注意一下要“反射”方法的参数的类型是InoutStream类型的
        Method method = clazz.getDeclaredMethod("say", InputStream.class);
        //因为要反射的方法是“private”类型的，所以这里需要设置一下可访问性！
        method.setAccessible(true);
        //第一个参数是要反射的对象，第二个参数是要反射对象的方法的参数
        method.invoke(p, new FileInputStream("d://test.txt"));
    }

    /**
     * //静态方法的反射
     * public static void say(int num) {
     * System.out.println(num);
     * }
     */
    @Test
    public void test4() throws Exception {
        Class clazz = Class.forName("com.reflect.bean.Person");
        Method method = clazz.getMethod("say", int.class);
        //反射静态方法有个不同的地方就是，进行方法在调用的时候是不需要传入对象的，所以前面给null就可以了！
        method.invoke(null, 20);
    }


    /**
     *如何反射main方法？这个有点特殊，不能直接在invoke的时候传入String[]类型的参数
     * 这里jdk1.5之后才出现了“可变参数”的概念，sun公司为了兼容以前的代码，这里做了一个折中的选择。
     */
    @Test
    public void test5() throws Exception {
        Class clazz = Class.forName("com.reflect.bean.Person");
        Method method = clazz.getMethod("main", String[].class);
        //这个有点特殊，不能直接在invoke的时候传入String[]类型的参数,必须传入new Object[]{new String[]{"hello","world"}}
        //如果直接传入new String["hello","world"],会在person中去寻找有两个String类型的static的main方法，它默认会将String["hello","world"]拆成"hello","world两个参数
        method.invoke(null, new Object[]{new String[]{"hello","world"}});
    }

}
</span>

4反射类的“字段”（这个仍然是是使用上面的Person类）： 
<span style="font-size:18px;">package com.reflect;


import com.reflect.bean.Person;
import org.junit.Test;

import java.lang.reflect.Field;

/**
 * 反射类的“字段”
 * User: OF895
 * Date: 14-11-11
 * Time: 下午11:26
 */
public class GetFieldDemo {

    /**
     * 反射Person类的name字段
     * <p/>
     * public String name = "小明";
     */
    @Test
    public void test1() throws Exception {
        Class clazz = Class.forName("com.reflect.bean.Person");
        //这里的参数是要“反射的”字段的“引用名”
        Field field = clazz.getField("name");
        //我们可以获取到“反射的”字段的“类型”
        Class type = field.getType();
        //获取到“反射的”字段的值,参数一定要记住，要从“反射那个对象”中的此字段,要传入“被反射字段所在的类的对象”
        Person p = (Person) clazz.newInstance();
//        Object value = field.get(p);
        if (type.equals(String.class)) {
            //我们还可以为“字段”赋值，先赋值，在取值
            field.set(p,"科比");
            //这里的字段P,指的是反射的“字段”，所在的类的"对象"
            Object value = field.get(p);
            //如果得到的“反射的字段”的类型是java.lang.String类型的，那么我们就将“反射的”字段的值，强制转换成String类型的
            String str = (String) value;
            System.out.println(str);
        }
    }


    /**
     * 反射私有的字段
     *  private String gender = "男";
     *
     */
    @Test
    public void test2() throws Exception {
        Class clazz = Class.forName("com.reflect.bean.Person");
        Field field = clazz.getDeclaredField("gender");
        field.setAccessible(true);
        Object value = field.get(clazz.newInstance());
        System.out.println(value);
    }

    /**
     *
     * 反射类的静态的字段
     *
     *   public static String weight = "300";
     */

    @Test
    public void test3() throws Exception {
        Class clazz = Class.forName("com.reflect.bean.Person");
        Field field = clazz.getDeclaredField("weight");
        //由于“反射的”是“静态的”字段，所以我们不需要指定反射的具体的类的对象，因为这个类的这个静态的“字段”在内存中只有一份，是通用的。
        Object value = field.get(null);
        System.out.println(value);
    }
}</span>
chen158158
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java反射技术原理与用法实例分析
08-19
主要介绍了Java反射技术原理与用法,结合实例形式分析了Java反射技术的基本概念、功能、原理、用法及操作注意事项,需要的朋友可以参考下
Java反射技术详解
热门推荐
黄林晴
04-14 23万+
前言 相信很多人都知道反射可以说是Java中最强大的技术了，它可以做的事情太多太多，很多优秀的开源框架都是通过反射完成的，比如最初的很多注解框架，后来因为java反射影响性能，所以被运行时注解APT替代了，java反射有个开源框架jOOR相信很多人都用过，不过我们还是要学习发射的基础语法，这样才能自己写出优秀的框架，当然这里所讲的反射技术，是学习Android插件化技术、Hook技术等必不可...
Java反射（通俗易懂）
qq_51515673的博客
05-17 10万+
目录 1、反射介绍 2、反射API 2.1 获取类对应的字节码的对象（三种） 2.2 常用方法 3、反射的应用 3.1 创建 : 测试物料类 3.2 获取类对象 3.3 获取成员变量 3.4 通过字节码对象获取类的成员方法 3.5 通过字节码对象获取类的构造方法 4、创建对象 1、反射介绍 Reflection(反射) 是 Java 程序开发语言的特征之一，它允许运行中的 Java 程序对自身进行检查。被private封装的资源只能类内部访问，外部是不行的，...
java反射技术
幻影寒狼
12-06 2100
一、反射的引入 1.编译时知道类或对象的具体信息，此时直接对类和对象进行操作即可，无需反射 Student stu2 = new Student(); stu2.setAge(stu1.getAge()); System.out.println(stu2.getAge()); 2.如果编译不知道类或对象的具体信息，此时应该如何做呢？使用反射来实现 比
Java反射的用途
果酱 の 博客
07-20 3620
Java反射是一项强大的特性，它为我们提供了在运行时获取和操作类的信息的能力。通过反射，我们可以动态地创建对象、调用方法、访问和修改字段，甚至实现动态代理。Java反射是一种强大的特性，它允许我们在运行时获取和操作类的信息。通过反射，我们可以动态地创建对象、调用方法、访问和修改字段，甚至可以实现动态代理。通过动态代理，我们可以在运行时生成代理对象，并在代理对象中添加额外的逻辑。在许多情况下，我们需要在运行时获取类的信息，例如类的名称、修饰符、父类、接口等。通过反射，我们可以访问和修改对象的字段。
java反射构建一个类_【软件工程】JAVA反射技术
weixin_29671351的博客
02-27 2236
JAVA反射技术Java 反射技术应用广泛，它能够配置：类的全限定名、方法和参数，完成对象的初始化，甚至是反射某些方法。这样就可以大大增强 Java 的可配置’性， pring IoC 的基本原理也是如此，当然 Spring IoC 的代码要复杂得多。Java 的反射内容繁多，包括对象构建、反射方法、注解、参数、接口等。通过反射构建对象Java 中允许通过反射配置信息构建对象，比如 Reflect...
基于Java反射技术实现简单IOC容器
08-18
主要介绍了基于Java反射技术实现简单IOC容器,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
Java反射技术详解及实例解析
08-18
主要介绍了Java反射技术详解及实例解析，反射可以说是Java中最强大的技术了，它可以做的事情太多太多，很多优秀的开源框架都是通过反射完成的。如果对JAVA感兴趣来可以学习一下
java 反射技术
07-28
java 反射技术
基础深化和提高-java反射技术
11-11
Java反射技术指的是在运行时动态地获取类的信息、调用对象的方法、操作类的属性等能力。通过反射，程序可以在运行时检查类、实例化对象、调用方法、获取和设置属性，甚至可以动态修改类的结构。 Java反射技术的核心...
关于Ribbon在SpringCloudAlibaba2021.1版本中，找不到服务实例
aoxiaojun的博客
04-12 435
关于Ribbon在SpringCloudAlibaba2021.1版本中，找不到服务实例
java面向对象.day21（继承02--super）
BaiZhuYuan的博客
04-14 715
super===父this===当前使用super时，首先要继承父类，其次是在子类里面才能使用super。继承父类后，运行子类时会同时调用父类的构造方法，如果要显性调用父类的构造方法必须在子类的第一行调用。单使用super()表示调用父类构造方法，单使用this()表示调用本身的构造方法。父类具有有参的构造方法时，并且没有显性无参构造方法，那么子类要使用时必须直接调用父类的有参构造方法，
【1524】java投票管理系统Myeclipse开发mysql数据库web结构java编程计算机网页项目
最新发布
qq_251836457的博客
04-18 212
2、开发环境为TOMCAT7.0,Myeclipse8.5开发，数据库为Mysql5.0，使用java语言开发。(5)投票选项管理：对投票选项信息进行添加、删除、修改和查看。(6)投票记录管理：对投票记录信息进行添加、删除、修改和查看。(1)管理员管理：对管理员信息进行添加、删除、修改和查看。(2)用户管理：对用户信息进行添加、删除、修改和查看。(3)公告管理：对公告信息进行添加、删除、修改和查看。(4)投票管理：对投票信息进行添加、删除、修改和查看。4）投票浏览查看、查看投票、投票记录。
Ubuntu部署jmeter与ant
weixin_71807218的博客
04-12 982
为了整合的持续集成工具，我将jmeter与ant都部署在了Jenkins容器中，并配置了build.xml1：先下载jdk-8u74-linux-x64.tar.gz，上传到服务器，这里上传文件用到了ubuntu 下的​2：解压tar包。执行 tar -xvf jdk-8u74-linux-x64.tar.gz ，解压jdk包，生成 jdk1.8.0_74 目录​3：配置环境变量在最后面增加两行执行命令：source /etc/profile，配置的环境变量生效。
常见Spring相关工具报错-源码分析
小百的博客
04-15 376
在 getResources 中会获取 getResources(“classpath*:” + i18n/messages + “.properties”)，但是缺少messages.properties属性文件。3️⃣ 源码分析 MessageSourceAutoConfiguration 配置类。4️⃣ 解决：补充 messages.properties 文件。
Java IO流-字节流
qq_40603125的博客
04-15 487
上述两两结合一下，就得到四种大的分类。使用循环一个个字节输入。
Java代码基础算法练习-自定义函数之求字符串长度-2024.04.13
Sakurapaid的博客
04-13 318
写一函数，求一个字符串的长度（字符串长度不超过255），然后在主函数中调用该函数 实现求长度操作。
Java编程练习之接口的声明及实现
weixin_42204220的博客
04-14 301
System.out.println("peter:同学开始记笔记");System.out.println("mike:老师开始上课");System.out.println("peter:老师好");System.out.println("mike:同学们好");
JavaSE基础篇-2
qq_48357941的博客
04-16 373
1.概述:数组中套着多个一维数组2.定义:动态初始化数据类型[][] 数组名 = new 数据类型[m][n]数据类型 数组名[][] = new 数据类型[m][n]数据类型[] 数组名[] = new 数据类型[m][n]m:代表的是二维数组的长度->二维数组中最多能放几个一维数组n:代表的是每一个一维数组的长度->每一个一维数组中最多能放几个元素静态初始化。
Java反射技术通过什么实现的
09-16
Java反射技术通过Java语言中的反射包中的类和接口来实现的。这些类和接口提供了访问、操作和修改所谓的运行时类信息的能力。运行时类信息是指在Java程序运行时，Java虚拟机所维护的关于类和对象的信息。通过反射，...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值