详解Java 类的加载、连接和初始化

系统可能在第一次使用某个类时加载该类,也可能采用预加载机制来加载某个类。本节将会详细介绍类加载、连接和初始化过程中的每个细节。

JVM 和类

当调用 java 命令运行某个 Java 程序时,该命令将会启动一个 Java 虚拟机进程,不管该 Java 程序有多么复杂,该程序启动了多少个线程,它们都处于该 Java 虚拟机进程里。正如前面介绍的,同一个 JVM 的所有线程、所有变量都处于同一个进程里,它们都使用该 JVM 进程的内存区。当系统出现以下几种情况时,JVM 进程将被终止。

  • 程序运行到最后正常结束。
  • 程序运行到使用 system.exit() 或 Runtime.getRuntime().exit() 代码处结束程序。
  • 程序执行过程中遇到未捕获的异常或错误而结束。
  • 程序所在平台强制结束了 JVM 进程。

从上面的介绍可以看出,当 Java 程序运行结束时,JVM 进程结束,该进程在内存中的状态将会丢失。下面以类的类变量来说明这个问题。下面程序先定义了一个包含类变量的类。

public class A {
  // 定义该类的类变量
  public static int a = 6;
}

上面程序中的粗体字代码定义了一个类变量a,接下来定义一个类创建A类的实例,并访问A对象的类变量a。

public class ATest1 {
  public static void main(String[] args) {
    // 创建A类的实例
    A a = new A();
    // 让a实例的类变量a的值自加
    a.a++;
    System.out.println(a.a);
  }
}

下面程序也创建A对象,并访问其类变量a的值。

public class ATest2 {
  public static void main(String[] args) {
    // 创建A类的实例
    A b = new A();
    // 输出b实例的类变量a的值
    System.out.println(b.a);
  }
}

在 ATest1.java 程序中创建了A类的实例,并让该实例的类变量a的值自加,程序输出该实例的类变量a的值将看到7,相信读者对这个答案没有疑问。关键是运行第二个程序 ATest2 时,程序再次创建了A对象,并输出A对象类变量的a的值,此时a的值是多少呢?结果依然是6,并不是7。这是因为运行 ATest1 和 ATest2 是两次运行 JVM 进程,第一次运行 JVM 结束后,它对A类所做的修改将全部丢失——第二次运行 JVM 时将再次初始化A类。

注意:两次运行 Java 程序处于两个不同的 JVM 进程中,两个 JVM 之间并不会共享数据。

类的加载

当程序主动使用某个类时,如果该类还未被加载到内存中,则系统会通过加载、连接、初始化三个步骤来对该类进行初始化。如果没有意外,JVM 将会连续完成这三个步骤,所以有时也把这三个步骤统称为类加载或类初始化。

类加载指的是将类的 class 文件读入内存,并为之创建一个 java.lang.Class 对象,也就是说,当程序中使用任何类时,系统都会为之建立一个 java.lang.Class 对象。

提示:前面介绍面向对象时提到:类是某一类对象的抽象,类是概念层次的东西.但不知道读者有没有想过:类也是一种对象就像平常说概念主要用于定义、描述其他事物,但概念本身也是一种事物,那么概念本身也需要被描述———这有点像一个哲学命题,但事实就是这样,每个类是一批具有相同特征的对象的抽象(或者说概念),而系统中所有的类实际上也是实例,它们都是 java.lang.Class 的实例。

类的加载由类加载器完成,类加载器通常由 JVM 提供,这些类加载器也是前面所有程序运行的基础,JVM 提供的这些类加载器通常被称为系统类加载器。除此之外,开发者可以通过继承 ClassLoader 基类来创建自己的类加载器。

通过使用不同的类加载器,可以从不同来源加载类的二进制数据,通常有如下几种来源。

  • 从本地文件系统加载 class 文件,这是前面绝大部分示例程序的类加载方式。
  • 从 JAR 包加载 class 文件,这种方式也是很常见的,前面介绍 JDBC 编程时用到的数据库驱动类就放在 JAR 文件中,JVM 可以从 JAR 文件中直接加载该 class 文件。
  • 通过网络加载 class 文件。
  • 把一个 Java 源文件动态编译,并执行加载。

类加载器通常无须等到“首次使用”该类时才加载该类,Java 虚拟机规范允许系统预先加载某些类。

类的连接

当类被加载之后,系统为之生成一个对应的 Class 对象,接着将会进入连接阶段,连接阶段负责把类的二进制数据合并到 JRE 中。类连接又可分为如下三个阶段。

(1)验证:验证阶段用于检验被加载的类是否有正确的内部结构,并和其他类协调一致。
(2)准备:类准备阶段则负责为类的类变量分配内存,并设置默认初始值。
(3)解析:将类的二进制数据中的符号引用替换成直接引用。

类的初始化
在类的初始化阶段,虚拟机负责对类进行初始化,主要就是对类变量进行初始化。在 Java 类中对类变量指定初始值有两种方式:

①声明类变量时指定初始值;

②使用静态初始化块为类变量指定初始值。例如下面代码片段。

public class Test {
  // 声明变量a时指定初始值
  static int a = 5;
  static int b = 9; // ①
  static int c;
  static {
    // 使用静态初始化块为变量b指定出初始值
    b = 6;
    System.out.println("----------");
  }

  public static void main(String[] args) {
    System.out.println(Test.b);
  }
}

对于上面代码,程序为类变量a、b都显式指定了初始值,所以这两个类变量的值分别为5、6,但类变量c则没有指定初始值,它将采用默认初始值0。

声明变量时指定初始值,静态初始化块都将被当成类的初始化语句,JVM 会按这些语句在程序中的排列顺序依次执行它们,例如下面的类。

public class Test {
  static {
    // 使用静态初始化块为变量b指定出初始值
    b = 6;
    System.out.println("----------");
  }
  // 声明变量a时指定初始值
  static int a = 5;
  static int b = 9; // ①
  static int c;

  public static void main(String[] args) {
    System.out.println(Test.b);
  }
}

上面代码先在静态初始化块中为b变量赋值,此时类变量b的值为6;接着程序向下执行,执行到①号代码处,这行代码也属于该类的初始化语句,所以程序再次为类变量b赋值。也就是说,当 Test 类初始化结束后,该类的类变量b的值为9。

JVM 初始化一个类包含如下几个步骤。

①假如这个类还没有被加载和连接,则程序先加载并连接该类。
②假如该类的直接父类还没有被初始化,则先初始化其直接父类。
③假如类中有初始化语句,则系统依次执行这些初始化语句。

当执行第2个步骤时,系统对直接父类的初始化步骤也遵循此步骤1、3;如果该直接父类又有直接父类,则系统再次重复这三个步骤来先初始化这个父类......依此类推,所以 JVM 最先初始化的总是 java.lang.Object 类。当程序主动使用任何一个类时,系统会保证该类以及所有父类(包括直接父类和间接父类〕都会被初始化。

类初始化的时机

当 Java 程序首次通过下面6种方式来使用某个类或接口时,系统就会初始化该类或接口。

  • 创建类的实例。为某个类创建实例的方式包括:使用 new 操作符来创建实例,通过反射来创建实例,通过反序列化的方式来创建实例。
  • 调用某个类的类方法(静态方法)。
  • 访问某个类或接口的类变量,或为该类变量赋值。
  • 使用反射方式来强制创建某个类或接口对应的 java.lang.Class 对象。例如代码:Class.forName("Person"),如果系统还未初始化 Person 类,则这行代码将会导致该 Person 类被初始化,并返回 Person 类对应的 java.lang.Class 对象。
  • 初始化某个类的子类。当初始化某个类的子类时,该子类的所有父类都会被初始化。
  • 直接使用 java.exe 命令来运行某个主类。当运行某个主类时,程序会先初始化该主类。

除此之外,下面的几种情形需要特别指出。

对于一个 final 型的类变量,如果该类变量的值在编译时就可以确定下来,那么这个类变量相当于“宏变量”。Java 编译器会在编译时直接把这个类变量出现的地方替换成它的值,因此即使程序使用该静态类变量,也不会导致该类的初始化。例如下面示例程序的结果。

class MyTest {
  static {
    System.out.println("静态初始化块...");
  }
  // 使用一个字符串直接量为static final的类变量赋值
  static final String compileConstant = "疯狂Java讲义";
}

public class CompileConstantTest {
  public static void main(String[] args) {
    // 访问、输出MyTest中的compileConstant类变量
    System.out.println(MyTest.compileConstant); // ①
  }
}

上面程序的 MyTest 类中有一个 compileConstant 的类变量,该类变量使用了 final 修饰,而且它的值可以在编译时确定下来,因此 compileConstant 会被当成“宏变量”处理。程序中所有使用 compileConstant 的地方都会在编译时被直接替换成它的值——也就是说,上面程序中①处的粗体字代码在编译时就会被替换成“疯狂Java讲义”,所以①行代码不会导致初始化 MyTest 类。

提示:当某个类变量(也叫静态变量)使用了 final 修饰,而且它的值可以在编译时就确定下来,那么程序其他地方使用该类变量时,实际上并没有使用该类变量,而是相当于使用常量。

反之,如果 final 修饰的类变量的值不能在编译时确定下来.则必须等到运行时才可以确定该类变量的值,如果通过该类来访问它的类变量,则会导致该类被初始化。例如将上面程序中定义compileConstant 的代码改为如下:

//采用系统当前时间为 static final 类变量赋值
static final String compileConstant = System.currentTimeMiIlis() + "";

因为上面定义的 compileConstant 类变量的值必须在运行时才可以确定,所以①处的粗体字代码必须保留为对 MyTest 类的类变量的引用,这行代码就变成了使用 MyTest 的类变量,这将导致 MyTest 类被初始化。

当使用 ClassLoader 类的 loadClass() 方法来加载某个类时,该方法只是加载该类,并不会执行该类的初始化。使用 Class 的 forName() 静态方法才会导致强制初始化该类。例如如下代码。

package com.jwen.chapter18_1;

class Tester {
  static {
    System.out.println("Tester类的静态初始化块...");
  }
}

public class ClassLoaderTest {
  public static void main(String[] args) throws ClassNotFoundException {
    ClassLoader cl = ClassLoader.getSystemClassLoader();
    // 下面语句仅仅是加载Tester类
    cl.loadClass("com.jwen.chapter18_1.Tester");
    System.out.println("系统加载Tester类");
    // 下面语句才会初始化Tester类
    Class.forName("com.jwen.chapter18_1.Tester");
  }
}

上面程序中的两行粗体字代码都用到了 Tester 类,但第一行粗体字代码只是加载 Tester 类,并不会初始化 Tester 类。运行上面程序,会看到如下运行结果:

系统加载Tester类
Tester类的静态初始化块...

从上面运行结果可以看出,必须等到执行 Class.forName("Tester") 时才完成对 Tester 类的初始化。

以上就是详解Java 类的加载、连接和初始化的详细内容,更多关于Java 类的加载、连接和初始化的资料请关注我们其它相关文章!

时间: 2020-06-22

Java类加载连接和初始化原理解析

1.当程序使用某个类时,JVM将会完成以下这三个步骤 2.连接 1)验证 验证是否是合法的字节码文件.验证JDK版本是否正确等. 2)准备 给成员变量(类变量/静态变量)赋默认值 把常量(final)等值在方法区的常量池中给准备好. 3)解析 虚拟机常量池内的符号引用(常量名)替换为引用(地址)的过程 3.初始化 <clinit> 类初始化 <clinit> 类初始化由两部分组成: (1)静态变量的显示初始化代码,赋值代码 (2)静态代码块 (1) 和 (2) 的顺序从上往下 当一

浅谈JAVA 类加载器

类加载机制 类加载器负责加载所有的类,系统为所有被载入内存中的类生成一个 java.lang.Class 实例.一旦一个类被载入 JVM 中,同个类就不会被再次载入了.现在的问题是,怎么样才算"同一个类"? 正如一个对象有一个唯一的标识一样,一个载入 JVM 中的类也有一个唯一的标识.在 Java 中,一个类用其全限定类名(包括包名和类名)作为标识:但在 JVM 中,一个类用其全限定类名和其类加载器作为唯一标识.例如,如果在 pg 的包中有一个名为 Person 的类,被类加载器 Cl

Java类加载机制实现流程及原理详解

前言 我们知道,Java项目编译后会生成许许多多的class文件,class文件保存着类的描述信息.虚拟机把描述类的数据从Class文件加载到内存,并对数据进行校验.转化解析和初始化,最终形成可以被虚拟机直接使用的Java类型,这就是虚拟机的类加载机制. 类的生命周期 类从被加载到虚拟机内存中开始,到卸载出内存位置,他的整个生命周期包括: 加载验证准备解析初始化使用卸载 这七个阶段.画个图就是下面这样: 其中,类加载的过程包括了加载.验证.准备.解析.初始化这五个阶段.其中加载.验证.准备.初始

详解JAVA类加载机制

1.一段简单的代码 首先来一段代码,这个是单例模式,可能有的人不知道什么是单例模式,我就简单说一下 单例模式是指一个类有且只有一种对象实例.这里用的是饿汉式,还有懒汉式,双检锁等等.... 写这个是为了给大家看一个现象 class SingleTon{ public static int count1; public static int count2=0; private static SingleTon instance=new SingleTon(); public SingleTon()

Java类的加载连接和初始化实例分析

本文实例讲述了Java类的加载连接和初始化.分享给大家供大家参考,具体如下: 一 点睛 1 类加载 当程序主动使用某个类时,如果该类还未被加载到内存中,系统会通过加载.连接.初始化三个步骤来对该类进行初始化,如果没有意外,JVM将会连续完成这三个步骤,所以有时也把这三个步骤统称为类加载或类初始化. 类加载指的是将类的class文件读入内存,并为之创建一个java.lang.Class对象,也就是说当程序使用任何类时,系统都会为之建立一个java.lang.Class对象. 2 类数据的来源 通过

classloader类加载器_基于java类的加载方式详解

基础概念 Classloader 类加载器,用来加载 Java 类到 Java 虚拟机中.与普通程序不同的是.Java程序(class文件)并不是本地的可执行程序.当运行Java程序时,首先运行JVM(Java虚拟机),然后再把Java class加载到JVM里头运行,负责加载Java class的这部分就叫做Class Loader. JVM本身包含了一个ClassLoader称为Bootstrap ClassLoader,和JVM一样,BootstrapClassLoader是用本地代码实现

java类的加载过程以及类加载器的分析

我们知道,我们写的java代码保存的格式是 .java, java文件被编译后会转换为字节码,字节码可以在任何平台通过java虚拟机来运行,这也是java能够跨平台的原因. 那JVM是如何来让我们写的java文件运行的呢? 这个问题通常的问法好像是:类是如何被加载的. 记得第一次遇见这个问题的时候,同学给我的回答是: 1.虚拟机会加载JDK里类的核心包 2.虚拟机会加载JDK里类的扩展包 3.虚拟机会加载JDK里类的系统包 4.虚拟机再会加载我们写好的java类. 初学的时候,大家都这么说,好像

JQuery中DOM加载与事件执行实例分析

本文实例讲述了JQuery中DOM加载与事件执行原理.分享给大家供大家参考.具体分析如下: JavaScript和HTML之间的交互是通过用户和浏览器操作页面时引发的事件来处理的.当文档或者它的某些元素发生某些变化或操作时,浏览器会自动生成一个事件.例如当浏览器装载完一个文档后,会生成事件:当用户单击某个按钮时,也会生成事件.虽然利用传统的JavaScript事件能完成这些交互,但jQuery增加并扩展了基本的事件处理机制.jQuery不仅提供了更加优雅的事件处理语法,而且极大地增强了事件处理能

从JVM分析Java的类的加载和卸载机制

类的加载 类的加载指的是将类的.class文件中的二进制数据读入到内存中,将其放在运行时数据区的方法区内,然后在堆区创建一个java.lang.Class对象,用来封装类在方法区内的数据结构. 加载.class文件的方式: 1.从本地系统中直接加载 2.通过网络下载.class文件 3.从zip,jar等归档文件中加载.class文件 4.从专有数据库中提取.class文件 5.将Java源文件动态编译为.class文件 类的加载的最终产品是位于堆区中的Class对象. Class对象封装了类在

举例讲解Java的内部类与类的加载器

内部类 class A { //Inner1 要在 A 初始化后 才能使用,即要被A的对象所调用 class Inner1 { int k = 0; // static int j = 0; //A加载后,Inner1没有加载,所以这个 静态变量j 无法立即使用,报错 final int z = 0; /*static void say1() { }*/ void say2() { } } //Inner2 在A加载好后就可以使用了 static class Inner2 { int k = 0

Java中类的加载顺序执行结果

具体代码如下所示: public class Parent { public static int a = parentStaticMethod2(); { System.out.println("父类非静态初始化块"); } static { System.out.println("父类静态初始化块"); } public Parent() { System.out.println("父类的构造方法"); } public static int

详解Java中类的加载顺序

本文介绍的是Java中类的加载顺序,下面来看看详细的介绍: 1.虚拟机在首次加载Java类时,会对静态初始化块.静态成员变量.静态方法进行一次初始化 2.只有在调用new方法时才会创建类的实例 3.类实例创建过程:按照父子继承关系进行初始化,首先执行父类的初始化块部分,然后是父类的构造方法:再执行本类继承的子类的初始化块,最后是子类的构造方法 4.类实例销毁时候,首先销毁子类部分,再销毁父类部分 示例 public class Parent { public static int t = par

php类自动加载器实现方法

本文实例讲述了php类自动加载器实现方法.分享给大家供大家参考.具体如下: 这里autoload 可兼容以下格式: Cache_File_Json class_xxx.php xxx.class.php   xxx.php php代码如下: function __autoload($className){ $dirs=explode('_',$className); $fileName=array_pop($dirs); //print_r($dirs); $filePath=$fileName

PHP实现的简单路由和类自动加载功能

本文实例讲述了PHP实现的简单路由和类自动加载功能.分享给大家供大家参考,具体如下: 项目目录如下 入口文件index.php <?php define('WEBROOT', 'C:/Users/Administrator/Documents/NetBeansProjects/test'); require_once(WEBROOT.'/core/environment.php'); core__app::run(); // 类自动加载文件environment.php <?php //根据类