Java基础 - 反射篇 - 类加载分析，通过反射获取类的结构API案例

最新推荐文章于 2022-11-23 15:54:49 发布
最新推荐文章于 2022-11-23 15:54:49 发布
阅读量882 收藏 1
点赞数
分类专栏： 成长阶段 笔记 文章标签： java 开发语言 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39123467/article/details/123160006
版权

文章目录

类加载

基本说明

反射机制是java实现动态语言的关键，也就是通过反射实现类动态加载

  1. 静态加载：编译时加载相关的类，如果没有则报错，依赖性太强
  2. 动态加载：运行时加载需要的类，如果运行时不用该类，则不报错，降低了依赖性

举例说明(静态加载)

外部ClassLoad_类

import java.util.*;
public class ClassLoad_{
	public static void main(String[] args){
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入key");
		String key = sc.next();
		switch(key) {
			case "1":
				Dog dog = new Dog();//编译时加载类，静态加载
				dog.cry();
				break;
			case "2":
				System.out.println("ok");
				break;
			default:
				System.out.println("do nothing...");
		}
	}
}

dos窗口运行展示

请添加图片描述

举例说明（动态加载）

ClassLoad_类

package com.taotao.reflection.question;

import java.lang.reflect.Method;
import java.util.*;
/**
 * Create By 刘鸿涛
 * 2022/2/26 17:20
 */
public class Test {
    @SuppressWarnings({"all"})
    public static void main(String[] args)throws Exception {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入key");
        String key = sc.next();
        switch(key) {
            case "1":
                Dog dog = new Dog();//编译时加载类，静态加载，依赖性很强
                dog.cry();
                break;
            case "2":
                //反射 -> 动态加载
                Class cls = Class.forName("person");	//加载Person类[动态加载]
                Object o = cls.newInstance();
                Method m = cls.getMethod("hi");
                m.invoke(o);
                System.out.println("ok");
                break;
            default:
                System.out.println("do nothing...");
        }
    }
}
//因为new Dog（）是静态加载，因此必须编写dog类
//Person类是动态加载，所以，没有编写person类也不会报错，只有当动态加载该类时，才会报错
class Dog {
    public void cry() {
        System.out.println("小狗汪汪叫....");
    }
}

运行展示

请添加图片描述

请添加图片描述

类加载时机

  1. 当创建对象时（new）（静态加载）
  2. 当子类被加载时（静态加载）
  3. 调用类中的静态成员时（静态加载）
  4. 通过反射（动态加载）

类加载过程图

请添加图片描述

请添加图片描述

类加载的五个阶段

加载阶段

JVM在该阶段的主要目的是将字节码从不同的数据源（可能是class文件、也可能是jar包，甚至网络）转化为二进制字节流加载到内存中，并生成一个代表该类的java.lang.Class对象

连接阶段 - 验证

  1. 目的是为了确保Class 文件的字节流中包含的信息符合当前虚拟机的要求，并且不会危害虚拟机自身的安全。
  2. 包括：文件格式验证（是否以魔数 oxcafebabe开头）、元数据验证、字节码验证和符号引用验证
  3. 可以考虑使用 - Xverify：none 参数来关闭大部分的类验证措施，缩短虚拟机类加载的时间

准备阶段 - 准备

  1. JVM 会在该阶段对静态变量，分配内存并默认初始化（对应数据类型的默认初始值，如 O，OL，null，false等）。这些变量所使用的内存都将在方法区中进行分配

请添加图片描述

案例演示

package com.taotao.reflection.classload_;

/**
 * Create By 刘鸿涛
 * 2022/2/26 18:26
 * 我们说明一个类加载的链接阶段 - 准备
 */
public class ClassLoad02 {
    public static void main(String[] args) {

    }
}
class A {
    //属性 - 成员变量 - 字段
    //分析类加载的链接阶段 - 准备 属性是如何处理
    //1.n1 是实例属性，不是静态变量，因此在准备阶段，是不会分配内存
    //2.n2 是静态变量，分配内存 n2 是默认初始化 0，而不是20
    //3.n3 是static final是常量，他和类变量不一样，因为一旦赋值就不变 n3 = 30
    public int n1 = 10;
    public static int n2 = 20;
    public static final int n3 = 30;
}

连接阶段 - 解析

  1. 虚拟机将常量池内的符号引用替换为直接引用的过程

请添加图片描述

数据的内存地址是JVM机来分配的，用户不能控制

Initialization（初始化）

  1. 到初始化阶段：才真正开始执行类中定义的Java程序代码，此阶段是执行clinit（）方法的过程。
  2. clinit（）方法是由编译器按语句在源文件中出现的顺序，一次自动收集类中的所有“静态变量”的赋值动作和静态代码块中的语句，并进行合并。
package com.taotao.reflection.classload_;

/**
 * Create By 刘鸿涛
 * 2022/2/26 19:10
 * 演示类加载 - 初始化
 */
public class ClassLoad03 {
    public static void main(String[] args) {
        //分析
        //1.加载B类，并生成B 的class对象
        //2.链接 num = 0;
        //3.初始化阶段
        // 依次自动收集类中的所有静态变量的赋值动作和静态代码块中的语句,并合并
        /*
        *   clinit() {
        *       System.out.println("B  静态代码块被执行");
        *       num = 300;
        *       num = 100;
        *   }
        *   合并：num = 100
        * */
//        new B();
        //如果直接使用类的静态属性
        System.out.println(B.num);  //B 静态代码块被执行     100
    }
}
class B {
    static {
        System.out.println("B  静态代码块被执行");
        num = 300;
    }
    static int num = 100;
    public B() {
        System.out.println("B() 构造器被执行");
    }
}
  1. 虚拟机会保证一个类clinit（）方法在多线程环境中被正确地加锁、同步，如果多个线程同时去初始化一个类，那么只有一个线程去执行这个类的clinit（）方法，其他线程都需要阻塞等待，直到活动线程执行clinit（）方法完毕

通过反射获取类的结构信息

第一组（java.lang.Class）

  1. getNname：获取全类名
  2. getSimpleName：获取简单类名
  3. getFields：获取所有public修饰的属性，包含本类以及父类的
  4. getDeclaredFields：获取本类中所有属性
  5. getMethods：获取所有public修饰的方法，包含本类以及父类的
  6. getDeclaredMethods：获取本类中所有方法
  7. getConstructors：获取所有public修饰的构造器，包含本类以及父类的
  8. getDeclaredConstructors：获取本类中所有构造器
  9. getPackage：以Package形式返回，包信息
  10. getSuperClass：以Class形式返回父类信息
  11. getInterfaces：以Class[]形式返回接口信息
  12. getAnnotations：以Annotation[] 形式返回注解信息

演示通过反射获取类的结构信息

package com.taotao.reflection;

import org.junit.Test;

import java.lang.annotation.Annotation;
import java.lang.annotation.Inherited;
import java.lang.annotation.Retention;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;

/**
 * Create By 刘鸿涛
 * 2022/2/26 23:11
 */
public class ReflectionUtils {
    public static void main(String[] args) {

    }

    //第一组方法API
    @SuppressWarnings({"all"})
    @Test
    public void api_01() throws ClassNotFoundException {
        //得到 Class对象
        Class<?> personCls = Class.forName("com.taotao.reflection.Person");

//        1. getNname：获取全类名
        System.out.println(personCls.getName()); //com.taotao.reflection.Person

//        2. getSimpleName：获取简单类名
        System.out.println(personCls.getSimpleName()); //Person

//        3. getFields：获取所有public修饰的属性，包含本类以及父类的
        Field[] fields = personCls.getFields();
        for (Field field :fields) {
            System.out.println("本类以及父类的属性" + field.getName());
        }

//        4. getDeclaredFields：获取本类中所有属性,本类及父类，包含私有、共有、protected
        Field[] declaredFields = personCls.getDeclaredFields();
        for (Field declaredField : declaredFields) {
            System.out.println("本类中所有属性=" + declaredField.getName());
        }

//        5. getMethods：获取所有public修饰的方法，包含本类以及父类的
        Method[] methods = personCls.getMethods();
        for (Method method : methods) {
            System.out.println("本类以及父类的方法 = " + method.getName());
        }

//        6. getDeclaredMethods：获取本类中所有方法
        Method[] declaredMethods = personCls.getDeclaredMethods();
        for (Method declaredMethod : declaredMethods) {
            System.out.println(declaredMethod.getName());
        }

//        7. getConstructors：获取所有public修饰的构造器，只有本类，没有父类
        Constructor<?>[] constructors = personCls.getConstructors();
        for (Constructor<?> constructor : constructors) {
            System.out.println("本类以及父类的构造器 = " + constructor.getName());
        }       //测试并未得到父类构造器

//        8. getDeclaredConstructors：获取本类中所有构造器，只有本类，没有父类
        Constructor<?>[] declaredConstructors = personCls.getDeclaredConstructors();
        for (Constructor constructor : declaredConstructors) {
            System.out.println("本类中的所有构造器分别为 = " + constructor.getName());
        }   //测试未得到父类构造器

//        9. getPackage：以Package形式返回，包信息
        System.out.println(personCls.getPackage());

//        10. getSuperClass：以Class形式返回父类信息
        System.out.println("父类的class信息 = " + personCls.getSuperclass());  //class com.taotao.reflection.A

//        11. getInterfaces：以Class[]形式返回接口信息
        Class<?>[] interfaces = personCls.getInterfaces();
        for (Class anInterface : interfaces){
            System.out.println("实现接口信息" + anInterface);
        }

//        12. getAnnotations：以Annotation[] 形式返回注解信息
        Annotation[] annotations = personCls.getAnnotations();
        for (Annotation annotation : annotations){
            System.out.println("注解信息 = " + annotation);
        }
    }
}
class A {
    public String hobby;
    public A(){
        
    }

    public A(String hobby){

    }
}

interface IA {

}

interface IB {

}

@Deprecated
@SuppressWarnings({"all"})
class Person extends A implements IA, IB {
    //属性
    public String name;
    protected int age;
    String job;
    private double sal;

    //构造器
    public Person(){

    }

    public Person(String name){

    }

    private Person(int age){

    }

    //方法
    public void m1() {

    }

    protected void m2() {

    }

    void m3() {

    }

    private void m4() {

    }
}

第二组(java.lang.reflect.Field)

  1. getModifiers；以int形式返回修饰符

说明：默认修饰符是 0，public 是1，private 是 2，protected 是 4， static 是 8 ，final 是16.

如果 是 public static 那么就是 1 + 8 = 9

  1. getType：以Class形式返回类型
  2. getName：返回属性名

演示

package com.taotao.reflection;

import org.junit.Test;

import java.lang.annotation.Annotation;
import java.lang.annotation.Inherited;
import java.lang.annotation.Retention;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;

/**
 * Create By 刘鸿涛
 * 2022/2/26 23:11
 */
public class ReflectionUtils {
    public static void main(String[] args) {

    }

    @Test
    @SuppressWarnings({"all"})
    public void api_02 () throws ClassNotFoundException {
        //得到 Class对象
        Class<?> personCls = Class.forName("com.taotao.reflection.Person");
        //getDeclareFileds:获取本类中所有属性
        Field[] declaredFields = personCls.getDeclaredFields();
        for (Field fields : declaredFields){
            System.out.println("本类中的所有属性分别为 = " + fields.getName() + "  该属性的修饰符值 = " + fields.getModifiers() + "  该属性的类型为 = " + fields.getType());
        }
    }
}

class Person {
    //属性
    public String name;
    protected int age;
    String job;
    private double sal;

    }
}

请添加图片描述

第三组(java.lang.reflect.Method)

  1. getModifiers:以int形式返回修饰符

说明：默认修饰符 是 0 ，public 是 1，private 是 2，protected 是 4， static 是 8 ，final 是16；

  1. getReturnType：以Class形式获取 返回类型
  2. getName：返回方法名
  3. getParameterTypers：以Class[]返回参数类型数组

演示

package com.taotao.reflection;

import org.junit.Test;

import java.lang.annotation.Annotation;
import java.lang.annotation.Inherited;
import java.lang.annotation.Retention;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;

/**
 * Create By 刘鸿涛
 * 2022/2/26 23:11
 */
public class ReflectionUtils {
    public static void main(String[] args) {

    }
        //getDeclaredMethods：获取本类中所有方法
        Method[] declaredMethods = personCls.getDeclaredMethods();
        for (Method declaredMethod : declaredMethods) {
            System.out.println("本类的所有方法分别为：" + declaredMethod.getName() + " 该方法的访问修饰符值：" + declaredMethod.getModifiers() +  " 返回类型为：" + declaredMethod.getReturnType());
            //输出当前这个方法的参数情况
            Class<?>[] parameterTypes = declaredMethod.getParameterTypes();
            for (Class parameterType : parameterTypes) {
                System.out.println("该方法的形参类型：" + parameterType);    //class java.lang.String,  int
            }
        }
    }
}

@SuppressWarnings({"all"})
class Person {

    //方法
    public void m1(String a,int b) {

    }

    protected void m2() {

    }

    void m3() {

    }

    private void m4() {

    }
}

第四组(java.lang.reflect.Constructor)

  1. getModifiers:以int形式返回修饰符
  2. getName：返回构造器名（全类名）
  3. getParameterTypes：以Class[]返回参数类型数组

案例

package com.taotao.reflection;

import org.junit.Test;

import java.lang.annotation.Annotation;
import java.lang.annotation.Inherited;
import java.lang.annotation.Retention;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;

/**
 * Create By 刘鸿涛
 * 2022/2/26 23:11
 */
public class ReflectionUtils {
    public static void main(String[] args) {

    }

    @Test
    @SuppressWarnings({"all"})
    public void api_02 () throws ClassNotFoundException {
        //得到 Class对象
        Class<?> personCls = Class.forName("com.taotao.reflection.Person");


        //getDeclaredConstructors：获取本类中所有构造器
        Constructor<?>[] declaredConstructors = personCls.getDeclaredConstructors();
        for (Constructor constructor : declaredConstructors) {
            System.out.println("本类中的所有构造器分别为 = " + constructor.getName());

            Class<?>[] paremeterTypes = constructor.getParameterTypes();
            for (Class<?> paremeterType : paremeterTypes) {
                System.out.println("该构造器的形参类型 = " + paremeterType);
            }
            System.out.println();
        }
    }
}

@Deprecated
@SuppressWarnings({"all"})
class Person {
    //属性
    public String name;
    protected int age;
    String job;
    private double sal;

    //构造器
    public Person(){

    }

    public Person(String name,int a){

    }

    public Person(int age){

    }
}

在这里插入图片描述

鬼鬼骑士
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
java由类的完整路径利用反射给接口注入对象
12-03
java由类的完整路径利用反射给接口注入对象，本人亲测可用，完整实例。
Java 反射，超全面的API示例
Ajdjdj的博客
04-27 182
public class ClassTest { private volatile int i; public String s; protected char c; static int[] ints = {1,2,3}; private ClassTest(){ } public ClassTest(int i){ this.i = i; } private class InnerClass{}
java类加载+反射的真正使用例子
weixin_39338645的博客
07-17 134
java类加载+反射的真正使用例子
java利用反射得到实例
hnzgemail的博客
04-10 379
[code="java"] 对于面向接口编程的项目免不了要一反射相接触，动态得到实例: public interface a { public void sayHello(); } --------------------------- 第一种情况是当 aImpl实现类为默认的构造方法： 根据类名aImpl动态得到实例 Class c=Class.forName("aImpl"...
Android P+通过反射调用系统API实现高级功能
MasterC的博客
09-15 2629
Android P+通过反射调用系统API实现高级功能1. 添加反射库1.1 导包1.2 打开隐藏API 通过反射调用系统API已经不算是什么新鲜事了，不过在Android P之后，Google对隐藏API的限制更加严格，不能再直接通过反射去调用系统API了，必须通过特定手段先打开隐藏API的限制，具体原理可以移步另一种绕过 Android P以上非公开API限制的办法，这里我们只讲实战用法。 1. 添加反射库 1.1 导包 新建AS项目后，打开项目的settings.gradle，在repositorie
Java基础精品课22-xml与反射.zip
05-20
5. 反射基础：理解反射的概念，学习Class类和反射API的使用。 6. 动态方法调用：使用Method类调用类的方法，包括静态方法和实例方法。 7. 访问私有字段：通过反射访问和修改私有字段的值。 8. 反射与设计模式：如...
day021-反射和注解笔记和代码.rar
03-16
所以不能够直接new一个Class对象出来，是通过Class类中的一个方法获取到的。 例如：通过全限定路径类名 2、同一种类型不管通过什么方式得到Class的实例都是相等的；一个类型的字节码对象只有一份，在...
Java基础案例教程（第2版）-教学案例.zip
07-06
9. **反射API**：反射是Java的高级特性，允许程序在运行时动态地获取类的信息并操作类的对象。案例可能展示如何使用反射进行类的动态加载和方法的动态调用。 10. **注解（Annotation）**：注解是元数据的一种形式，...
java反射笔记
04-14
关于标签"反射基础"，在Java反射基础中，还包括了泛型信息的获取、接口实现类的判断、注解的处理等内容： 1. 泛型信息：虽然Java泛型在编译后会被擦除，但通过反射仍可以获取到泛型的实际类型。 2. 接口实现：`Class...
java反射应用详细介绍
09-05
Java反射是Java语言提供的一种强大的机制，它允许程序在运行时检查类、接口、字段和方法的信息，并且能够在运行时动态地创建对象和调用方法。以下是对标题和描述中涉及知识点的详细解释： 1. **获取类的完整包名和...
java 反射 动态代码_java利用反射动态加载方法
weixin_36359075的博客
02-16 319
根据特定字符串加载相应的方法，有人用if else，有人用switch。参数少了或情况少了还好，很多方法真要命，不要紧，java反射拯救你import java.lang.reflect.Method;public class Test {public static void main(String[] args) throws Exception {Test t=new Test();Class...
反射 - 拿类中@ApiOperation注解与所以方法名称
技术刘的博客
08-24 2264
public static void main(String[] args) throws ClassNotFoundException { Class cl1 = Class.forName("com.zulijian.server.admin.controller.UserController"); //获取类中所有的方法 Method[] methods = ...
Java反射机制、反射相关API、反射API使用（反射获取实体类字段名和注解值）
xingze的博客
07-30 1390
Java的反射机制在编译时并不确定是哪个类被加载了，而是在程序运行时才加载、探知、使用，这样的特点就是反射。每个类被加载后，系统就会为该类生成一个对应的Class对象，通过该Class对象就可以访问JVM中的这个类。在获得了某个类所对应的Class对象之后，程序就可以调用Class对象的方法来获取该类的详细信息。指定的public属性,与访问级别无关（可访问paivate属性）指定的构造方法,与访问级别无关（可访问paivate构造方法）指定的方法,与访问级别无关（可访问paivate方法）
JAVA使用反射动态的获取接口的所有实现类(通过接口类路径)
最新发布
zxm18751880909的博客
11-23 9504
JAVA使用反射动态的获取接口的所有实现类(通过接口类路径)
Java反射实现接口
lastwarmth的博客
10-28 8919
之前做过一个插件，综合了移动MM，移动和游戏，沃商店等一些计费SDK。将这些计费SDK提供的接口全部整合，最后由插件提供一套接口。通过后台配置，来让游戏使用某种计费SDK。游戏开发商接入计费的时候，只需要调用插件提供的一套接口即可。因为不可能保证游戏会包含所有的计费SDK的代码，所以插件内部只能利用反射来实现。通过反射来获取类，获取方法进行调用是比较简单的。但是有个问题困扰了我很久：计费SDK都有提
java反射实现接口_Java反射学习笔记
weixin_36354965的博客
02-25 1854
非原创：以下内容都是学习Java反射时从网上摘录的信息汇总Java反射机制可以让我们在编译期(Compile Time)之外的运行期(Runtime)检查类，接口，变量以及方法的信息。反射还可以让我们在运行期实例化对象，调用方法，通过调用get/set方法获取变量的值。下面是一个Java反射的简单例子：Method[] methods = MyObject.class.getMethods();f...
类加载器的作用&反射获取Class类对象的三种方式&暴力反射
X18160013的博客
08-05 548
是指在运行时去获取一个类的变量和方法信息。然后通过获取到的信息来创建对象，调用方法的一种机制。由于这种动态性，可以极大的增强程序的灵活性，程序不用在编译期就完成确定，在运行期仍然可以扩展。...
java 反射 获取父类、实现接口类型
qq_16430873的博客
09-23 885
java 反射 获取父类、实现接口类型
【Java】【反射】 使用反射方式去实现一个接口
05-07 7459
使用放射方式去实现一个接口 场景: 假设想使用 MediaScannerConnection 类的 scanFile 静态方法,但需传入参数 OnScanCompletedListener 使用如下反射方式便可. Class MediaScanner = null; Class OnScanCompletedListener = null;
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

鬼鬼骑士

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值