JavaSE基础学习——反射

最新推荐文章于 2023-01-13 19:30:28 发布
最新推荐文章于 2023-01-13 19:30:28 发布
阅读量218 收藏 2
点赞数 1
文章标签： java idea
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/weixin_44018911/article/details/124365898
版权

1. 反射概述

1.1 概述

  • 反射是指对于任何一个Class类，在“运行的时候”都可以直接得到这个类的全部成分
  • 在运行时，可以直接得到这个类的构造器对象：Constructor
  • 在运行时，可以直接得到这个类的成员变量对象：Field
  • 在运行时，可以直接得到这个类的成员方法对象：Method
  • 这种运行时动态获取类信息以及动态调用类中成分的能力称为Java语言的反射机制

1.2 反射的关键

  • 反射的第一步都是先得到编译后的Class类对象，然后就可以得到Class的全部成分
    在这里插入图片描述

2. 反射获取类对象

  • 反射的第一步：获取Class类对象，如此才可以解析类的全部成分
  • 获取Class类的对象的三种方式
/**
    目标：反射第一步：获取Class对象
 */
public class Test {
    public static void main(String[] args) throws Exception {
        // 1、Class类中的一个静态方法：forName（全限名： 包名 + 类名）
        Class c = Class.forName("com.lenyoo.d2_reflect_class.Student");
        System.out.println(c); // Student

        // 2、类名.class
        Class c1 = Student.class;
        System.out.println(c1);

        // 3、对象.getClass() 获取对象对应类的Class对象
        Student s = new Student();
        Class c2 = s.getClass();
        System.out.println(c2);
    }
}

3. 反射获取构造器对象

3.1 利用反射技术获取构造器对象的方式

public class TestStudent01 {

    // 2.getDeclaredConstructors():（推荐）
    // 获取全部的构造器：只要你敢写，这里就能拿到，无所谓权限是否可及。
    @Test
    public void getDeclaredConstructors(){
        // a.第一步：获取类对象
        Class c = Student.class;
        // b.提取类中的全部的构造器对象
        Constructor[] constructors = c.getDeclaredConstructors();
        // c.遍历构造器
        for (Constructor constructor : constructors) {
            System.out.println(constructor.getName() + "===>" + constructor.getParameterCount());
        }
    }

    // 4.getDeclaredConstructor(Class... parameterTypes)（推荐）
    // 获取某个构造器：只要你敢写，这里就能拿到，无所谓权限是否可及。
    @Test
    public void getDeclaredConstructor() throws Exception {
        // a.第一步：获取类对象
        Class c = Student.class;
        // b.定位单个构造器对象（按照参数定位无参数构造器）
        Constructor cons = c.getDeclaredConstructor();
        System.out.println(cons.getName() + "===>" + cons.getParameterCount());

        // c.定位某个有参构造器
        Constructor cons1 = c.getDeclaredConstructor(String.class, int.class);
        System.out.println(cons1.getName() + "===>" + cons1.getParameterCount());
    }

}

3.2 反射得到的构造器用途

  • T newInstance(Object… initargs)
    创建对象，注入构造器需要的数据。
  • void setAccessible(true)
    修改访问权限，true代表暴力攻破权限，false表示保留不可访问权限(暴力反射)
    反射可以破坏封装性，私有的也可以执行了
public class TestStudent02 {
    // 1.调用构造器得到一个类的对象返回。
    @Test
    public void getDeclaredConstructor() throws Exception {
        // a.第一步：获取类对象
        Class c = Student.class;
        // b.定位单个构造器对象 (按照参数定位无参数构造器)
        Constructor cons = c.getDeclaredConstructor();
        System.out.println(cons.getName() + "===>" + cons.getParameterCount());

        // 如果遇到了私有的构造器，可以暴力反射
        cons.setAccessible(true); // 权限被打开

        Student s = (Student) cons.newInstance();
        System.out.println(s);

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

        // c.定位某个有参构造器
        Constructor cons1 = c.getDeclaredConstructor(String.class, int.class);
        System.out.println(cons1.getName() + "===>" + cons1.getParameterCount());

        Student s1 = (Student) cons1.newInstance("孙悟空", 1000);
        System.out.println(s1);

    }
}

4. 反射获取成员变量对象

4.1 利用反射技术获取成员变量的方式

  • getDeclaredFields()
  • getDeclaredField (String name)
public class FieldDemo01 {
    /**
     * 1.获取全部的成员变量。
     * Field[] getDeclaredFields();
     *  获得所有的成员变量对应的Field对象，只要申明了就可以得到
     */
    @Test
    public void getDeclaredFields(){
        // a.定位Class对象
        Class c = Student.class;
        // b.定位全部成员变量
        Field[] fields = c.getDeclaredFields();
        // c.遍历一下
        for (Field field : fields) {
            System.out.println(field.getName() + "==>" + field.getType());
        }
    }
    
    /**
     2.获取某个成员变量对象 Field getDeclaredField(String name);
     */
    @Test
    public void getDeclaredField() throws Exception {
        // a.定位Class对象
        Class c = Student.class;
        // b.根据名称定位某个成员变量
        Field f = c.getDeclaredField("age");
        System.out.println(f.getName() + "==>" + f.getType());
    }
}

4.2 反射得到成员变量用途

  • 依然是在某个对象中取值和赋值。
    void set (Object obj, Object value)：
    Object get (Object obj)
  • 如果某成员变量是非public的，需要打开权限（暴力反射），然后再取值、赋值
    setAccessible(boolean)
public class FiledDemo02 {
    @Test
    public void setField() throws Exception {
        // a.反射第一步，获取类对象
        Class c = Student.class;
        // b.提取某个成员变量
        Field ageF = c.getDeclaredField("age");

        ageF.setAccessible(true); // 暴力打开权限

        // c.赋值
        Student s = new Student();
        ageF.set(s, 18); // s.setAge(18);
        System.out.println(s);

        // d.取值
        int age = (int)ageF.get(s);
        System.out.println(age);
    }
}

5. 反射获取方法对象

5.1 利用反射技术获取成员方法对象的方式

  • getDeclaredMethods()
  • getDeclaredMethod (String name, Class<?>… parameterTypes)

5.2 反射得到成员方法的用途

  • 在某个对象中触发该方法执行。
    Object invoke (Object obj, Object… args)
  • 如果某成员方法是非public的，需要打开权限（暴力反射），然后再触发执行
    setAccessible(boolean)
public class MethodDemo01 {
    /**
     * 1.获得类中的所有成员方法对象
     */
    @Test
    public void getDeclaredMethods(){
        // a.获取类对象
        Class c = Dog.class;
        // b.提取全部方法：包括私有的
        Method[] methods = c.getDeclaredMethods();
        // c.遍历全部方法
        for (Method method : methods) {
            System.out.println(method.getName() + " 返回值类型：" + method.getReturnType() + " 参数个数：" + method.getParameterCount());
        }
    }

    /**
     * 2. 获取某个方法对象
     */
    @Test
    public void getDeclardMethod() throws Exception{
        // a.获取类对象
        Class c = Dog.class;
        // b.提取单个方法对象
        Method m = c.getDeclaredMethod("eat");
        Method m2 = c.getDeclaredMethod("eat", String.class);

        // 暴力打开权限
        m.setAccessible(true);
        m2.setAccessible(true);

        // c.触发方法的执行
        Dog d = new Dog();
        // 注意：方法如果是没有结果回来的，那么返回的是null;
        Object result = m.invoke(d);
        System.out.println(result);

        Object result2 = m2.invoke(d, "骨头");
        System.out.println(result2);
    }
}

public class Dog {
    private String name ;
    public Dog(){
    }

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

    public void run(){
        System.out.println("狗跑的贼快~~");
    }

    private void eat(){
        System.out.println("狗吃骨头");
    }

    private String eat(String name){
        System.out.println("狗吃" + name);
        return "吃的很开心！";
    }

    public static void inAddr(){
        System.out.println("在黑马学习Java!");
    }

    public String getName() {
        return name;
    }

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

}

6. 反射的作用

6.1 绕过编译阶段为集合添加数据

  • 反射是作用在运行时的技术，此时集合的泛型将不能产生约束了，此时是可以为集合存入其他任意类型的元素的。
  • 泛型只是在编译阶段可以约束集合只能操作某种数据类型，在编译成Class文件进入运行阶段的时候，其真实类型都是ArrayList了，泛型相当于被擦除了。
  • 反射是作用在运行时的技术，此时已经不存在泛型了。
public class ReflectDemo {
    public static void main(String[] args) throws Exception {
        // 需求：反射实现泛型擦除后，加入其他类型的元素
        ArrayList<String> list1 = new ArrayList<>();
        ArrayList<Integer> list2 = new ArrayList<>();
        System.out.println(list1.getClass());
        System.out.println(list2.getClass());

        System.out.println(list1.getClass() == list2.getClass()); // ArrayList.class

        System.out.println("-------------------------");
        ArrayList<Integer> list3 = new ArrayList<>();
        list3.add(23);
        list3.add(22);
        // list3.add("黑马");
        Class c = list3.getClass(); // ArrayList.class ===> public boolean add(E e)
        // 定位c类中的add方法
        Method add = c.getDeclaredMethod("add", Object.class);
        boolean rs = (boolean) add.invoke(list3, "黑马");
        System.out.println(rs);

        System.out.println(list3);

    }
}

6.2 通用框架的底层原理

public class MybatisUtil {
    /**
     保存任意类型的对象
     * @param obj
     */
    public static void save(Object obj){
        try (
                PrintStream ps = new PrintStream(new FileOutputStream("junit-reflect-annotation-proxy-app/src/data.txt", true))
        ){
            // 1、提取这个对象的全部成员变量：只有反射可以解决
            Class c = obj.getClass(); // c.getSimpleName()获取当前类名 c.getName获取全限名：包名+类名
            ps.println("=============" + c.getSimpleName() + "=============");
            // 2、提取它的全部成员变量
            Field[] fields = c.getDeclaredFields();
            // 3、获取成员变量的信息
            for (Field field : fields) {
                String name = field.getName();
                // 提取本成员变量在obj对象中的值（取值）
                field.setAccessible(true);
                String value = field.get(obj) + "";
                ps.println(name + "=" + value);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

/**
    目标：提供一个通用框架，支持保存所有对象的具体信息。
 */
public class ReflectDemo {
    public static void main(String[] args) throws Exception{
        Student s = new Student();
        s.setName("猪八戒");
        s.setClassName("西天跑路1班");
        s.setAge(1000);
        s.setHobby("吃，睡");
        s.setSex('男');
        MybatisUtil.save(s);

        Teacher t = new Teacher();
        t.setName("波仔");
        t.setSex('男');
        t.setSalary(6000);
        MybatisUtil.save(t);
    }
}
KnightZer0
关注
JavaSE 反射——使用反射调用方法
Lv Zejiang
10-09 317
Java自我学习路线一、使用反射调用方法二、invoke()1. 实现原理 一、使用反射调用方法 四关键 对象 方法名 实参列表 返回值 public class User { public int id; private String name; String address; protected int sno; public User() {} public User(int id, String name, String address, int sno) {
JavaSE——单元测试、反射、注解、动态代理
qq_46002941的博客
01-28 1070
文章目录单元测试单元测试概述单元测试快速入门单元测试常用注解反射反射概述反射获取类对象反射获取构造器对象反射获取成员变量对象反射获取方法对象反射的作用-绕过编译阶段为集合添加数据反射的作用-通用框架的底层原理注解注解概述自定义注解元注解注解解析案例：注解解析的案例注解的应用场景一：Junit框架动态代理 单元测试 单元测试概述 单元测试 单元测试就是针对最小的功能单元编写测试代码，Java程序最小的功能单元是方法，因此，单元测试就是针对Java方法的测试，进而检查方法的正确性。 目前测试方法是怎么进行
JavaSE——反射
Mr_Jett的博客
04-23 320
获取Class对象的三种方式 public class Test01 { public static void main(String[] args) { // 通过 类的 Class对象 获取类的加载器 // ClassLoader cl1 = String.class.getClassLoader(); // System.out.println(cl1); // // System.out.println(Test01.class.getClassLoader()); //
java反射（调用运行时类的指定结构）
qq_46100517的博客
03-15 204
属性、方法、构造器 package com.company2; import com.company1.Person; import org.junit.Test; import java.lang.reflect.Constructor; import java.lang.reflect.Field; import java.lang.reflect.Method; /** * 调用运行时类中指定的结构：属性、方法、构造器 */ public class ReflectionTest {
Java反射运行时_Java反射总结
weixin_30356285的博客
02-26 155
反射(java.lang.reflect)用于分析类能力(一)Class类1.定义Java运行时为每一个对象都维护的一个类型标识，用于跟踪对象所属的类提供给虚拟机分析调用，而保存这些信息的类就是Class类(一个Class类对象可以理解为一个类型，这个类型可以是类或基本数据类型int等)2.作用通过对象所属的Class类，我们可以获取对象类型的数据域，方法，父类等一切类信息，还可以用它来创建实例对...
Java反射:运行时的类信息
分享传递价值
03-15 755
java中的反射首先要获取到反射类的字节码，然后将字节码中的变量、方法、构造函数等映射成Field、Method、Constructor类，接着便可以使用这些反射生成的类了。获取类的字节码有如下三种方法 public class Demo { public static void main(String[] args) throws ClassNotFoundException { ...
Java基础 学习笔记 Markdownr版
06-27
本学习笔记主要涵盖了Java的基础知识，包括面向对象、集合、IO流、多线程、反射与动态代理以及Java 8的新特性等方面，旨在帮助初学者或有经验的开发者巩固和提升Java编程技能。 1. 面向对象（OOP）：Java的核心是...
Java SE核心：探索动态机制——反射
1. **基础掌握**：学习者需深入理解Java语言的基础知识，包括数据类型、控制流、类和对象等概念。 2. **面向对象编程**：重点讲解封装、继承、多态等面向对象设计原则，以及如何在Java中实现这些特性。 3. **实战...
【大数据开发阶段一】Javase 基础知识点总结（基础篇）【持续更新】
skyman30的博客
01-13 763
本文是对大数据开发中第一阶段javase学习的知识点总结，在持续更新中，希望可以和大家交流学习，有不足及错误请大家指出。
动力节点JavaSE的基础学习笔记（2021.11.01——11.22）
weixin_42346671的博客
11-22 1356
1、windows相关的DOS命令： *打开方式 win+R 接着输入cmd就可以打开了 *常见的DOS命令有哪些 - exit 退出当前命令 - cls 清除屏幕 - 复制方法只需要选中即可，这个和视频当中是有区别的 - dir 显示当前文件夹里面包含的目录 - cd 表示进入当前的文件夹 *使用方法 cd+路径 *路径分为绝对路径和相对路径 *绝对路径的指向是给定的，具有完整的路径 *相对路径是在当前目录下进一步延申的路径 *例如绝对路径为cd C:\Users\19766\Desktop，相对路径为
Java中的反射
qq_58000391的博客
06-21 295
Java高级框架常用的技术——反射
java反射在编译之后_Java反射-再次认识
weixin_39531582的博客
02-27 151
最近的学习发现在很多方面，基础知识掌握的还很不牢固，所以对于架构、知识点等属于那种问啥啥知道，做啥啥不出来的那种类型。前些日子，老师一直在抓基础，做什么都要从最简单的demo开始，只有懂了原理之后再去用一些高深的东西如框架等才会理解的更深刻。现在首先需要理解的就是基本上每个Java框架都在用的反射技术。要想理解反射，首先得了解类的加载过程，看下图： 我们的源代码经过编译之后变成字节码，然后在JVM...
java反射
m0_62520968的博客
05-07 288
Java 反射机制是 Java 语言的一个重要特性。在学习 Java 反射机制前，大家应该先了解两个概念，编译期和运行期。 编译期是指把源码交给编译器编译成计算机可以执行的文件的过程。在 Java 中也就是把 Java 代码编成 class 文件的过程。编译期只是做了一些翻译功能，并没有把代码放在内存中运行起来，而只是把代码当成文本进行操作，比如检查错误。 运行期是把编译后的文件交给计算机执行，直到程序运行结束。所谓运行期就把在磁盘中的代码放到内存中执行起来。 Java 反射机制是在运行状态中，对于任意一个
反射的使用(java)
weixin_43142816的博客
08-21 335
1.使用反射的好处是什么? 在java中我们使用类的方法时，一般的操作是new一个对象，然后使用这个对象直接调用方法。但是你知道吗？这种形式的调用存在着缺点，试想一下，如果我们有多个Java Bean类，里面的参数类型和个数都相同，它们都有set方法。使用这些Bean类时，我们都需要分别调用它们各自独有的set方法，这种方式的使用增加了我们的代码量，那么我们有什么方法可以减少这些代码量吗？答案肯定是有的，没错，正是我们这次的课题，java 放射，反射的使用除了可以减少不必要的代码量，还可以调用类私有、保护的
借助于java的反射机制_Java基础篇：反射机制详解
weixin_32593721的博客
02-13 275
一、什么是反射：(1)Java反射机制的核心是在程序运行时动态加载类并获取类的详细信息，从而操作类或对象的属性和方法。本质是JVM得到class对象之后，再通过class对象进行反编译，从而获取t对象的各种信息。(2)Java属于先编译再运行的语言，程序中对象的类型在编译期就确定下来了，而当程序在运行时可能需要动态加载某些类，这些类因为之前用不到，所以没有被加载到JVM。通过反射，可以在运行时动态...
JAVA反射调用详解
Aka丶的博客
05-04 8111
JAVA反射调用的确是一种很神奇的机制，在项目中使用后恋恋不忘，现将其好好整理一下。 参考： 学习JAVA应该如何理解反射？知乎 https://www.zhihu.com/question/24304289 全面细致讲解反射机制系列 http://www.365yg.com/item/6414118008049893889/?iid=9697930986&app=news_artic
如何在运行时使用反射来调用Java方法
一名可爱的技术搬运工
05-21 279
反射是一种在运行时处理Java类的非常有用的方法，它可用于加载Java类，调用其方法或在运行时分析该类。 在此示例中，您将加载一个名为“ AppTest ”的类，并在运行时调用其每个方法。 1. AppTest.java 稍后将在运行时调用此Java类及其方法 package com.mkyong.reflection; public class AppTest{ pri...
一篇文章搞定你不得不懂的反射！
starstar2014的博客
03-25 360
微信公众号：程序媛的非程序人生 关注可了解更多资讯。问题或建议，请公众号留言; 内容目录 一、反射相关概念 二、应用场景 三、反射中Class的获取方式 四、创建类对象的方式 五、用代码说话 六、反射优缺点 一、反射相关概念 1、编译期 & 运行期 编译期：编译器把源代码翻译成机器能识别的代码，如Java代码编译成jvm识别的字节码文件。 运行期：将可执行文件交给操...
java反射取返回值_Java反射（Reflection）获取运行时类的结构
weixin_30989967的博客
02-27 1248
目 录(本篇字数：1358)· 简介Java Reflection，称为 Java 反射，是Java基础部分的一个比较难的点。Reflection(反射)是被视为动态语言的关键，通过反射机制，我们可以在运行时(runtime)获取类的完整结构。例如，可以获取到类的变量名、方法、构造器、内部类、接口、注解等等，并且通过反射机制可以对类内部进行操作。Java反射机制在实际开发中是非常常用的，强...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值