Java学习之路（十五）：反射

最新推荐文章于 2024-08-11 09:51:52 发布
最新推荐文章于 2024-08-11 09:51:52 发布
阅读量164 收藏
点赞数
分类专栏： JAVA 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42826747/article/details/107218593
版权

一、Java反射机制概述

  • Reflection(反射) 是被视为动态语言的关键，反射机制允许程序在执行期间借助于Reflection API 取得任何类的内部信息，并能直接操作任意对象的内部属性及方法。
  • 加载完类之后，在堆内存的方法区中就产生了一个Class类型的对象（一个类只有一个Class对象），这个对象就包含了完整的类的结构信息。我们可以通过这个对象看到类的结构。这个对象就像一面镜子，透过这个镜子看到类的结构，所以，我们形象的称之为： 反射 。
    在这里插入图片描述
  • Java反射机制提供的功能
    1. 在运行时判断任意一个对象所属的类
    2. 在运行时构造任意一个类的对象
    3. 在运行时判断任意一个类所具有的成员变量和方法
    4. 在运行时获取泛型信息
    5. 在运行时调用任意一个对象的成员变量和方法
    6. 在运行时处理注解
    7. 生成动态代理
  • 反射相关的主要API
    1. java.lang.Class：代表一个类（用来描述类的一个类）
    2. java.lang.reflect,Method：代表类的方法
    3. java.lang.reflect.Field：代表类的成员变量
    4. java.lang.reflect.Constructor：代表类的构造器
    5. … …

补充：动态语言 Vs 静态语言

  1. 动态语言：是一类在运行时可以改变其结构的语言：例如新的函数、对象、甚至代码可以被引进。已有的函数可以被删除或是其他结构上的变化。通俗点说就是在运行时代码可以根据某些条件改变自身结构。
    主要动态语言：Object-c、c#、JavaScript、PHP、Python、Erlang
  2. 静态语言：与动态语言相对应的，运行时结构不可变的语言就是静态语言，如Java、C、C++
  • Java不是动态语言，但Java可以称之为准动态语言。即Java有一定的动态性，我们可以利用反射机制、字节码操作获得类似动态语言的特性

二、理解Class类并获取Class实例

1. 关于java.lang.Class类的理解

  1. 类的加载过程：
    ① 程序经过javac.exe命令(编译)以后，会生成一个或多个字节码文件（.class结尾）。
    ② 接着我们使用java.exe命令对某个字节码文件进行解释运行。相当于将某个字节码文件加载到内存中。此过程称为类的加载。加载到内存中的类，我们就称之为运行时类，此运行时类就作为Classd的一个实例
  2. 换句话说，Class的一个实例对象就对应着一个运行时类
  3. 加载到内存中的运行时类，会缓存一定的时间。在此时间之内，我们可以通过不同的方式来获取此运行时类。
  4. 哪些类型可以有Class对象
    ① class，外部类，成员（成员内部类，静态内部类），局部内部类，匿名内部类
    ②interface接口
    ③[]，数组，只要数组的元素的类型和维度一致，就是同一个Class
    ④enum，枚举
    ⑤annotation，注解@interface
    ⑥primitive，基本数据类型
    ⑦void

2. 获取Class实例的方式

@Test
    public void test2() throws ClassNotFoundException {
        //方式一：调用运行时类的属性 .class
        Class clazz1 = Person.class;
        System.out.println(clazz1);
        //方式二：调用运行时类的对象的方法，getClass()
        Person person = new Person();
        Class clazz2 = person.getClass();
        System.out.println(clazz2);
        //方式三：调用Class的静态方法，forName(String className),类的全称
        Class clazz3 = Class.forName("Person");
        System.out.println(clazz3);

        System.out.println(clazz1 == clazz2);
        System.out.println(clazz1 == clazz3);

        //方式四：调用类的加载器：ClassLoader (了解)
        ClassLoader classLoader = ReflectionTest.class.getClassLoader();
        Class clazz4 = classLoader.loadClass("Person");
        System.out.println(clazz4);
        System.out.println(clazz1 == clazz4);

    }

三、类的加载与ClassLoader的理解

1. 类的加载

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

2.类的加载器与ClassLoader的理解

在这里插入图片描述
在这里插入图片描述

@Test
    public void test1(){
        //对于自定义类，使用系统类加载器加载
        ClassLoader classLoader = ClassLoaderTest.class.getClassLoader();
        System.out.println(classLoader);
        //调用系统类加载器的getParent()方法，获取扩展类加载器
        ClassLoader classLoader1 = classLoader.getParent();
        System.out.println(classLoader1);
        //调用扩展类加载器的getParent()，无法获取引导类加载器
        //引导类加载器主要负责加载java的核心库类，无法加载自定义类
        ClassLoader classLoader2 = classLoader1.getParent();
        System.out.println(classLoader2);
    }

四、创建运行时类的对象

  • newInstance()：调用此方法，创建对应的运行时类的对象。内部调用了运行时类的空参构造器
  • 要想调用此方法正常的创建运行时类的对象，要求：
    1. 运行时类的必须提供空参构造器
    2. 空参构造器的访问权限得够，通常，设置为public
  • 补充：在javabean中要求提供一个public的空参构造器，原因：
    1. 便于通过反射，创建运行时类的对象
    2. 便于子类继承此运行时类是，默认调用super()是，保证父类有此构造器
import org.junit.Test;

/**
 * @author ZC
 * @Description  通过反射创建对应的运行时类的对象
 * @date 2020-07-11 17:18
 */
public class NewInstanceTest {

    @Test
    public void test() throws ClassNotFoundException, IllegalAccessException, InstantiationException {

        Class<Person> clazz = Person.class;
        Person p = clazz.newInstance();
        System.out.println(p);
    }
}

五、获取运行时类的完整结构

package java2;

import java1.Person;
import org.junit.Test;

import java.lang.reflect.Field;
import java.lang.reflect.Modifier;

/**
 * @author ZC
 * @Description 获取运行时类的属性
 * @date 2020-07-11 17:53
 */
public class FieldTest {

    //获取属性的完整结构
    @Test
    public void test() throws Exception{
        Class clazz = Class.forName("java1.Person");
        //获取属性结构

        //getFields()：获取当前运行时类及其父类中声明为public访问权限的属性
        Field[] fields = clazz.getFields();
        for (Field f: fields
             ) {
            System.out.println(f);
        }
        System.out.println("*****************");

        //getDeclaredFields()：获取当前运行时类中声明的所有属性（不包括父类中声明的属性）
        Field[] declaredFields = clazz.getDeclaredFields();
        for (Field f:declaredFields
             ) {
            System.out.println(f);
        }
    }

    //获取属性的某个结构：权限修饰符、数据类型、属性名
    @Test
    public void test2(){
        Class clazz = Person.class;

        Field[] fields = clazz.getFields();
        for (Field f:fields
             ) {
            //1. 权限修饰符
            int modifiers = f.getModifiers();
            System.out.print(Modifier.toString(modifiers) +"\t");
            //2. 数据类型
            Class<?> type = f.getType();
            System.out.print(type.getName()+"\t");
            //3. 变量名
            String name = f.getName();
            System.out.print(name);

            System.out.println();
        }
    }
}


package java2;

import java1.Person;
import org.junit.Test;

import java.lang.annotation.Annotation;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;

/**
 * @author ZC
 * @Description  获取运行时类的方法
 * @date 2020-07-11 22:47
 */
public class MethodTest {

    @Test
    public void test(){
        Class clazz = Person.class;
        //getMethod()：获取当前运行时类及其所有父类声明为public权限的方法
        Method[] methods = clazz.getMethods();
        for (Method m: methods
             ) {
            System.out.println(m);
        }
        //getDeclaredMethod()：获取当前运行时类中声明的所有方法。（不包括父类中声明的方法）
        Method[] declaredMethods = clazz.getDeclaredMethods();
        for (Method m:declaredMethods
             ) {
            System.out.println(m);
        }

    }

    /**
     * @Xxxx
     * 权限修饰符 返回值类型 方法名(参数类型1，参数类型2，...) thorws XxxException{}
     */
    @Test
    public void test1(){
        Class clazz = Person.class;

        Method[] declaredMethods = clazz.getDeclaredMethods();
        for (Method m:declaredMethods
             ) {
            //1. 获取方法的注解
            Annotation[] annotations = m.getAnnotations();
            for (Annotation anno: annotations
                 ) {
                System.out.println(anno);
            }
            //2. 权限修饰符
            System.out.print(Modifier.toString(m.getModifiers()) + "\t");
            //3. 返回值类型
            System.out.print(m.getReturnType().getName()+"\t");
            //4. 方法名
            System.out.print(m.getName());
            //5. 形参类型
            Class<?>[] parameterTypes = m.getParameterTypes();
            System.out.print("(");
            if (parameterTypes != null && parameterTypes.length != 0){
                for (int i = 0; i < parameterTypes.length; i++) {
                    if (i == parameterTypes.length-1){
                        System.out.print(parameterTypes[i].getName()+" args_"+i);
                        break;
                    }
                    System.out.print(parameterTypes[i].getName()+" args_"+i+",");
                }
            }
            System.out.print(")");
            //6. 抛出的异常
            Class<?>[] exceptionTypes = m.getExceptionTypes();
            if (!(exceptionTypes == null || exceptionTypes.length == 0)){
                System.out.print("throws ");
                for (int i = 0; i < exceptionTypes.length; i++) {
                    if (i == exceptionTypes.length-1){
                        System.out.print(exceptionTypes[i].getName());
                        break;
                    }
                    System.out.print(exceptionTypes[i].getName()+",");

                }
            }

            System.out.println();

        }

    }
}


package java2;

import java1.Person;
import org.junit.Test;

import java.lang.annotation.Annotation;
import java.lang.reflect.Constructor;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;

/**
 * @author ZC
 * @Description  获取运行时类的其他结构
 * @date 2020-07-11 23:38
 */
public class OtherTest {

    //获取运行时类的构造器
    @Test
    public void test1(){
        Class clazz = Person.class;
        //getConstructors()：获取当前运行时类中声明为public的构造器
        Constructor[] constructors = clazz.getConstructors();
        for (Constructor c: constructors
             ) {
            System.out.println(c);
        }
        System.out.println();
        //getDeclaredConstructors()：获取当前运行时类声明的所有构造器
        Constructor[] declaredConstructors = clazz.getDeclaredConstructors();
        for (Constructor c:declaredConstructors
             ) {
            System.out.println(c);
        }
    }

    //获取运行时类的父类
    @Test
    public void test2(){
        Class clazz = Person.class;
        Class superClass = clazz.getSuperclass();
        System.out.println(superClass);
    }

    //获取运行时类带泛型的父类
    @Test
    public void test3(){
        Class clazz = Person.class;
        Type genericSuperclass = clazz.getGenericSuperclass();
        System.out.println(genericSuperclass);
    }

    //获取运行时类带泛型的父类的泛型
    @Test
    public void test4(){
        Class clazz = Person.class;
        Type genericSuperclass = clazz.getGenericSuperclass();
        ParameterizedType paramType = (ParameterizedType)genericSuperclass;
        //获取泛型类型
        Type[] actualTypeArguments = paramType.getActualTypeArguments();
        //System.out.println(actualTypeArguments[0].getTypeName());
        System.out.println(((Class) actualTypeArguments[0]).getName());
    }

    //获取运行时类实现的接口
    @Test
    public void test5() throws ClassNotFoundException {
        Class clazz = Class.forName("java1.Person");
        Class[] interfaces = clazz.getInterfaces();
        for (Class inter:interfaces
             ) {
            System.out.println(inter);
        }
        System.out.println();
        //获取运行时类的父类实现的接口
        Class[] interfaces1 = clazz.getSuperclass().getInterfaces();
        for (Class inter: interfaces1
             ) {
            System.out.println(inter);
        }
    }

    //获取运行时类所在的包
    @Test
    public void test6(){
        Class clazz = Person.class;
        Package pack = clazz.getPackage();
        System.out.println(pack);
    }

    //获取运行时类的注解
    @Test
    public void test7(){
        Class clazz = Person.class;
        Annotation[] annotations = clazz.getAnnotations();
        for (Annotation a:annotations
             ) {
            System.out.println(a);
        }
    }

}

六、调用运行时类的指定结构

package java2;

import java1.Person;
import org.junit.Test;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;

/**
 * @author ZC
 * @Description  获取运行时类的指定结构
 * @date 2020-07-14 0:26
 */
public class ReflectionTest {

    //获取指定的属性
    @Test
    public void testField() throws IllegalAccessException, InstantiationException, NoSuchFieldException {
        Class clazz = Person.class;

        Person p = (Person) clazz.newInstance();

        //getField()获取指定变量名的的属性，要求运行时类中属性声明为public（通常不使用此方法）
        Field id = clazz.getField("id");

        /**
         * set()： 参数1：指明设置哪个对象的属性   参数2：将此属性值设置为多少
         */
        id.set(p,1001);

        /**
         *获取当前属性的值
         * get()：参数1：获取哪个对象的当前属性值
         */
        id.get(p);
    }

    //如何操作运行时类的指定属性————需要掌握
    @Test
    public void testField1() throws IllegalAccessException, InstantiationException, NoSuchFieldException {
        Class clazz = Person.class;
        //创建运行时类的对象
        Person p = (Person) clazz.newInstance();

        //1. getDeclaredField():获取指定变量名的属性
        Field name = clazz.getDeclaredField("name");

        //2. 保证当前属性是可访问的
        name.setAccessible(true);

        //3. 获取、设置指定对象的此属性值
        name.set(p,"TOM");
        name.get(p);
    }

    //如何操作运行时类的指定方法————需要掌握
    @Test
    public void testMethod() throws Exception {
        Class clazz = Class.forName("java1.Person");

        //创建运行时类的对象
         Person p = (Person) clazz.newInstance();
        /**
         * 1. 获取某个指定的方法
         * getDeclaredMethod()：参数1：指明获取的方法名称   参数2：指明获取的方法的形参列表
         */
        Method show = clazz.getDeclaredMethod("show",String.class);
        /**
         * 2. 保证当前方法是可访问的
         */
        show.setAccessible(true);

        /**
         * 3. 调用该方法的invoke()
         * invoke()：参数1：方法的调用者  参数2：给方法形参赋值的实参
         * invoke()方法的返回值即为对应类中调用的方法的返回值,
         * 如果没有返回值，则invoke()方法返回null
         */
        show.invoke(p,"China");


        /**
         * 调用静态方法
         */
        Method showDesc = clazz.getDeclaredMethod("showDesc");
        showDesc.setAccessible(true);
        showDesc.invoke(clazz);//Person.class,null
    }

    //如何操作运行时类的指定构造器
    @Test
    public void test() throws Exception{
        Class clazz = Person.class;

        //1. 获取指定的构造器
        //getDeclaredConstructor()：参数：指明构造器的参数列表
        Constructor constructor = clazz.getDeclaredConstructor(String.class);

        //2.保证此构造器是可访问的
        constructor.setAccessible(true);

        //3. 调用此构造器创建运行时类的对象
        Person tom = (Person) constructor.newInstance("TOM");

        System.out.println(tom);

    }
}

七、反射的应用：动态代理

  • 代理设计模式的原理：使用一个代理将对象包装起来，然后用该代理对象取代原始对象。任何对原始对象的调用都要通过代理。代理对象决定是否以及何时将方法调用转到原始对象上。
@zzy
关注
专栏目录
Java学习之反射机制
01-20
java语言区别于C，C++等准静态语言的大特点是java的反射机制。静态语言的直接定义是不能在运行时改变程序结构或变量的类型.按照这样的定义，python，ruby是动态语言，C，C++，Java不是动态语言。虽然在这样的定义下...
Java源码反射-reflex:java反射部分学习
05-19
在“Java源码反射-reflex:java反射部分学习”这个主题中，我们将深入探讨Java反射机制及其在实际开发中的应用。 1. **反射的基本概念** 反射是指在运行时，程序可以动态地获取类的信息（如类名、属性、方法等）并...
JAVA
沉心听雨
03-25 548
http://www.cnblogs.com/rollenholt/archive/2011/09/02/2163758.html反射机制详解 java反射详解 本篇文章依旧采用小例子来说明，因为我始终觉的，案例驱动是最好的，要不然只看理论的话，看了也不懂，不过建议大家在看完文章之后，在回过头去看看理论，会有更好的理解。 下面开始正文。 【案例1】通过一个对象获得完整的包名和类名
Java基础之—反射（非常重要）
热门推荐
sinat_38259539的博客
05-13 73万+
反射是框架设计的灵魂 （使用的前提条件：必须先得到代表的字节码的Class，Class类用于表示.class文件（字节码）） 一、反射的概述 JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。 要想解剖一个类,必须先要获取到该类的
Java中的反射
最新发布
SHI940637335的博客
08-11 1906
问题：IDEA中的对象是怎么知道类有哪些属性，哪些方法的呢？在运行时获取【任意】一个对象所属的类型在运行时获取【任意】一个类的构造在运行时构造【任意】一个类的对象在运行时获取【任意】一个类所具有的成员变量在运行时设置或者获取【任意】一个属性的值在运行时获取【任意】一个类所具有的成员方法在运行时调用【任意】一个对象的方法提示！在所有的具备的功能中，都是针对任意的对象进行操作，说明反射机制具备很强的灵活性和通用性。
Java反射机制
daguairen的博客
08-19 504
1 、认识反射          反射之中包含了一个“反”的概念，所以要想解释反射就必须先从“正”开始解释，一般而言，当用户使用一个类的时候，应该先知道这个类，而后通过这个类产生实例化对象，但是“反”指的是通过对象找到类。 package cn.mldn.demo; class Person {} public class TestDemo {     public st
java反射
weixin_47276069的博客
07-18 561
Setting——Editor——File and Code templates——"+"——名称为“new.xml”——输入“<?>”——单击"OK"2.类的class静态属性（一个类只有一个class,实例化多次对应的都是同一个class，所以class可以用==进行比较，a.getClass==b.getClass）若是想要获得父类和子类所以的属性，则需要进行递归，先对子类进行属性的获得，然后获得子类的父类，如果不是Object类型，则使用递归将父类传入继续进行属性的获得。
Java 学习之反射机制及应用场景
01-20
　近公司正在进行业务组件化进程，其中的路由实现用到了Java的反射机制，既然用到了想着好好学习总结一下，其实无论是之前的EventBus 2.x版本还是Retrofit、早期的View注解框架都或多或少的用到Java的反射机制。...
跟汤老师学Java（第17季）：反射
06-13
本课程从零开始，以通俗易懂的方式讲解Java技术，手把手教你掌握每一个知识点。 真正做到零基础入门学习，适合初学者的教程！ 课程内容包括： 1.类加载 2.反射简介 3.Class对象的创建 4.Class对象的常用方法 ...
java学习——java中的反射学习笔记.rar_java 反射
09-21
Java反射是Java编程语言中的一种强大机制，它允许运行中的Java程序对自身进行检查并且可以直接操作程序的内部属性。在Java中，反射是通过java.lang.Class类和java.lang.reflect包中的类来实现的。本篇笔记将深入探讨...
Java 反射机制浅析
weixin_30906701的博客
01-27 110
Java反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为Java语言的反射机制。反射的概念是由Smith在1982年首次提出的，主要是指程序可以访问、检测和修改它本身状态或行为的一种能力。这一概念的提出很快引发了计算机科学领域关于应用反射性的研究。它首先被程序...
java反射详解
09-02 641
本篇文章依旧采用小例子来说明，因为我始终觉的，案例驱动是最好的，要不然只看理论的话，看了也不懂，不过建议大家在看完文章之后，在回过头去看看理论，会有更好的理解。 下面开始正文。 【案例1】通过一个对象获得完整的包名和类名   package Reflect;
java中的反射总结
weixin_33737774的博客
12-24 159
刚开始学习java的时候真的很难理解反射到底是个什么东西 一些书籍，哪怕是很经典的书籍都解释的让人感觉懵懵的，或许的确是我太笨 况且，网上说在将来学习框架的时候需要经常应用到反射机制，这样一来总让人心里有些不安 就方才偶然又把讲解反射的章节和视频看了一点，觉得能理解一些了 现在决定一鼓作气，边看边写，顺便把一些主要的内容和操作都记载到这里 我想，对于我这么一个笨笨的人来说，学习的最好方法...
Java之反射
柠檬精
03-02 4万+
1.什么是反射 JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于 任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的 方法的功能称为java语言的反射机制。 2.Class类对象的三种实例化模式 在默认情况下我们是根据包名.类名找到类。而反射是根据对象来取得对象的信息来源。 要想解剖一个类,必须先要获取到该类的字节码文件对象。而解剖使用的就是Class类中的方法.所 以先要获取到每一个字节码文件对应的Clas....
Java学习资料：反射机制和注解简介
Java学习资料-反射机制和注解是Java语言学习过程中重要的内容。反射机制是Java语言的一个重要特性，通过它可以在运行状态中获取类的信息和动态调用对象的方法和属性。在学习Java反射机制之前，需要先了解编译期和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值