Java Class-类-对象 类加载器

 

声明：本文仅仅是总结学习笔记，使用了以下5篇文章

1.  深入研究java.lang.Class类

（http://wenku.baidu.com/link?url=JYgIYDCKKZ6AOZ3pRuqcZwJgXVkgEYiW0foYI5ujFgPl25QaHY31Wd7qWv5ukZYebh39FwD76_jD8ekF3RWrodMowULmlMWm5JrqnRwcp5y）

2.  认识java的Class类

（http://www.blogjava.net/formatmyself/articles/21291.html）

3.  对于java类加载器的认识（1）

（http://www.blogjava.net/formatmyself/articles/21297.html）

4.  对于java类加载器的认识（2）

（http://www.blogjava.net/formatmyself/articles/21330.html）

5.  Java类加载器总结

（http://blog.csdn.net/gjanyanlig/article/details/6818655）

 

一.Class简介

 

Java程序在运行时，Java运行时系统一直对所有的对象进行所谓的运行时类型标识。这项信息纪录了每个对象所属的类。虚拟机通常使用运行时类型信息选准正确方法去执行，用来保存这些类型信息的类是Class类。

Class类封装一个对象和接口运行时的状态，当装载类时，Class类型的对象自动创建。  Class 没有公共构造方法。Class 对象是在加载类时由 Java 虚拟机以及通过调用类加载器中的 defineClass 方法自动构造的，因此不能显式地声明一个Class对象。

虚拟机为每种类型管理一个独一无二的Class对象。也就是说，每个类（型）都有一个Class对象。运行程序时，Java虚拟机(JVM)首先检查是否所要加载的类对应的Class对象是否已经加载。如果没有加载，JVM就会根据类名查找.class文件，并将其Class对象载入。

基本的 Java 类型（boolean、byte、char、short、int、long、float 和 double）和关键字 void 也都对应一个 Class 对象。

每个数组属于被映射为 Class 对象的一个类，所有具有相同元素类型和维数的数组都共享该 Class 对象。

一般某个类的Class对象被载入内存，它就用来创建这个类的所有对象。  

有三种方法可以的获取：

1、调用Object类的getClass()方法来得到Class对象，这也是最常见的产生Class对象的方法。

例如： MyObject x; Class c1 = x.getClass(); 

2、使用Class类的中静态forName()方法获得与字符串对应的Class对象。

例如： Classc2=Class.forName("MyObject"),Employee必须是接口或者类的名字。 

3、获取Class类型对象的第三个方法非常简单。如果T是一个Java类型，那么T.class就代表了匹配的类对象。

例如 Class cl1 = Manager.class; Class cl2 =int.class; Class cl3 = Double[].class; 

注意：Class对象实际上描述的只是类型，而这类型未必是类或者接口。

例如上面的int.class是一个Class类型的对象。

由于历史原因，数组类型的getName方法会返回奇怪的名字。 

 

二.Class类的常用方法

1、 forName(String classname)和 forName(String classname，booleaninitialze,ClassLoader loader) 

给定串名相应的Class 对象。若给定一个类或接口的完整路径名，那么此方法将试图定位、装载和连接该类。若成功，返回该类对象。否则，抛出 ClassNotFoundException 异常。

例如，下面代码段返回名为java.lang.Thread 的运行 Class 描述器。

Class t = Class.forName("java.lang.Thread"); 

此方法是需要指定类加载器的，当用到仅有一个String参数的forName方法时，Class对象将默认调用当前类加载器作为加载器和将第二参数为true。第二个参数说明：如果是false时，调用forName方法只是在命令类加载器载入该类，而不初始化该类的静态区块，只有当该类第一次实例化时，静态区块才被调用。当为true时，则载入时就调用静态区块

2、 getName()

一个Class对象描述了一个特定类的属性，Class类中最常用的方法getName以 String 的形式返回此 Class 对象所表示的实体（类、接口、数组类、基本类型或 void）名称。 

3、 newInstance() 

Class还有一个有用的方法可以为类创建一个实例，这个方法叫做newInstance()。

例如： x.getClass.newInstance()，创建了一个同x一样类型的新实例。newInstance()方法调用默认构造器（无参数构造器）初始化新建对象。 

4、 getClassLoader() 

返回该类的类加载器

5、 getComponentType()  

返回表示数组组件类型的 Class

 

三.Class和类以及对象的关系

 

Java类：用于描述一类事物的共性

对象：类的实例化

Class：Java类在内存中保存（每个Java类对应一份Class对象）

 

在运行期间，如果我们要产生某个类的对象，Java虚拟机(JVM)会检查该类型的Class对象是否已被加载。如果没有被加载，JVM会根据类的名称找到.class文件并加载它。一旦某个类型的Class对象已被加载到内存，就可以用它来产生该类型的所有对象。我们生成的对象都会有个字段记录该对象所属类在CLass类的对象的所在位置。

                                                            

 

注意：虚拟机只会产生一份字节码， 用这份字节码可以产生多个实例对象

 

四.类加载器

 

java是具有动态性，什么是动态性？有个最直观的例子：windows系统的即插即用，支持即插即用的设备可以在系统不重新启动的情况下既可以热把插使用。而java的动态性表现在：我们的程序可以不用全盘的重新编译就能对程序某部分进行更新，C#也和java一样具有动态性，而且它的这种动态性表现更为直观：直接生成windows的动态连接库文件——dll文件。而java生成的是class文件，class是怎么实现动态性的了,这个时候就全靠我们今天的主角：java的类加载器。

    我们都知道所有的java类都是继承了object这个类，在object这个类中有一个方法：getclass(),这个方法返回的是一个Class类对象

    一旦一个类被载入JVM中，同一个类就不会被再次载入了（切记，同一个类）。这里存在一个问题就是什么是“同一个类”？正如一个对象有一个具体的状态，即标识，一个对象始终和其代码(类)相关联(见文认识java的Class类)。同理，载入JVM的类也应该有一个具体的标识，我们知道：在JAVA中，一个类用其完全匹配类名(fully qualified class name)作为标识，这里指的完全匹配类名是包名和类名。不过在JVM中一个类是用其全名再附加上一个加载类ClassLoader的实例作为唯一标识。因此，如果一个名为Pg的包中，有一个名为Cl的类，被类加载器KlassLoader的一个实例对象kl1加载，生成Cl的对象，即C1.class(这里指类，而非对象)在JVM中表示为(Cl, Pg,kl1)。这意味着两个类加载器的实例(Cl, Pg, kl1) 和 (Cl, Pg, kl2)是不同的，被它们所加载的类也因此完全不同，互不兼容的。

    在java中每个类都是由某个类加载器的实体来载入的，因此在Class类的实体中，都会有字段记录载入它的类加载器的实体（当为null时，其实是指Bootstrap ClassLoader）。 在java类加载器中除了引导类加载器（既Bootstrap ClassLoader），所有的类加载器都有一个父类加载器(因为他们本身自己就是java类)。而类的加载机制是遵循一种委托模式：当类加载器有加载类的需求时，会先请求其Parent加载(依次递归),如果在其父加载器树中都没有成功加载该类，则由当前类加载器加载。

 

java的类加载器分为以下几种：

 

1.  BootstrapClassLoader，用C++实现，一切的开始，是所有类加载器的最终父加载器。负责将一些关键的Java类，如java.lang.Object和其他一些运行时代码先加载进内存中。

2.  ExtClassLoader，用java实现，是Launcher.java的内部类，编译后的名字为：Launcher$ExtClassLoader.class 。此类由BootstrapClassLoader加载，但由于Bootstrap ClassLoader已经脱离了java体系(c++),所以Launcher$ExtClassLoader.class的Parent(父加载器)被设置为null;它用于装载Java运行环境扩展包(jre/lib/ext)中的类，而且一旦建立其加载的路径将不再改变。

3.  AppClassLoader,用java实现，也是是Launcher.java的内部类，编译后的名字为：Launcher$AppClassLoader.class 。AppClassLoader是当Bootstrap ClassLoader加载完ExtClassLoader后，再被Bootstrap ClassLoader加载。所以ExtClassLoader和AppClassLoader都是被Bootstrap ClassLoader加载，但AppClassLoader的Parent被设置为ExtClassLoader。可见Parent和由哪个类加载器来加载不一定是对应的。

这个类装载器是我们经常使用的，可以调用ClassLoader.getSystemClassLoader() 来获得，如果程序中没有使用类装载器相关操作设定或者自定义新的类装载器，那么我们编写的所有java类都会由它来装载。而它的查找区域就是我们常常说到的Classpath，一旦建立其加载路径也不再改变。

4.  ClassLoader：一般我们自定义的ClassLoader从ClassLoader类继承而来。比如：URLClassloader是ClassLoader的一个子类，而URLClassloader也是ExtClassLoader和AppClassLoader的父类（注意不是父加载器）。

 

实现java的动态性有两种方法类型：一种是隐式，另一种是显式。

隐式：new 这个关键字我们都认识，当我们用其将类实例化时（即将对象载入），这种就是隐式

显式：一种可以由java.long.Class里面的forName()方法将类实例化，其中也用到了类加载器

另一种：是由也就是直接用类加载器ClassLoader来实现。

 

ClassLoader一些重要的方法

 

A)  loadClass

   ClassLoader.loadClass() 是 ClassLoader 的入口点。该方法的定义如下：

   Class loadClass( String name, booleanresolve );

   参数name  JVM 需要的类的名称，如 Person 或 java.lang.Object。

   参数 resolve 参数告诉方法是否需要解析类。在准备执行类之前，应考虑类解析。并不总是需要解析。如果 JVM 只需要知道该类是否存在或找出该类的超类，那么就不需要解析详情见： Class类中的forName()方法的介绍。

 

B)  方法 defineClass

    defineClass 方法是ClassLoader 的主要诀窍。该方法接受由原始字节组成的数组并把它转换成 Class 对象。原始数组包含如从文件系统或网络装入的数据。defineClass 管理 JVM 的许多复杂、神秘和倚赖于实现的方面 -- 它把字节码分析成运行时数据结构、校验有效性等等。不必担心，您无需亲自编写它。事实上，即使您想要这么做也不能覆盖它，因为它已被标记成final的。

 

C)  方法 findSystemClass

    findSystemClass 方法从本地文件系统装入文件。它在本地文件系统中寻找类文件，如果存在，就使用 defineClass 将原始字节转换成 Class 对象，以将该文件转换成类。当运行 Java 应用程序时，这是 JVM 正常装入类的缺省机制。（Java 2 中 ClassLoader 的变动提供了关于 Java 版本 1.2 这个过程变动的详细信息。） 对于定制的 ClassLoader，只有在尝试其它方法装入类之后，再使用findSystemClass。原因很简单：ClassLoader 是负责执行装入类的特殊步骤，不是负责所有类。例如，即使 ClassLoader 从远程的 Web 站点装入了某些类，仍然需要在本地机器上装入大量的基本 Java 库。而这些类不是我们所关心的，所以要 JVM 以缺省方式装入它们：从本地文件系统。这就是 findSystemClass 的用途。

 

D)  方法 resolveClass

    正如前面所提到的，可以不完全地（不带解析）装入类，也可以完全地（带解析）装入类。当编写我们自己的 loadClass 时，可以调用 resolveClass，这取决于 loadClass 的 resolve 参数的值。

 

E)  方法 findLoadedClass

    findLoadedClass 充当一个缓存：当请求 loadClass 装入类时，它调用该方法来查看 ClassLoader 是否已装入这个类，这样可以避免重新装入已存在类所造成的麻烦。应首先调用该方法。

 

怎么组装这些方法

  1） 调用findLoadedClass 来查看是否存在已装入的类。

  2） 如果没有，那么采用那种特殊的神奇方式来获取原始字节。

  3） 如果已有原始字节，调用defineClass 将它们转换成 Class 对象。

  4） 如果没有原始字节，然后调用 findSystemClass 查看是否从本地文件系统获取类。

  5） 如果 resolve 参数是 true，那么调用 resolveClass 解析 Class 对象。

  6） 如果还没有类，返回ClassNotFoundException。

 

Java 2 中 ClassLoader 的变动

1.  loadClass 的缺省实现

           定制编写的 loadClass 方法一般尝试几种方式来装入所请求的类，如果您编写许多类，会发现一次次地在相同的、很复杂的方法上编写变量。在 Java 1.2 中 loadClass 的实现嵌入了大多数查找类的一般方法，并使您通过覆盖 findClass 方法来定制它，在适当的时候 findClass 会调用 loadClass。 这种方式的好处是您可能不一定要覆盖 loadClass；只要覆盖 findClass 就行了，这减少了工作量。

 

2.  新方法：findClass

           loadClass的缺省实现调用这个新方法。findClass 的用途包含您的 ClassLoader 的所有特殊代码，而无需要复制其它代码（例如，当专门的方法失败时，调用系统 ClassLoader）。

 

3.  新方法：getSystemClassLoader

           如果覆盖 findClass或 loadClass，getSystemClassLoader使您能以实际 ClassLoader 对象来访问系统ClassLoader（而不是固定的从 findSystemClass 调用它）。

 

4.  新方法：getParent 

            为了将类请求委托给父代ClassLoader，这个新方法允许 ClassLoader 获取它的父代 ClassLoader。当使用特殊方法，定制的 ClassLoader 不能找到类时，可以使用这种方法。

父代 ClassLoader 被定义成创建该ClassLoader 所包含代码的对象的 ClassLoader。 

 

五.Java类加载过程

 

1.  类的加载过程 

JVM将类加载过程分为三个步骤：装载（Load），链接（Link）和初始化(Initialize)链接又分为三个步骤，如下图所示：

1) 装载：查找并加载类的二进制数据；

2) 链接：

验证：确保被加载类的正确性；

准备：为类的静态变量分配内存，并将其初始化为默认值；

解析：把类中的符号引用转换为直接引用；

3) 初始化：为类的静态变量赋予正确的初始值；

那为什么我要有验证这一步骤呢？首先如果由编译器生成的class文件，它肯定是符合JVM字节码格式的，但是万一有高手自己写一个class文件，让JVM加载并运行，用于恶意用途，就不妙了，因此这个class文件要先过验证这一关，不符合的话不会让它继续执行的，也是为了安全考虑吧。

准备阶段和初始化阶段看似有点牟盾，其实是不牟盾的，如果类中有语句：private static int a = 10，它的执行过程是这样的，首先字节码文件被加载到内存后，先进行链接的验证这一步骤，验证通过后准备阶段，给a分配内存，因为变量a是static的，所以此时a等于int类型的默认初始值0，即a=0,然后到解析（后面在说），到初始化这一步骤时，才把a的真正的值10赋给a,此时a=10。

 

2.  类的初始化

类什么时候才被初始化：

1）创建类的实例，也就是new一个对象

2）访问某个类或接口的静态变量，或者对该静态变量赋值

3）调用类的静态方法

4）反射（Class.forName("com.lyj.load")）

5）初始化一个类的子类（会首先初始化子类的父类）

6）JVM启动时标明的启动类，即文件名和类名相同的那个类

只有这6中情况才会导致类的类的初始化。

类的初始化步骤：

1）如果这个类还没有被加载和链接，那先进行加载和链接

2）假如这个类存在直接父类，并且这个类还没有被初始化（注意：在一个类加载器中，类只能初始化一次），那就初始化直接的父类（不适用于接口）

3) 加入类中存在初始化语句（如static变量和static块），那就依次执行这些初始化语句。

 

3.  类的加载

类的加载指的是将类的.class文件中的二进制数据读入到内存中，将其放在运行时数据区的方法区内，然后在堆区创建一个这个类的java.lang.Class对象，用来封装类在方法区类的对象。看下面2图

 

类的加载的最终产品是位于堆区中的Class对象

Class对象封装了类在方法区内的数据结构，并且向Java程序员提供了访问方法区内的数据结构的接口

加载类的方式有以下几种：

1）从本地系统直接加载

2）通过网络下载.class文件

3）从zip，jar等归档文件中加载.class文件

4）从专有数据库中提取.class文件

5）将Java源文件动态编译为.class文件（服务器）

 

4.  加载器

来自http://blog.csdn.net/cutesource/article/details/5904501

JVM的类加载是通过ClassLoader及其子类来完成的，类的层次关系和加载顺序可以由下图来描述：

1）Bootstrap ClassLoader

负责加载$JAVA_HOME中jre/lib/rt.jar里所有的class，由C++实现，不是ClassLoader子类

2）Extension ClassLoader

负责加载java平台中扩展功能的一些jar包，包括$JAVA_HOME中jre/lib/*.jar或-Djava.ext.dirs指定目录下的jar包

3）App ClassLoader

负责记载classpath中指定的jar包及目录中class

4）Custom ClassLoader

属于应用程序根据自身需要自定义的ClassLoader，如tomcat、jboss都会根据j2ee规范自行实现ClassLoader

加载过程中会先检查类是否被已加载，检查顺序是自底向上，从Custom ClassLoader到BootStrap ClassLoader逐层检查，只要某个classloader已加载就视为已加载此类，保证此类只所有ClassLoader加载一次。而加载的顺序是自顶向下，也就是由上层来逐层尝试加载此类。