JavaSE之反射

最新推荐文章于 2023-11-27 21:10:53 发布
最新推荐文章于 2023-11-27 21:10:53 发布
阅读量303 收藏
点赞数 1
分类专栏： Java基础入门 文章标签： java mybatis 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_47543906/article/details/127899366
版权

目录

Class类

Class类创建的对象我们称为Class对象/类对象/字节码对象

Class对象会保存类中的信息(构造方法, 成员方法, 成员变量等)
有了Class对象就能得到类中的所有信息。

反射的概念

在程序的运行过程中, 通过Class对象得到类中的信息(构造方法, 成员方法, 成员变量), 并操作他们

这种动态获取信息以及动态调用对象方法的功能称为Java语言的反射机制。非正常的手段操作对象。

反射的好处

使用反射创建对象，代码更复杂，无视修饰符，
功能更强大灵活

反射的应用场景

IDEA的智能提示
框架Spring/SpringMVC/Mybatis

三种获取Class对象的方式

类名.class

对象.getClass()

Class.forName(“类全名”);

注意：三种方式获取到的是同一个Class对象

public static void main(String[] args) throws ClassNotFoundException {
        // 类名.class    Class<Employee>:
        Class<Employee> cls1 = Employee.class;
        System.out.println(cls1);
        // 对象.getClass()    Class<? extends Employee>:
        Employee employee = new Employee();
        Class<? extends Employee> cls2 = employee.getClass();
        System.out.println(cls2);
        // Class.forName("类全名"); 包名.类名  第三种使用最灵活(常用),因为类不存在也能通过编译
        Class<?> cls3 = Class.forName("com.itheima.bean.Employee");
        System.out.println(cls3);
    }

Class类中的方法

String getSimpleName(); 获得类名字符串：类名

String getName(); 获得类全名：包名.类名

public static void main(String[] args) {
        // 1.得到Class对象
        Class<Employee> cls = Employee.class;
        // 2.得到类中的信息
        String name = cls.getName();
        System.out.println(name);
        String simpleName = cls.getSimpleName();
        System.out.println(simpleName);
    }

Class中获取构造器的方法

getConstructors()

getConstructor (Class<?>… parameterTypes)

getDeclaredConstructors()

getDeclaredConstructor (Class<?>… parameterTypes)

反射得到的构造器可以做什么？

创建对象

public newInstance(Object… initargs)

如果是非public的构造器，需要打开权限（暴力反射），然后再创建对象
setAccessible(boolean)

反射可以破坏封装性，私有的也可以执行了。

public class Demo06 {
    // 得到所有public的构造器: getConstructors
    @Test
    public void test01() {
        // 1.得到Class对象
        Class<Employee> cls = Employee.class;
        // 2.得到所有public的构造器
        Constructor<?>[] constructors = cls.getConstructors();
        for (Constructor o:constructors){
            System.out.println(o);
        }
    }

    // 得到一个public的构造器: getConstructor
    @Test
    public void test02() throws NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
        // 1.得到Class对象
        Class<Employee> cls = Employee.class;
        // 2.得到一个public的构造器
        Constructor<Employee> constructor = cls.getConstructor();
        System.out.println(constructor);
        Constructor<Employee> constructor1 = cls.getConstructor(String.class, int.class);
        System.out.println(constructor1);
        // Constructor<Employee> c = cls.getConstructor(); // 匹配无参 public Employee()

        // 3.使用构造器创建对象
        Employee employee = constructor.newInstance();
        Employee employee1 = constructor1.newInstance("张三", 88);
        System.out.println(employee);
        System.out.println(employee1);

    }

    // 得到所有存在的构造器: getDeclaredConstructors
    @Test
    public void test03() {
        // 1.得到Class对象
        Class<Employee> cls = Employee.class;
        // 2.得到所有存在的构造器     Declared:声明的,存在的
        //包括私有，protected等
        Constructor<?>[] constructors = cls.getDeclaredConstructors();
        for (Constructor o : constructors){
            System.out.println(o);
        }
    }

    // 得到一个存在的构造器: getDeclaredConstructor
    @Test
    public void test04() throws NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
        // 1.得到Class对象
        Class<Employee> cls = Employee.class;
        // 2.得到一个存在的构造器
        Constructor<Employee> constructor = cls.getDeclaredConstructor();
        Constructor<Employee> constructor1 = cls.getDeclaredConstructor(String.class);
        // 3.使用构造器创建对象
        Employee employee = constructor.newInstance();
        constructor1.setAccessible(true);
        Employee employee1 = constructor1.newInstance("王五");
        System.out.println(employee);
        System.out.println(employee1);
    }
}

获取成员方法对象

Class中获取成员方法的方法

getMethods()

getMethod(String name, Class<?>… parameterTypes)

getDeclaredMethods()

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

反射得到成员方法可以做什么？

依然是在某个对象中触发该方法执行。

Object invoke​(Object obj, Object… args)

如果某成员方法是非public的，需要打开权限（暴力反射），然后再触发执行
setAccessible(boolean)

public class Demo07 {
    // 得到所有public的方法: getMethods
    @Test
    public void test01() {
        // 1.得到Class对象
        Class<Employee> cls = Employee.class;
        // 2.得到所有public的方法
        Method[] methods = cls.getMethods();
        for (Method m : methods) {
            System.out.println(m);
        }
    }

    @Test
    // 得到所有存在的方法: getDeclaredMethods

    public void test02() {
        // 1.得到Class对象
        Class<Employee> cls = Employee.class;
        // 2.得到所有存在的方法
        Method[] methods = cls.getDeclaredMethods();
        for (Method m : methods) {
            System.out.println(m);
        }
    }

    // 得到一个public的方法: getMethod
    @Test
    public void test03() throws NoSuchMethodException, InvocationTargetException, IllegalAccessException, InstantiationException {
        // 1.得到Class对象
        Class<Employee> cls = Employee.class;
        // 2.得到一个public的方法
        Method setName = cls.getMethod("setName", String.class);
        // 3.调用方法
        // Object invoke(Object obj, Object... args)
        Employee instance = cls.getConstructor().newInstance();
        instance.setAge(19);
        setName.invoke(instance, "李四");

        Method getName = cls.getMethod("getName");
        Object invoke = getName.invoke(instance);
        System.out.println(invoke);
        // Object obj: 调用方法的对象
        // Object... args: 方法的参数
        // Object: 返回值

    }

    // 得到一个存在的方法: getDeclaredMethod
    @Test
    public void test04() throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
        // 1.得到Class对象
        Class<?> cls = Class.forName("com.itheima.bean.Employee");
        // 2.得到一个存在的方法
        Method sleep = cls.getDeclaredMethod("sleep", int.class);
        // 3.调用方法
        Object instance = cls.getConstructor().newInstance();
        sleep.setAccessible(true);
        Object hours = sleep.invoke(instance, 2);
        System.out.println(hours);
    }
}

获取成员变量

获取类中成员变量对象的方法

getFields()

getField(String name)

getDeclaredFields()

getDeclaredField(String name)

反射得到成员变量可以做什么？（不常用，因为我们一般通过方法来取值赋值，这样直接拿成员变量赋值效率低）

依然是在某个对象中取值和赋值。

void set​(Object obj, Object value)：

Object get​(Object obj)

如果某成员变量是非public的，需要打开权限（暴力反射），然后再取值、赋值
setAccessible(boolean)

public class Demo08 {
    // 得到所有public的成员变量: getFields
    @Test
    public void test01() {
        // 1.得到Class对象
        Class<Employee> cls = Employee.class;
        // 2.得到所有public的成员变量
        Field[] fields = cls.getFields();
        for (Field f : fields) {
            System.out.println(f);
        }
    }

    // 得到所有存在的成员变量: getDeclaredFields
    @Test
    public void test02() {
        // 1.得到Class对象
        Class<Employee> cls = Employee.class;

        // 2.得到所有存在的成员变量
        Field[] declaredFields = cls.getDeclaredFields();
        for (Field f : declaredFields) {
            System.out.println(f);
        }
    }

    // 得到一个public的成员变量: getField
    @Test
    public void test03() throws NoSuchFieldException {
        // 1.得到Class对象
        Class<Employee> employeeClass = Employee.class;
        // 2.得到Field
        Field weight = employeeClass.getField("weight");
        System.out.println(weight);
    }

    // 得到一个存在的成员变量: getDeclaredField
    @Test
    public void test04() throws NoSuchFieldException, NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
        // 1.得到Class对象
        Class<Employee> employeeClass = Employee.class;
        // 2.得到Field
        Field age = employeeClass.getDeclaredField("age");
        // 3.给成员变量赋值
        // set(Object obj, Object value);
        Employee employee = employeeClass.getConstructor().newInstance();
        age.setAccessible(true);
        age.set(employee, 99);
        // Object obj: 成员变量所在对象
        // Object value: 新的值

        // 4.获取成员变量的值

        Object o = age.get(employee);
        System.out.println(o);
        // Object get(Object obj);
        // Object obj: 成员变量所在对象
        // Object: 返回成员变量的值
    }
}

反射案例

需求: 利用反射根据文件中的不同类名和方法名，创建不同的对象并调用方法。
分析:

通过Properties加载配置文件

得到类名和方法名

通过类名反射得到Class对象

通过Class对象创建一个对象

通过Class对象得到方法

调用方法

public class Demo09 {
    public static void main(String[] args) throws Exception {
        Properties properties = new Properties();
        properties.load(new FileReader("D:\\it_workspace\\src\\config.properties"));
        String className = properties.getProperty("className");
        String methodName = properties.getProperty("methodName");
        Class<?> cls = Class.forName(className);
        Object instance = cls.getConstructor().newInstance();
        Method method = cls.getMethod(methodName);
        method.invoke(instance);
    }
}

在这里插入图片描述

Teacher
在这里插入图片描述

最后

如果你对本文有疑问，你可以在文章下方对我留言，敬请指正，对于每个留言我都会认真查看。

@爱学习的小姜
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JavaSE反射技术
10-15
JavaSE反射技术是Java编程语言中的一个重要特性，它允许程序在运行时检查和操作类、接口、字段和方法等对象。这种动态类型的能力使得Java在处理未知类或接口时具有很大的灵活性，尤其在框架和库的开发中发挥着关键...
JavaSE 高级反射-JVM篇.xmind
09-12
JavaSE 高级反射-JVM篇
JavaSE--反射
最新发布
weixin_57346120的博客
11-27 768
通过Java语言中的反射机制可以操作字节码文件。有点类似于黑客。（可以读和修改字节码文件），通过反射机制可以操作代码片段。（class文件）。java代码写一遍，再不改变Java源代码的基础之上，可以做到不同对象的实例化，非常灵活。（符合OCP开闭原则：对扩展开放，对修改关闭）。后期要学习的高级框架包括：ssh ssm、Spring SpringMVC MyBatis、Spring Struts、Hibernate这些高级框架底层实现原理：都实现了反射机制，所以反射机制还是重要的。
【JavaSE】反射
weixin_44258092的博客
08-28 261
Java的反射机制是在运行状态中，对于一个类，能够知道这个类的所有属性和方法；对于任意一个对象，能够调用它的任何方法和属性。与反射相关的类有四种，Class、Filed、Method和Constructor。需要掌握这四个类的常用方法。反射可以提高代码的灵活性和扩展性，但是降低了程序的效率。...
Java SE：反射超详解
siaok的博客
03-19 159
Override: 标记某个重写的方法@Deprecated: 标记某个类、方法已过时@SuppressWarnings: 抑制警告@Test: JUnit测试的标记语法格式：[修饰符] @interface 注解名 {可以在类、方法、成员变量等上面加注解。
JavaSE基础篇：反射（一）
七叔的博客
05-20 1万+
JavaSE基础篇：反射（一）
javaSE学习——反射
Helen_1997_1997的博客
11-16 252
javaSE学习——反射
JavaSE反射详解.ppt
06-08
JavaSE反射详解
JavaSE.zip
12-22
除此之外，JavaSE还包含丰富的内置类库，如集合框架（ArrayList、LinkedList、HashMap、HashSet等）、I/O流（用于文件读写和网络通信）、线程处理（实现多任务并行执行）、反射API（在运行时动态访问类的信息）等。...
JavaSE.xmind
05-08
Java基础语法，面向对象，API, 集合，IO流，泛型，异常，线程，枚举，网络编程，反射，注解，新特性
Javase反射基础
m0_51654746的博客
03-27 713
所有的有关反射的东西都在java.lang.reflect包下，在java.lang包下的所有东西都不需要导包 获取Class对象 所有的反射操作都是基于Class对象来进行的，所以获取Class对象非常关键 有三种获取的方法 利用getClass()方法进行获取，自定义类亦可以使用，因为他是封装在Object类中，所有的类都默认继承Object类，需要使用对象名调用 利用Class类中的class属性，java中所有的数据类型都有class属性,注意：一定要使用类名来获取属性，使用对象名无法获取到c
Java基础之—反射（非常重要）
热门推荐
sinat_38259539的博客
05-13 72万+
反射是框架设计的灵魂 （使用的前提条件：必须先得到代表的字节码的Class，Class类用于表示.class文件（字节码）） 一、反射的概述 JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。 要想解剖一个类,必须先要获取到该类的
JavaSE——反射
Mr_Jett的博客
04-23 253
获取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()); //
JavaSE 第十八章 反射
技术小白
03-23 628
Reflection（反射）是被视为动态语言的关键，反射机制允许程序在执行期借助于Reflection API取得任 何类的内部信息，并能直接操作任意对象的内部属性及方法。 加载完类之后，在堆内存的方法区中就产生了一个Class类型的对象（一个类只有一个Class对象），这 个对象就包含了完整的类的结构信息。我们可以通过这个对象看到类的结构。这个对象就像一面镜子， 透过这个镜子看到类的结构，所以，我们形象的称之为：反射。 动态语言 是一类在运行时可以改变其结构的语言：例如新的函数、对象、甚至代码可以被
java SE 反射机制
a2401877437的专栏
09-19 454
反射 一个类有多个组成部分，例如：成员变量，方法，构造方法等。反射就是加载类，并解剖出类的各个组成部分。 编程时什么情况下才需要加载类，并解剖出类的各个组成部分呢？ Java反射所需要的类并不多，主要有java.lang.Class类和java.lang.reflect包中的Field、Constructor、Method、Array类。 注意：Class类是Java反射的起源，针对任何一
JAVA SE——反射
qq_20834769的博客
03-13 248
反射:通过一个第三方元素来描述”.class”的类文件.从而使内存与硬盘之间产生一种映射关系叫做反射。 1.      所谓的加载并不是对“.class”类文件的真实拷贝，而是将其在堆内存中产生一个映射，像镜子一样将其从硬盘反映到堆内存。 2.      五大映射元素 目的：描述类和类中的成员，与对象无关 （1）      Class                      类
JavaSE--反射技术
weixin_53860901的博客
05-31 128
前言 其实之前就该把这一个篇章写了的，但是一直拖了这么久，也已经在找实习了。所以这篇博客补上，就当做复习啦。 一丶反射 1.什么是反射？ 首先对于什么是反射我们需要一些问题来反衬出来，这样来进行问题的场景设置。当我们进行Web项目开发的时候，我们使用了Servlet接口来处理用户请求，但是程序员自己没有创建Servlet对象，那么Servlet对象谁创建的？再如果说有一个类为私有类，也就是说其中的方法和属性全都是私有的，那么我们想要访问或者说使用这个类当中的方法和属性要怎么办呢？再或者说如果有一个类总是变动
JavaSE 反射机制
JavaLab
06-17 432
反射机制是什么反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。 要想解剖一个类,必须先要获取到该类的字节码文件对象，而解剖使用的就是Class类中的方法，所以先要获取到每一个字节码文件对应的Class类型的对象。反射机制能做什么反射机制主要提供了以下
atguigu_Day_01随堂笔记1.pdf
10-04
在JavaSE课程中，我们会学习Java的基础语法、面向对象思想、常用API、集合板块、IO板块、多线程、网络编程、反射、注解、枚举等知识点。同时，我们还会了解JDK8的新特性，如Lambda表达式、方法引用和Stream流，这些...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值