JAVA类加载过程

最新推荐文章于 2024-06-07 16:41:02 发布

年少一梦

最新推荐文章于 2024-06-07 16:41:02 发布

阅读量279

点赞数

分类专栏： Java基础

本文链接：https://blog.csdn.net/DQ1521166966/article/details/116534860

版权

Java基础专栏收录该内容

9 篇文章 0 订阅

订阅专栏

类加载过程

一、class文件简介及加载
Java编译器编译好Java文件之后，产生.class 文件在磁盘中。这种class文件是二进制文件，内容是只有JVM虚拟机能够识别的机器码。JVM虚拟机读取字节码文件，取出二进制数据，加载到内存中，解析.class 文件内的信息，生成对应的 Class对象:
在这里插入图片描述
二、JAVA内存

三、类初始化

四、类加载机制
JVM把class文件加载到内存，并对数据进行校验、准备、解析、初始化，最终形成JVM可以直接使用的Java类型的过程
类加载全过程

注：对象的创建过程

在这里插入图片描述
new对象 T t = new T();
实际步骤：
（1）申请内存
（2）成员变量赋默认值
（3）调用构造方法赋初始值
（4）建立关系（把引用栈空间的t和new 出来的堆里面的对象建立关联）

五、具体示意图
在这里插入图片描述
六、程序

public class Test05 {
    public static void main(String[] args) {
    A a = new A();
        System.out.println(A.m);
        /**
         1.加载到内存会产生一个类对应的Class对象
         2.建立链接，链接后m=0 初始值
         3.初始化 执行静态代码块(合并到一起执行)
            <clinit>(){
             System.out.println("A类静态代码块初始化===");
             m = 300;
            m = 100;
         }
         */
    }
}
class A{
    static {
        System.out.println("A类静态代码块初始化===");
        m = 300;
    }
    static int m = 100;
    public A() {
        System.out.println("A类无参构造初始化---");
    }
}

七、Java程序初始化顺序
1、父类的静态变量
2、父类的静态代码块
3、子类的静态变量
4、子类的静态代码块
5、父类的非静态变量
6、父类的非静态代码块
7、父类的构造方法
8、子类的非静态变量
9、子类的非静态代码块
10、子类的构造方法

public class LoadSX {
        public static void main(String[] args) {
            B b = new B();
        }
}
class AA{
    static String str1 = "父类A的静态变量";
    String str2 = "父类A的非静态变量";
    static {
        System.out.println("执行了父类A的静态代码块");
    }
    {
        System.out.println("执行了父类A的非静态代码块");
    }
    public AA(){
        System.out.println("执行了父类A的构造方法");
    }
}

class B extends AA{
    static String str1 = "子类B的静态变量";
    String str2 = "子类B的非静态变量";
    static {
        System.out.println("执行了子类B的静态代码块");
    }
    {
        System.out.println("执行了子类B的非静态代码块");
    }
    public B(){
        System.out.println("执行了子类B的构造方法");
    }
}

八、类的引用

1、主动引用（一定会初始化）
（1）new一个类的对象。
（2）调用类的静态成员(除了final常量)和静态方法。
（3）使用java.lang.reflect包的方法对类进行反射调用。
（4）当虚拟机启动，java Hello，则一定会初始化Hello类。说白了就是先启动main方法所在的类。
（5）当初始化一个类，如果其父类没有被初始化，则先会初始化他的父类
2、被动引用
（1）当访问一个静态域时，只有真正声明这个域的类才会被初始化。例如：通过子类引用父类的静态变量，不会导致子类初始化。
（2）通过数组定义类引用，不会触发此类的初始化。
（3）引用常量不会触发此类的初始化（常量在编译阶段就存入调用类的常量池中了）。

public class LoadYY {
    public static void main(String[] args) throws ClassNotFoundException {
        //主动引用：new一个类的对象
 //       People people = new People();
        //主动引用：调用类的静态成员(除了final常量)和静态方法
  //      People.getAge();
 //       System.out.println(People.age);
        //主动调用：使用java.lang.reflect包的方法对类进行反射调用
        Class.forName("com.classLoad.People");

        //被动引用:当访问一个静态域时，只有真正声明这个域的类才会被初始化。
 //       System.out.println(WhitePeople.age);
  //        System.out.println(WhitePeople.high);
        //被动引用:通过数组定义引用，不会初始化
 //       People[] people = new People[10];
        //被动引用:引用常量不会触发此类的初始化
 //      System.out.println(People.num);
    }
    //主动调用：先启动main方法所在的类
/*    static {
        System.out.println("main方法所在的类在虚拟机启动时就加载");
    }*/

}

class People{

    static int age = 3;
    static final int num = 20;

    static {
        System.out.println("People被初始化了！");
    }

    public People() {
    }

    public static int getAge() {
        return age;
    }

    public static void setAge(int age) {
        People.age = age;
    }

}

class WhitePeople extends People{
    static int high = 178;
    static {
        System.out.println("WhitePeople被初始化了！");
    }
}

九、类加载器的原理

1、类缓存
标准的Java SE类加载器可以按要求查找类，一旦某个类被加载到类加载器中，它将维持加载（缓存）一段时间。不过，JVM垃圾收集器可以回收这些Class对象。
2、类加载器的分类
在这里插入图片描述
引导类加载器（bootstrap class loader）
（1）它用来加载 Java 的核心库(JAVA_HOME/jre/lib/rt.jar,sun.boot.class.path路径下的内容)，是用原生代码（C语言）来实现的，并不继承自 java.lang.ClassLoader。
（2）加载扩展类和应用程序类加载器。并指定他们的父类加载器。

扩展类加载器（extensions class loader）
（1）用来加载 Java 的扩展库(JAVA_HOME/jre/ext/*.jar，或java.ext.dirs路径下的内容) 。Java 虚拟机的实现会提供一个扩展库目录。该类加载器在此目录里面查找并加载 Java类。
（2）由sun.misc.Launcher$ExtClassLoader实现。

应用程序类加载器（application class loader）
（1）它根据 Java 应用的类路径（classpath，java.class.path 路径下的内容）来加载 Java 类。一般来说，Java 应用的类都是由它来完成加载的。
（2）由sun.misc.Launcher$AppClassLoader实现。

自定义类加载器
（1）开发人员可以通过继承 java.lang.ClassLoader类的方式实现自己的类加载器，以满足一些特殊的需求。

3、java.class.ClassLoader类
（1）作用：

java.lang.ClassLoader类的基本职责就是根据一个指定的类的名称，找到或者生成其对应的字节代码，然后从这些字节代码中定义出一个Java类，即java.lang.Class类的一个实例。

ClassLoader还负责加载 Java 应用所需的资源，如图像文件和配置文件等。
（2）常用方法：

getParent() 返回该类加载器的父类加载器。

loadClass(String name) 加载名称为 name的类，返回的结果是java.lang.Class类的实例。
此方法负责加载指定名字的类，首先会从已加载的类中去寻找，如果没有找到；从parent ClassLoader[ExtClassLoader]中加载；如果没有加载到，则从Bootstrap ClassLoader中尝试加载(findBootstrapClassOrNull方法), 如果还是加载失败，则自己加载。如果还不能加载，则抛出异常ClassNotFoundException。

findClass(String name) 查找名称为 name的类，返回的结果是java.lang.Class类的实例。

findLoadedClass(String name) 查找名称为 name的已经被加载过的类，返回的结果是 java.lang.Class类的实例。

defineClass(String name, byte[] b, int off, int len) 把字节数组 b中的内容转换成 Java 类，返回的结果是java.lang.Class类的实例。这个方法被声明为 final的。

resolveClass(Class<?> c) 链接指定的 Java 类。

十、类加载器的代理模式

（1）双亲委派机制
双亲委派机制是指当一个类加载器收到一个类加载请求时，该类加载器首先会把请求委派给父类加载器。每个类加载器都是如此，只有在父类加载器在自己的搜索范围内找不到指定类时，子类加载器才会尝试自己去加载。
在这里插入图片描述
（2）双亲委派模型工作工程：
　　1.当Application ClassLoader 收到一个类加载请求时，他首先不会自己去尝试加载这个类，而是将这个请求委派给父类加载器Extension ClassLoader去完成。
　　2.当Extension ClassLoader收到一个类加载请求时，他首先也不会自己去尝试加载这个类，而是将请求委派给父类加载器Bootstrap ClassLoader去完成。
　　3.如果Bootstrap ClassLoader加载失败(在<JAVA_HOME>\lib中未找到所需类)，就会让Extension ClassLoader尝试加载。
　　4.如果Extension ClassLoader也加载失败，就会使用Application ClassLoader加载。
　　5.如果Application ClassLoader也加载失败，就会使用自定义加载器去尝试加载。
　　6.如果均加载失败，就会抛出ClassNotFoundException异常。

（3）双亲委派机制的作用
1、防止重复加载同一个.class。通过委托去向上面问一问，加载过了，就不用再加载一遍。保证数据安全。
2、保证核心.class不能被篡改。通过委托方式，不会去篡改核心.clas，即使篡改也不会去加载，即使加载也不会是同一个.class对象了。不同的加载器加载同一个.class也不是同一个Class对象。这样保证了Class执行安全。

（4）Tomcat服务器的类加载器

每个 Web 应用都有一个对应的类加载器实例。该类加载器也使用代理模式(不同于前面说的双亲委托机制)，所不同的是它是首先尝试去加载某个类，如果找不到再代理给父类加载器。这与一般类加载器的顺序是相反的。但也是为了保证安全，这样核心库就不在查询范围之内。

注：1.内容来自观看狂神说Java视频做的笔记
视频地址
2.摘抄和搬运
作者：四方城外
来源：简书
搬运链接

年少一梦

关注

0
点赞
踩
3

收藏

觉得还不错? 一键收藏
0
评论
JAVA类加载过程

类加载内存分析一、JAVA内存二、类初始化三、类的加载与ClassLoader的理解四、程序public class Test05 { public static void main(String[] args) { A a = new A(); System.out.println(A.m); /** 1.加载到内存会产生一个类对应的Class对象 2.建立链接，链接后m=0 初始值 3.
复制链接

扫一扫