类加载机制与反射

（一）类加载机制与反射

　　　Java类加载器除了根类加载器之外，其他类加载器都是使用Java语言编写的，所以程序员完全可以开发自己的类加载器，通过使用自定义类加载器，可以完成一些特定的功能。

 

（二）类的加载、连接和初始化

　　系统可能在第一次使用某个类时加载该类，也可能采用预加载机制来加载某个类。

　　1.　　JVM和类　　

　　当我们调用Java命令运行某个Java程序时，该命令将会启动一个Java虚拟机进程，不管该Java程序有多么复杂，该程序启动了多少个线程，它们都处于该Java虚拟机进程里。

　　同一个JVM的所有线程、所有变量都处于同一个进程里，它们都使用该JVM进程的内存区。

　　当系统出现以下几种情况时，JVM进程将被终止：

　　　　（1）程序运行到最后正常结束。

　　　　（2）程序运行到使用System.exit()或Runtime.getRuntime().exit()代码处结束程序。

　　　　（3）程序执行过程中遇到未捕获的异常或错误而结束。

　　　　（4）程序所在平台强制结束了JVM进行。

 

下面举例说明：不同JVM程序的运行情况：

public class A
{
    //定义该类的静态Field
    public static int a = 6;
}

 

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

 

 运行结果：7

 

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

 

运行结果：6

 

 

因为运行ATest1和ATest2是两次运行JVM进程，第一次运行JVM结束后，它对A类所做的修改将全部丢失---第二次运行JVM时将再次初始化A类。

 

 　　2.　　类的加载

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

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

　　　　类的加载由类加载器完成，类加载器通常由JVM提供，JVM提供的这些类加载器通常被称为系统类加载器。除此之外，开发者还可以通过继承ClassLoader基类来创建自己的类加载器。

　　通过使用不同的类加载器，可以从不同来源加载类的二进制数据：

　　1.从本地系统加载class文件。

　　2.从JAR包加载class文件

　　3.通过网络加载class文件

　　4.把一个Java源文件动态编译，并执行加载

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

 

 　　3.　　类的连接

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

类连接又可分为如下3个阶段：

（1）验证：验证阶段用于检验被加载的类是否有正确的内部结构，并和其他类协调一致。

（2）准备：类准备阶段则负责为类的静态Field分配内存，并设置默认初始值。

（3）解析：将类的二进制数据中的符号引用替换成直接引用。

 

 　　4.　　类的初始化

　　在类的初始化阶段，虚拟机负责对类进行初始化，主要就是对静态Field进行初始化。在Java类中对静态Field指定初始值有两种方式：

　　（1）声明静态Field时指定初始值

　　（2）使用静态初始化块为静态Field指定初始值　　

public class Test
{
    //声明a变量时指定初始值
    static int a = 5;
    static int b;
    static int c;
    
    static
    {
        //使用静态初始化块b变量指定初始值
        b = 6;
    }
}

 

 

 

　　对于上面代码，程序为静态Field a、b都显示指定了初始值，所以这两个静态Field的值分别为5、6，但静态Field c则没有指定初始值，它将采用默认初始值0

 

 

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

　　（1）假如这个类还没有被加载和连接，则程序先加载并连接该类。

　　（2）假如该类的直接父类还没有被初始化，则先初始化其直接父类。

　　（3）假如类中有初始化语句，则系统依次执行这些初始化语句。

　　（注意：当执行第2个步骤时，系统对直接父类的初始化步骤也遵循此步骤1-3；如果该直接父类又有直接父类，则系统再次重复这3个步骤来先初始化这个父类....依次类推，所以JVM最先初始化的总是java.lang.Object类。当程序主动使用任何一个类时，系统会保证该类以及所有父类都会被初始化）

 

 

 （三）类初始化时机

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

（1）创建类的实例。为某个类创建实例的方法包括：使用new操作符来创建实例，通过反射来创建实例，通过反序列化的方式来创建实例。

（2）调用某个类的静态方法

（3）访问某个类或接口的静态Field,或为该静态Filed赋值。

（4）使用反射方式来强制创建某个类或接口对应的java.lang.Class对象。

（5）初始化某个类的子类。当初始化某个类的子类时，该子类的所有父类都会初始化。

（6）直接使用java.exe命令来运行某个主类。

 

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

　　下面举例:

package Chapter18;

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

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

　　运行结果:

　　　　　　疯狂Java讲义

　　

　　上面程序的MyTest类中有一个compileConstant的静态Field，该Field使用了final修饰，而且它的值可以在编译时确定下来，因此compileConstant会被当成"宏变量"处理。程序中所有使用compileConstant的地方都会在编译时被直接替换成它的值---也就是说，上面程序1处在编译时就会被替换成"疯狂Java讲义"，所以1处不可能初始化MyTest类。

 （注意：当使用ClassLoader类的loadClass()方法来加载某个类时，该方法只是加载该类，并不会执行该类的初始化。）