类是怎么被加载的

.java--->.class--->二进制字节流--->类加载器--->转换成 java.lang.Class类的一个实例

只要是二进制字节流都可以不一定是.class，所以这就有了多种加载方式

• 从zip包中读取：war、ear、jar

• 从网络读取applet

• 由其他文件生成jsp

• 运行时计算生成，proxy具体的东西还没看...

然后加载了之后才有后面一系列的连接（Linking）、初始化、使用、卸载这些操作

而且正因为：加载的时候只要是二进制字节流都可以，所以为了安全起见需要做验证

<font color="red">注意一下，类加载不等于初始化</font>（举个例子，首次new一个类之后就会对这个类进行初始化clinit方法）

类加载阶段需要做的事情

• 通过一个类的全限定名来获取定义这个类的二进制字节流
• 把这个二进制字节流代表的数据结构转化成方法区的运行时数据结构
• 在内存中生成一个本类的Class类对象作为方法区这个类的各种数据的访问入口
• 加载和验证有可能是交替进行的

而加载的过程就是由类加载器来完成的。

类加载器

类加载器（ClassLoader），就是把类加载到JVM里用的。当JVM启动的时候，Java会按以下顺序自顶而下地启动三类加载器并加载相应的类，而且他们依次呈继承关系：

启动（Bootstrap）类加载器

启动类加载器是用本地代码实现的类加载器，用C++编写，是JVM自带的类装载器，负责Java负责Java平台核心库，用来装载核心类（比如Object类，String类等）。由于引导类加载器涉及到虚拟机本地实现细节，所以不允许直接通过引用进行操作，不可被直接访问。

扩展（Extension）类加载器

扩展类加载器是由Sun的由Sun的ExtClassLoader（sun.misc.Launcher$ExtClassLoader）实现的
负责将 <JAVA_HOME >/lib/ext或者由系统变量-Djava.ext.dir指定位置中的类库 加载到内存中。开发者可以直接使用标准扩展类加载器。

系统（System）类加载器

由 Sun 的 AppClassLoader（sun.misc.Launcher$AppClassLoader）实现的
将用户写的类加载到内存中。开发者可以直接使用系统类加载器。也叫应用加载器。

用代码验证继承关系：

        //获取系统类加载器
        ClassLoader classLoader = ClassLoader.getSystemClassLoader();
        System.out.println(classLoader);
        
        //获取系统类加载器的父类----扩展类加载器
        System.out.println(classLoader.getParent());
        
        //获取扩展类加载器的父类----引导类加载器
        System.out.println(classLoader.getParent().getParent());        

输出结果：

在这里插入图片描述

关于数组类

非数组类都是类加载器来加载的，你可以自己写一个类加载器来，也可用应用加载器来

但是数组类的话是由JVM直接创建的，深入理解JVM书上有个例子，这个类里面就包含了边界检查等等的方法......

类是怎么比较的

这里就说一句：不同的类加载器加载的类是没法比较的，必定返回false

我们来看下面这段代码：

package classLoading;

import java.io.IOException;
import java.io.InputStream;

public class ClassLoaderTest {

    public static void main(String[] args)
            throws ClassNotFoundException, InstantiationException, IllegalAccessException {
        // TODO Auto-generated method stub

        ClassLoader myLoader = new ClassLoader() {

            @Override
            public Class<?> loadClass(String name) throws ClassNotFoundException {

                try {

                    String fileName = name.substring(name.lastIndexOf('.') + 1) + ".class";

                    InputStream is = getClass().getResourceAsStream(fileName);

                    if (is == null) {
                        return super.loadClass(fileName);
                    }

                    byte[] b = new byte[is.available()];

                    is.read(b);

                    return defineClass(name, b, 0, b.length);

                } catch (IOException e) {
                    throw new ClassNotFoundException(name);
                }

            }

        };

        // 用myLoader加载自己然后获得实例？
        Object obj = myLoader.loadClass("classLoading.ClassLoaderTest").newInstance();

        System.out.println(obj.getClass());

        System.out.println(obj instanceof classLoading.ClassLoaderTest);

    }

}

这个程序干的事情其实就是：自己创建了一个加载器然后加载了自己，然后和通过系统加载器加载的自己比

由于一个在user classloader里，一个在app classloader里，所以是返回false的

这就涉及到了一个问题：如何避免相同的类因为加载器的原因在内存中被重复加载？？？

双亲委派模型

在这里插入图片描述

一句话概括：子类拿到了一个新的要被加载的字节流就交给父类，父类如果可以加载就加载了，不行的话返回null然后子类来加载，Ps：Bootstrap Classloader由于是顶层，不用遵循这个规则

这样的好处就是，比如你乱写了一个Java.lang.Object的话，他是不会被加载的，因为BootStrap ClassLoader已经加载了它了

ClassLoader类的方法

每个 Java 类的Class类都维护着一个指向定义它的类加载器的引用，通过 getClassLoader()方法就可以获取到此引用。

在这里插入图片描述

Class.forName()方法

除了defineClass以外在Class类中还有一个静态方法来加载类：Class.forName("xxx.xxx.xxx")

这就是使用当前类的类加载器来加载这个类

比如A用的是用户自定义W类加载器，然后在A里通过Class.forName加载B，那么B的类加载器就是W类加载器
这里看个例子：

    
    System.out.println(Person.class.getClassLoader());
        
    System.out.println(Class.forName("java.lang.Object").getClassLoader());

输出结果：

在这里插入图片描述

文章参考来源：https://www.ibm.com/developerworks/cn/java/j-lo-classloader/index.html