基本数据类型由虚拟机预先定义，引用数据类型则需要进行类的加载。
加载就是将Java类的字节码文件加载到机器内存中，并在内存中构建出Java类的原型——类模板对象。 Java类模型）。 在内存中生成一个代表这个类的java.lang.Class对象，作为方法区这个类的各种数据访问的入口。
加载的类在JVM中创建相应的类结构，类结构会存储在方法区（JDK 1.8之前在永久代；JDK1.8之后在元空间）。类将.class文件加载至元空间后，会在堆中创建一个java.lang.Class对象，用来封装类位于方法区内的数据结构，该Class对象是在加载类的过程中创建的，每个类都对应有一个Class类型的对象。图示：外部可以通过访问代表Order类的Class对象来获取Order的类数据结构
注意：Class类的构造方法是私有的，只有JVM能够创建。
数组类本身并不是由类加载器负责创建，而是由JVM在运行时根据需要而直接创建的，但数组的元素类型仍然需要依靠类加载器去创建。创建数组类的过程： 如果数组的元素类型是引用类型，数组类的可访问性就由元素类型的可访问性决定。否则数组类的可访问性将被缺省定义为public。
它的目的是保证加载的字节码是合法、合理并符合规范的。验证的步骤比较复杂，实际要验证的项目也很繁多，大体上Java虚拟机需要做以下检查，如图所示：
格式验证会和加载阶段一起执行。验证通过之后，类加载器才会成功将类的二进制数据信息加载到方法区中。 格式验证之外的验证操作将会在方法区中进行。
它也是验证过程中最为复杂的一个过程。它试图通过对字节码流的分析，判断字节码是否可以被正确地执行 补充：栈映射帧（StackMapTable）就是在这个阶段，用于检测在特定的字节码处，其局部变量表和操作数栈是否有着正确的数据类型。但遗憾的是，100%准确地判断一段字节码是否可以被安全执行是无法实现的，因此，该过程只是尽可能地检查出可以预知的明显的问题。如果在这个阶段无法通过检查，虚拟机也不会正确装载这个类。但是，如果通过了这个阶段的检查，也不能说明这个类是完全没有问题的。 在验证阶段，虚拟机就会检查这些类或者方法确实是存在的，并且当前类有权限访问这些数据，如果一个需要使用类无法在系统中找到，则会抛出NoClassDefFoundError，如果一个方法无法被找到，则会抛出NoSuchMethdError，此阶段在解析环节才会执行。
准备阶段（Preparation）为类的静态变量分配内存，并将其初始化为默认值。
这里不包含基本数据类型的字段用static final修饰的情况，因为final在编译的时候就会分配了，准备阶段会显式赋值。 注意这里不会为实例变量分配初始化，类变量会分配在方法区中，而实例变量是会随着对象一起分配到 Java堆中。
解析阶段（Resolution），将类、接口、字段和方法的符号引用转为直接引用。 通过解析操作，符号引用就可以转变为目标方法在类中方法表中的位置，从而使得方法被成功调用。
初始化阶段为类的静态变量赋予正确的初始值（显式赋值）。到了初始化阶段，才真正开始执行类中定义的Java程序代码）初始化阶段的重要工作是执行类的初始化方法：<clinit>()方法
在加载一个类之前，虚拟机总是会试图加载该类的父类，因此父类的<clinit>总是在子类<clinit>之前被调用，也就是说，父类的static块优先级高于子类。由父及子，静态先行（静态先执行）。
public class InitializationTest1 {
public int num;
public int num1 = 1 ;
public static int num2;
public static final int num3 = 1 ;
}
public class InitializationTest2 {
public static int a = 1 ;
public static final int b = 10 ;
public static final Integer c = Integer . valueOf ( 100 ) ;
public static Integer d = Integer . valueOf ( 1000 ) ;
public static final String e = "hello1" ;
public static final String f = new String ( "hello2" ) ;
public static String g = "hello3" ;
public static final int h = new Random ( ) . nextInt ( 10 ) ;
}
对于基本数据类型的字段来说，如果使用static final来修饰，则显示赋值（直接赋值常量情况，而非调用方法）通常是在链接阶段的准备环节进行的。 对于String来说，如果使用字面量的方式赋值，并且使用了static final修饰，则显示赋值通常是在链接阶段的准备环节进行的。 最终结论：使用static + final修饰，且显式赋值中不涉及到方法或构造器调用的基本数据类型或String类型的显式赋值，是在链接阶段的准备环节进行的；其他的情况都是在初始化阶段<clinit>()中赋值。
正是因为函数<clinit>()带锁线程安全的，因此，如果一个在类的<clinit>()方法中有耗时很长的操作，就可能造成多个线程阻塞，引发死锁。并且这种死锁是很难发现的，因为看起来它们并没有可用的锁信息。
public class StaticDeadLockTest extends Thread {
private char flag;
public StaticDeadLockTest ( char flag) {
this . flag = flag;
this . setName ( "Thread" + flag) ;
}
@Override
public void run ( ) {
try {
Class . forName ( "com.itan.middle.day3.Static" + flag) ;
} catch ( ClassNotFoundException e) {
}
System . out. println ( getName ( ) + "over" ) ;
}
public static void main ( String [ ] args) {
StaticDeadLockTest loadA = new StaticDeadLockTest ( 'A' ) ;
loadA. start ( ) ;
StaticDeadLockTest loadB = new StaticDeadLockTest ( 'B' ) ;
loadB. start ( ) ;
}
}
class StaticA {
static {
try {
Thread . sleep ( 1000 ) ;
} catch ( InterruptedException e) {
}
try {
Class . forName ( "com.itan.middle.day3.StaticB" ) ;
} catch ( ClassNotFoundException e) {
}
System . out. println ( "StaticA init ok" ) ;
}
}
class StaticB {
static {
try {
Thread . sleep ( 1000 ) ;
} catch ( InterruptedException e) {
}
try {
Class . forName ( "com.itan.middle.day3.StaticA" ) ;
} catch ( ClassNotFoundException e) {
}
System . out. println ( "StaticB init ok" ) ;
}
}
主动使用（会调用类的<clinit>()方法，执行了类的初始化阶段）和被动使用。 invokestatic 。 getstatic或putstatic（访问变量、赋值变量的操作）。
public class ActiveUse1 {
public static void main ( String [ ] args) throws InterruptedException {
Order order = new Order ( ) ;
}
@Test
public void test1 ( ) {
ObjectOutputStream oss = null ;
try {
oss = new ObjectOutputStream ( new FileOutputStream ( "order.dat" ) ) ;
oss. writeObject ( new Order ( ) ) ;
} catch ( IOException e) {
e. printStackTrace ( ) ;
} finally {
try {
if ( oss != null ) {
oss. close ( ) ;
}
} catch ( IOException e) {
e. printStackTrace ( ) ;
}
}
}
@Test
public void test2 ( ) {
ObjectInputStream ois = null ;
try {
ois = new ObjectInputStream ( new FileInputStream ( "order.dat" ) ) ;
Order order = ( Order ) ois. readObject ( ) ;
} catch ( IOException e) {
e. printStackTrace ( ) ;
} catch ( ClassNotFoundException e) {
e. printStackTrace ( ) ;
} finally {
try {
if ( ois != null ) {
ois. close ( ) ;
}
} catch ( IOException e) {
e. printStackTrace ( ) ;
}
}
}
@Test
public void test3 ( ) {
Order . method1 ( ) ;
}
}
class Order implements Serializable {
static {
System . out. println ( "Order init" ) ;
}
public static void method1 ( ) {
System . out. println ( "Order static method()" ) ;
}
}
public class ActiveUse2 {
@Test
public void test1 ( ) {
System . out. println ( User . num3) ;
}
@Test
public void test2 ( ) {
System . out. println ( InterfaceA . num2) ;
}
}
class User {
public static int num1 = 1 ;
public static final int num2 = 1 ;
public static final int num3 = new Random ( ) . nextInt ( 10 ) ;
static {
System . out. println ( "User init" ) ;
}
}
interface InterfaceA {
public static final Object t = new Object ( ) {
{
System . out. println ( "InterfaceA init" ) ;
}
} ;
public static final int num1 = 1 ;
public static final int num2 = new Random ( ) . nextInt ( 10 ) ;
}
public class ActiveUse3 {
@Test
public void test1 ( ) throws ClassNotFoundException {
Class clazz = Class . forName ( "com.itan.middle.day4.Order" ) ;
}
@Test
public void test2 ( ) {
System . out. println ( Son . num) ;
}
@Test
public void test3 ( ) {
System . out. println ( Father . num) ;
}
@Test
public void test4 ( ) {
System . out. println ( InterfaceC . num) ;
}
}
class Father {
static {
System . out. println ( "Father init" ) ;
}
public static int num = 1 ;
}
class Son extends Father {
static {
System . out. println ( "Son init" ) ;
}
public static int num = 2 ;
}
interface InterfaceB {
public static final Object t = new Object ( ) {
{
System . out. println ( "InterfaceB init" ) ;
}
} ;
}
interface InterfaceC extends InterfaceB {
public static final Object t = new Object ( ) {
{
System . out. println ( "InterfaceC init" ) ;
}
} ;
public static final int num = new Random ( ) . nextInt ( 10 ) ;
}
public class ActiveUse4 {
static {
System . out. println ( "ActiveUse4 init" ) ;
}
@Test
public void test1 ( ) {
System . out. println ( Father1 . num) ;
}
public static void main ( String [ ] args) {
System . out. println ( "main" ) ;
}
}
class Father1 implements InterfaceB1 {
static {
System . out. println ( "Father init" ) ;
}
public static int num = 1 ;
}
interface InterfaceB1 {
public final static Object t = new Object ( ) {
{
System . out. println ( "InterfaceB1 init" ) ;
}
} ;
public default void method ( ) {
System . out. println ( "Interface default method" ) ;
}
}
被动使用不会引起类的初始化，也不会调用<clinit>()方法，也就是说：并不是在代码中出现的类，就一定会被加载或者初始化。如果不符合主动使用的条件，类就不会初始化。
public class PassiveUse1 {
@Test
public void test1 ( ) {
System . out. println ( Child . num) ;
}
@Test
public void test2 ( ) {
Parent [ ] parents = new Parent [ 10 ] ;
}
@Test
public void test3 ( ) {
Parent [ ] parents = new Parent [ 10 ] ;
parents[ 0 ] = new Parent ( ) ;
parents[ 1 ] = new Parent ( ) ;
}
}
class Parent {
static {
System . out. println ( "Parent init" ) ;
}
public static int num = 1 ;
}
class Child extends Parent {
static {
System . out. println ( "Child init" ) ;
}
}
public class PassiveUse2 {
@Test
public void test1 ( ) {
System . out. println ( Parent1 . num) ;
}
@Test
public void test2 ( ) {
System . out. println ( InterfaceC1 . num) ;
}
@Test
public void test3 ( ) throws ClassNotFoundException {
Class clazz = ClassLoader . getSystemClassLoader ( ) . loadClass ( "com.itan.middle.day4.Parent1" ) ;
}
}
class Parent1 {
static {
System . out. println ( "Parent1 init" ) ;
}
public static final int num = 1 ;
}
interface InterfaceC1 {
public final static Object t = new Object ( ) {
{
System . out. println ( "InterfaceC1 init" ) ;
}
} ;
public static final int num = 1 ;
}
一个类何时结束生命周期，取决于代表它的Class对象何时结束生命周期。
扫一扫
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
