JAVA类的加载(1) ——类的加载及类加载器介绍

过程：当程序主动使用某个类时，如果该类还未被加载到内存中，系统会通过加载、连接、初始化三个步骤来对该类进行初始化，有时候称为类加载（类初始化）

 

类加载 定义：类加载 指的是将类的class文件读入内存，并为之创建一个java.lang.Class对象

 

类也是一种对象：每个类是一批具有相同特征的对象的抽象，而系统中的所有类，它们实际上也是对象，它们都是java.lang.Class的实例

 

类加载器：类的加载由类加载器完成，JVM提供的类加载器称为系统类加载器，开发者可以通过继承ClassLoader基类来创建自己的类加载器

 

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

    （1）从本地文件系统加载class文件

    （2）从JAR包中加载class文件

    （3）通过网络加载class文件

    （4）把一个java源文件动态编译、并执行加载

 

 

类连接 定义：连接阶段将会负责把类的二进制数据合并到JRE中，又可分为如下三个阶段：

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

    （2）准备：为类的静态属性分配内存，并设置默认初始值

    （3）解析：将类的二进制数据中的符号引用替换成直接引用 ？？？  http://zhanjia.iteye.com/blog/1877236  http://m.oschina.net/blog/144133

 

类的初始化 定义：虚拟机对类进行初始化，主要是对静态属性进行初始化，有两种方式：

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

    （2）使用静态初始化块为静态属性执行初始值

public class Test {
    static {
        b = 6;
        System.out.println("-----------");
    }
    static int a = 9;
    static int b = 9;
    
    public static void main(String[] args) {
        System.out.println("b = " + Test.b);  //结果为9
    }
}

 

JVM初始化一个类的步骤：

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

    （2）假如该类的直接父类没有被初始化，则先初始化其直接父类（如果直接父类也有父类，会一直重复（1）（2）（3））

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

因此，JVM最先初始化的总是java.lang.Object类，当程序主动使用任何一个类时，系统会保证该类以及所有父类（包括直接父类和间接父类）都会被初始化

 

 

何时初始化类：当使用下面6种方式使用   

    （1）创建类的实例：包括用new、反射、反序列化来创建

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

    （3）访问某个类或接口的静态属性，或为该静态属性赋值

    （4）使用反射来强制创建某个类或接口对应的java.lang.Class对象。例如，代码Class.forName("Person")，如果系统还未初始化Person类，则这行代码会导致该Person类被初始化，并返回Person类对应的java.lang.Class对象

    （5）初始化某个类的子类

    （6）直接使用java.exe来运行某个主类，当运行某个主类时，程序会先初始化该主类

 

特殊说明1：对于一个final类型的静态属性

    （1）编译时常量：如果它的值在编译时就可以得到，系统使用时会认为是对该类的被动使用，所以不会导致该类的初始化

    （2）运行时常量：如果它的值必须在运行时才可以得到，会导致该类的初始化

 

class MyTest{
static {
System.out.println("静态初始化块");
}
 
static final String compileCon = "编译时常量";
static final String runningCon = System.currentTimeMillis() + "";
}
 
public class TestCompileConstant {
    public static void main(String[] args) {
        System.out.println(MyTest.compileCon);
        System.out.println("*****************");
        System.out.println(MyTest.runningCon);
    }
}

 

特殊说明2：当使用ClassLoader类的loadClass()方法加载某个类时，该方法只是加载该类，并不会执行该类的初始化；当使用Class类的forName()静态方法才会导致强制初始化该类

 

class MyTest1{
static {
System.out.println("MyTest1类的静态初始化块");
}
}
 
public class ClassLoaderTest{
    public static void main(String[] args) throws ClassNotFoundException{
                ClassLoader c1 = ClassLoader.getSystemClassLoader();
c1.loadClass("MyTest1"); //该语句仅是加载MyTest1类，并不执行该类的初始化
System.out.println("系统加载MyTest1类");
Class.forName("MyTest1");  //当使用Class的forName()静态方法才会导致该类的强制初始化
    }
}

 

 

 

类加载器简介：

 

1、一旦一个类被载入JVM中，同一个类就不会再被载入了。

 

那么 如何标识一个类：(全限定类名, 加载器)  或者叫做 (类名, 包名, 加载器)，如果在pg包中，有一个名为Person的类，被类加载器KclassLoader的实例k1负责加载，则该Person类对应的Class对象在JVM中表示为(Person，pg，k1)；这意味着两个类加载器加载的同名类：(Person，pg，k1)、(Person，pg，k2)是完全不同，互不兼容的。

 

 

2、当JVM启动时，会形成由三个类加载器组成的初始类加载器层次结构：

 

    （1）根类加载器（Bootstrap ClassLoader）：加载jdk/jre/lib/rt.jar等系统核心类库——比较特殊，它并不是java.lang.ClassLoader的子类，而是由JVM自身实现的

    （2）扩展类加载器（Extension ClassLoader）：它负责加载JRE的扩展目录（JAVA_HOME/jre/lib/ext或者由java.ext.dirs系统熟悉指定的目录）中JAR的类包。——通过这种方式，我们可以为Java扩展核心类以外的新功能，只要把我们自己开发的类包打成JAR文件，然后放入JAVA_HOME/jre/lib/ext路径即可

    （3）系统（应用）类加载器（System ClassLoader）：它负责在JVM启动时，加载来自命令java中的-classpath选项或java.class.path系统属性，或者CLASSPATH环境变量所指定的JAR包和类路径——通过ClassLoader的静态方法getSystemClassLoader()获取该类系统类加载器

 

JVM的类加载机制主要有如下三种机制：

1、全盘负责：当一个类加载器负责加载某个Class的时候，该Class所依赖的和引用的其它Class也将由该类加载器负责载入，除非使用另一个类加载器来载入

2、父类委托：先让parent（父）类加载器试图加载该Class，只有在父类加载器无法加载该类时才尝试从自己的类路径中加载该类

3、缓存机制：缓存机制会保证所有被加载过的Class都会被缓存，当程序中需要使用某个Class时，类加载器会先从缓存中搜该Class，只有缓存中不存在该        Class对象时，系统才会重新读取该类对应的二进制数据，并将其转换成Class对象，并存入cache。——这就是为什么我们修改了Class后，程序必须重新启动JVM，程序所做的修改才会生效的原因

 

例1：

import java.net.URL;
 
public class BootstrapTest {
    public static void main(String[] args) {
        //获取根类加载器所加载的全部URL数组
        URL[] urls = sun.misc.Launcher.getBootstrapClassPath().getURLs(); 
        //遍历、输出根类加载器加载的全部URL
        for (int i=0; i<urls.length; i++) {
            System.out.println(urls[i].toExternalForm());
        }
    }
}                        

 

例2：

import java.net.URL;
import java.util.Enumeration;
import java.io.*;

public class ClassLoaderProp {
    public static void main(String[] args) throws IOException {
        ClassLoader systemLoader = ClassLoader.getSystemClassLoader();
        System.out.println("系统类加载器: " + systemLoader);
        
        //获取系统类加载器的加载路径，通常由classpath环境变量指定
        //如果操作系统没有指定classpath变量，默认以当前路径作为系统类加载器的加载路径
        Enumeration<URL> em1 = systemLoader.getResources("");
        while (em1.hasMoreElements()) {
            System.out.println(em1.nextElement());
        }
        
        //获取系统类加载器的父类加载器——应该得到扩展类加载器
        ClassLoader extensionLader = systemLoader.getParent();
        System.out.println("扩展类加载器：" + extensionLader);
        System.out.println("扩展类加载器的加载路径：" + System.getProperty("java.ext.dirs"));
        System.out.println("扩展类加载器的parent：" + extensionLader.getParent());
    }
}

 

几点结论：

1、系统类加载器的路径是classpath指定的路径

2、扩展类加载器的路径：是JAVA_HOME/jre/lib/ext或者由java.ext.dirs系统熟悉指定的目录

3、扩展类加载器的父加载器是null，这是因为根加载器没有继承ClassLoader抽象类，所以此处返回null；但根类加载器确实是扩展类加载器的父类加载器

4、系统类加载器是AppClassLoader的实例，扩展类加载器是ExtClassLoader的实例，实际上这两个类都是URLClassLoader的实例

继承关系:

java.lang.Object

       --- java.lang.ClassLoader
              --- java.security.SecureClassLoader
                      ---  java.net.URLClassLoader
                            --- sun.misc.Launcher$ExtClassLoader

java.lang.Object

       --- java.lang.ClassLoader
              --- java.security.SecureClassLoader
                      ---  java.net.URLClassLoader
                            --- sun.misc.Launcher$AppClassLoader

 

 

类加载体系的目标：

1、类能够延迟加载

2、加载后能够有效运行

3、类之间能够隔离

4、类占用的资源能够回收