Java注解和反射03：类加载

合集 - Java(30)
1.Java入门——介绍及安装2.Java基础01：注释、标识符、数据类型3.Java基础02：类型转换、变量、常量4.Java基础03：基本运算符5.Java基础04：包机制、JavaDoc生成文档6.Java流程控制01：Scanner对象7.Java流程控制02：顺序结构和选择结构8.Java流程控制03：循环结构9.Java方法10.Java数组01：数组的定义、声明、创建、初始化和内存分析11.Java数组02：数组使用、多维数组、冒泡排序和稀疏数组12.Java面向对象01：类与对象的关系、创建和初始化对象13.Java面向对象02：封装和继承14.Java面向对象03：抽象类、接口和内部类15.Java异常16.SpringBoot和微服务架构17.SpringBoot基础01：创建项目和编写HTTP接口18.SpringBoot基础02：自动装配原理、yaml语法和JSR-303数据校验19.SpringBoot基础03：静态资源和首页定制20.Java多线程01：什么是线程和线程的创建21.Java多线程02：静态代理模式和Lambda表达式22.Java多线程03：线程的五大状态23.Java多线程04：线程优先级、守护线程和线程同步24.Java多线程05：死锁、LOCK和线程协作25.网络编程基础01：网络编程概述、IP和端口26.网络编程基础02：TCP实现聊天和文件上传27.Java注解和反射01：注解28.Java注解和反射02：反射基本概述和获得Class类的几种方式
29.Java注解和反射03：类加载
30.Java注解和反射04：Class对象的使用
收起

Java注解和反射03：类加载

Java类加载内存分析

类的加载过程

当程序主动使用某个类时，如果该类还未被加载到内存中，则系统会通过如下三个步骤来对该类进行初始化。

类的加载与ClassLoader的理解

  • 加载：将class文件字节码内容加载到内存中，并将这些静态数据转换成方法区的运行时数据结构，然后生成一个代表这个类的java.lang.Class对象
  • 链接：将Java类的二进制代码合并到JVM的运行状态之中的过程
    • 验证：确保加载的类信息符合JVM规范，没有安全方面的问题
    • 准备：正式为类变量（static）分配内存并设置类变量默认初始值的阶段，这些内存都将在方法区进行分配
    • 解析：虚拟机常量池内的符号引用（常量名）替换为直接引用（地址）的过程
  • 初始化：
    • 执行类构造器()方法的过程。类构造器()方法是由编译期自动收集类中所有类变量的赋值动作和静态代码块中的语句合并产生的。（类构造器是构造类信息的，不是构造该类对象的构造器）
    • 当初始化一个类的时候，如果发现其父类还没有进行初始化，则需要先触发其父类的初始化
    • 虚拟机会保证一个类的()方法在多线程环境中被正确加锁和同步
package com.lurenj.reflection;

public class Test05 {
    public static void main(String[] args) {
        A a = new A();
        System.out.println(A.m);

        /*
        类构造器<clinit>()方法进行合并
        1.加载到内存，会产生一个类对应的Class对象
        2.链接，链接结束后m = 0
        3.初始化
            <clinit>(){
                    System.out.println("A类静态代码块初始化");
                    m = 300;
                    m = 100;
                    System.out.println("A类的无参构造初始化");
            }
         */

    }
}

class A{
    static {
        System.out.println("A类静态代码块初始化");
        m = 300;
    }

    static int m = 100;

    public A(){
        System.out.println("A类的无参构造初始化");
    }
}

什么时候会发生类初始化

  • 类的主动引用（一定会发生类的初始化）
    • 当虚拟机启动，先初始化main方法所在的类
    • new一个类的对象
    • 调用类的静态成员（除了final常量）和静态方法
    • 使用java.lang.reflect包的方法对类进行反射调用
    • 当初始化一个类，如果其父类没有被初始化，则先会初始化它的父类
  • 类的被动引用（不会发生类的初始化）
    • 当访问一个静态域时，只有真正声明这个域的类才会被初始化。如：当通过子类引用父类的静态变量，不会导致子类初始化
    • 通过数组定义类引用，不会触发此类的初始化
    • 引用常量不会触发此类的初始化（常量在链接阶段就存入调用类的常量池中了）
package com.lurenj.reflection;

//测试类什么时候会初始化
public class Test06 {
    static {
        System.out.println("Main类被加载");
    }

    public static void main(String[] args) throws ClassNotFoundException {
        //1.主动引用
        Son son = new Son();

        //反射也会产生主动引用
        Class.forName("com.lurenj.reflection.Son");
        //不会产生类的引用的方法
        System.out.println(Son.b);

        Son[] array = new Son[5];

        System.out.println(Son.M);
    }
}

class Father{

    static int b = 2;

    static {
        System.out.println("父类被加载");
    }

}

class Son extends Father{
    static {
        System.out.println("子类被加载");
        m = 300;
    }
    static int m = 100;
    static final int M = 1;
}

类加载器的作用

  • 类加载的作用：将class文件字节码内容加载到内存中，并将这些静态数据转换成方法区的运行时数据结构，然后在堆中生成一个代表这个类的java.lang.Class对象，作为方法区中类数据访问入口
  • 类缓存：标准的JavaSE类加载器可以按要求查找类，但一旦某个类被加载到类加载器中，它将维持加载（缓存）一段时间。不过JVM垃圾回收机制可以回收这些Class对象

类加载器作用是用来把类（class）装载进内存的。JVM规范定义了如下类型的类的加载器

package com.lurenj.reflection;

public class Test07 {
    public static void main(String[] args) throws ClassNotFoundException {

        //获取系统类的加载器
        ClassLoader systemClassLoader = ClassLoader.getSystemClassLoader();
        System.out.println(systemClassLoader);//sun.misc.Launcher$AppClassLoader@18b4aac2

        //获取系统类加载器的父类加载器-->扩展类加载器
        ClassLoader parent = systemClassLoader.getParent();
        System.out.println(parent);//sun.misc.Launcher$ExtClassLoader@1b6d3586

        //获取扩展类加载器的父类加载器-->根加载器（C/C++编写）
        ClassLoader parent1 = parent.getParent();
        System.out.println(parent1);//null

        //测试当前类是哪个加载器加载的
        ClassLoader classLoader = Class.forName("com.lurenj.reflection.Test07").getClassLoader();
        System.out.println(classLoader);//sun.misc.Launcher$AppClassLoader@18b4aac2

        //测试JDK内置的类是由谁加载的
        classLoader = Class.forName("java.lang.Object").getClassLoader();
        System.out.println(classLoader);//null

        //如何获得系统类加载器可以加载的路径
        System.out.println(System.getProperty("java.class.path"));
        /*
        D:\Environment\java\jdk1.8\jre\lib\charsets.jar;
        D:\Environment\java\jdk1.8\jre\lib\deploy.jar;
        D:\Environment\java\jdk1.8\jre\lib\ext\access-bridge-64.jar;
        D:\Environment\java\jdk1.8\jre\lib\ext\cldrdata.jar;
        D:\Environment\java\jdk1.8\jre\lib\ext\dnsns.jar;
        D:\Environment\java\jdk1.8\jre\lib\ext\jaccess.jar;
        D:\Environment\java\jdk1.8\jre\lib\ext\jfxrt.jar;
        D:\Environment\java\jdk1.8\jre\lib\ext\localedata.jar;
        D:\Environment\java\jdk1.8\jre\lib\ext\nashorn.jar;
        D:\Environment\java\jdk1.8\jre\lib\ext\sunec.jar;
        D:\Environment\java\jdk1.8\jre\lib\ext\sunjce_provider.jar;
        D:\Environment\java\jdk1.8\jre\lib\ext\sunmscapi.jar;
        D:\Environment\java\jdk1.8\jre\lib\ext\sunpkcs11.jar;
        D:\Environment\java\jdk1.8\jre\lib\ext\zipfs.jar;
        D:\Environment\java\jdk1.8\jre\lib\javaws.jar;
        D:\Environment\java\jdk1.8\jre\lib\jce.jar;
        D:\Environment\java\jdk1.8\jre\lib\jfr.jar;
        D:\Environment\java\jdk1.8\jre\lib\jfxswt.jar;
        D:\Environment\java\jdk1.8\jre\lib\jsse.jar;
        D:\Environment\java\jdk1.8\jre\lib\management-agent.jar;
        D:\Environment\java\jdk1.8\jre\lib\plugin.jar;
        D:\Environment\java\jdk1.8\jre\lib\resources.jar;
        D:\Environment\java\jdk1.8\jre\lib\rt.jar;
        D:\Note\net\study\out\production\study;
        D:\Program Files\Intelij IDEA\IntelliJ IDEA 2020.1.2\lib\idea_rt.jar
         */

    }
}

获取运行时类的完整结构

通过反射获取运行时类的完整结构

Field、Method、Constructor、Superclass、Interface、Annotation

  • 实现的全部接口
  • 所继承的父类
  • 全部的构造器
  • 全部的方法
  • 全部的Field
  • 注解
  • ......
package com.lurenj.reflection;

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

//获得类的信息
public class Test08 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, NoSuchMethodException {
        Class c1 = Class.forName("com.lurenj.reflection.User");

        //获得类的名字
        System.out.println(c1.getName());//获得包名 + 类名
        System.out.println(c1.getSimpleName());//获得类名

        //获得类的属性
        System.out.println("================================");
        Field[] fields = c1.getFields();//只能找到public属性
        fields = c1.getDeclaredFields();//可以找到全部属性

        //快捷方式fields.for
        for (Field field:fields){
            System.out.println(field);
        }

        //获得指定属性的值
        Field name = c1.getDeclaredField("name");
        System.out.println(name);

        //获得类的方法
        System.out.println("=========================");
        Method[] methods = c1.getMethods();//获得本类及其父类的全部public方法
        for (Method method : methods) {
            System.out.println("正常的：" + method);
        }

        methods = c1.getDeclaredMethods();//获得本类的所有方法
        for (Method method : methods) {
            System.out.println("getDeclaredMethods:" + method);
        }

        System.out.println("===============================");
        //获得指定方法
        Method getName = c1.getMethod("getName", null);
        Method setName = c1.getMethod("setName", String.class);
        System.out.println(getName);
        System.out.println(setName);

        //获得构造器
        System.out.println("=============================");
        Constructor[] constructors = c1.getConstructors();//获得本类及其父类的全部public方法
        for (Constructor constructor : constructors) {
            System.out.println(constructor);
        }

        constructors = c1.getDeclaredConstructors();//获得本类的所有方法
        for (Constructor constructor : constructors) {
            System.out.println(constructor);
        }

        //获得指定的构造器
        Constructor declaredConstructor = c1.getDeclaredConstructor(String.class, int.class, int.class);
        System.out.println("指定的构造器：" + declaredConstructor);

    }
}

注意：

  1. 在实际的操作中，取得类的信息的操作，并不会经常开发
  2. 一定要熟悉java.lang.reflect包的作用，反射机制
  3. 如何获取属性、方法、构造器的名称，修饰符等
posted @   lurenj  阅读(51)  评论(0)  编辑  收藏  举报
相关博文：
· Java注解和反射02：反射基本概述和获得Class类的几种方式
· Java注解和反射04：Class对象的使用
· Java 注解和反射（四）Java内存分析
· 【学习笔记】反射（二）之类加载
· 获取类的相关信息
阅读排行：
· 无需6万激活码！GitHub神秘组织3小时极速复刻Manus，手把手教你使用OpenManus搭建本
· Manus爆火，是硬核还是营销？
· 终于写完轮子一部分：tcp代理 了，记录一下
· 别再用vector＜bool＞了！Google高级工程师：这可能是STL最大的设计失误
· 单元测试从入门到精通
点击右上角即可分享
微信分享提示