黑马程序员_java 类的加载机制

------- android培训、java培训、期待与您交流！ ----------

类加载器(ClassLoader):
    所谓类加载器就是加载类的工具。
作用：用于加载class文件，我们写的任何程序，首先要编写源代码，然后编译，把它编译成class文件，然后
      class文件会从硬盘加载到内存里面去执行，装载到内存就是由类加载器去完成的。
Java虚拟机与程序的生命周期：当程序执行的时候，就会启动一个JVM进程，进程里面包含一个主线程去执行程序。
    1：执行System.exit(int num);0表示正常结束，非0表示异常终止
    2：程序正常运行结束
    3：程序在执行过程中遇到了异常或错误而异常终止
    4：由于操作系统出现错误而导致JVM终止
类的加载、连接、初始化：
    一个类从硬盘上的class文件，一直到能被正常执行，在执行之前，它会经过加载、连接、初始化这三个
    过程。
    加载：查找并加载类的二进制数据。就是把一个class文件加载到内存里面，将其存放在运行时数据区
          的方法区，然后在堆内存中创建一个java.lang.Class对象，用来封装类在方法区的数据结构，
          所有的程序只有被加载到内存之后才能被正常执行。
        |--加载.class文件的方式：
            |--从本地系统中直接加载
            |--通过网络下载.class文件 URLClassLoader类
            |--从zip,jar等归档文件中加载.class文件
            |--从专有数据库中提取.class文件
            |--将java源文件动态编译为.class文件
          类加载的最终产品是位于堆区的Class对象，Class对象封装了类在方法区的数据结构，并且
          向java程序员提供了访问方法区内的数据结构的接口，这个接口是反射的接口，所以我们才
          可以通过反射获析它所描述的类的任何成员
           
    连接(3个步骤)：类被加载后，就进入连接阶段。连接就是将已经读入到内存的类的二进制数据合并到
        虚拟机的运行时环境中去。
        |--验证：确保被加载的类的正确性。比如说正常情况都是同过javac命令去生成class文件，
            但如果手动的生成class文件，如果不符合要求，就会出错！！！
            |--类文件的结构检查
            |--语言检查
            |--字节码验证
            |--二进制兼容性的验证
        |--准备：为类的静态变量(不是实例变量)分配内存，并将其初始化为默认值。
            |--为什么是静态变量？而不是实例变量？
               因为现在刚加载到内存，还没有生成对象，通常生成对象是通过new关键字，用
               new的方式的前提是这个类已经加载、连接、初始化完成了！这个时候才能为实
               例变量分配内存
        |--解析：把类中的符号引用，转换为直接引用。例如在Work类gotoWork()方法中，引用Car
            类的run()方法。
                public Class Work
                {
                    public void gotoWork()
                    {
                        Car c = new Car();
                        //下面代码在Work类的二进制数据中表示为符号引用
                        c.run();
                    }
                }
                Class Car
                {
                    public void run(){}
                }
            在Work的二进制数据中，包含了一个对Car类的run()方法的符号引用，它由run()
            方法的全名，和相关描述符组成。在解析阶段，JVM会把这个符号引用替换为指针，
            该指针指向Car类的run()方法在方法区内的内存位置，这个指针就是直接引用。
   
    初始化：为类的静态变量赋正确的初始值。在初始化阶段，JVM执行类的初始化语句，为类的静态变量
        赋值，在程序中，静态变量的初始化有两种途径：
            |--在静态变量的声明处进行初始化。
                public class C
                {
                    static int a = 3;//在声明处初始化
                }
            |--在静态代码块进行初始化。
                public class C
                {
                    static int a;
                    static
                    {
                        a = 3;//在静态代码块执行初始化
                    }
                }
        注意：这里还没有到实例变量生成！！！
        |--类的初始化时机：当Java程序通过主动使用的方式使用某个类时
            |--主动使用(6种)：
                |--创建类的实例
                |--访问某个类或接口的静态变量，或者对静态变量赋值
                    |--静态变量的声明语句，以及静态代码块都被看做类的初始化
                       语句，JVM会按照初始化语句在类中的先后顺序来一次执行！   
                |--调用类的静态方法
                |--反射(如：Class.forName("xxx"))
                |--初始化一个类的子类
                |--JVM启动时被标明为启动类的类(使用java命令启动一个类)
            只有当程序访问的静态变量，静态方法确实在当前类或接口中定义时，才可以认为
            是对类或接口的主动使用！！！
            代码体现：
                package com.itheima.classload;
                class Parent3
                {
                    static int a = 3;
                    static
                    {
                        System.out.println("父类的静态代码块执行了");
                    }
                    static void doSomething()
                    {
                        System.out.println("doSomething");
                    }
                }
                class Child3 extends Parent3
                {
                    static
                    {
                        System.out.println("子类的静态代码块执行了");
                    }
                }
                public class Test6
                {
                    public static void main(String[] args)
                    {
                        System.out.println(Child3.a);
                        Child3.doSomething();
                    }
                }
                运行结果：父类的静态代码块执行了
                      3
                      doSomething
                通过运行结果可以看出子类没有被初始化
            除以上6种之外，下面的几种情形需要特别指出：
                对于一个final修饰的静态常量，如果该Field值在编译时期就可以确定下来，
                那么即使程序使用该静态常量，也不会导致类的初始化！！！
                package com.itheima.classload;
                class FinalTest
                {
                    public static final int a = 3;
                    static
                    {
                        System.out.println("静态代码块执行了！！！");
                    }
                }
                public class Test2
                {
                    public static void main(String[] args) {
                        System.out.println(FinalTest.a);
                    }
                }
                运行结果：3
                反之，如果final修饰的静态常量的值不能在编译时期确定下来，则必须等到
                运行时才可以确定该Field值，通过类访问它时，就会导致类的初始化！！！
                package com.itheima.classload;
                class FinalTest3
                {
                    public static final int a = (int) (Math.random() * 100);
                    static
                    {
                        System.out.println("构造代码块执行了");
                    }
                }
                public class Test3
                {
                    public static void main(String[] args) {
                        System.out.println(FinalTest3.a);
                    }
                }
                运行结果：构造代码块执行了
                      37
                调用ClassLoader类的loadClass()方法加载一个类，该方法只是加载类，
                并不会执行到该类的初始化，所以不会导致类的初始化!!!但使用Class的
                forName()静态方法会导致类的初始化！！！
                package com.itheima.classload;
                class C
                {
                    static
                    {
                        System.out.println("Class");
                    }
                }
                public class ClassLoaderTest2
                {
                    public static void main(String[] args) throws Exception
                    {
                        //获得系统类加载器
                        ClassLoader cl = ClassLoader.getSystemClassLoader();
                        Class c = cl.loadClass("com.itheima.classload.C");
                        System.out.println("--------------------------");
                        c = Class.forName("com.itheima.classload.C");
                       
                    }
                }
                运行结果：--------------------------
                      Class
                通过结果可以看出，通过loadClass()方法不会导致类的初始化
            |--被动使用：
                除了以上6种情况，其它使用java类的方式，被称为被动使用，不会导致
                类的初始化！！！
            |--当JVM初始化一个类时，要求它的所有父类都已经初始化，但是这条规则并不
               适用于接口
                |--当初始化一个类时，并不会先初始化它所实现的接口
                |--当初始化一个接口时，并不会先初始化它的父接口
               因此，一个父接口并不会因为它的子接口或实现类的初始化而初始化。只有当
               程序首次适用特定接口的静态变量时，才会导致该接口的初始化
        |--类的初始化步骤：
            |--如果这个类还有没有被加载和连接，那么就先进行加载和连接
            |--如果类存在直接的父类，并且这个父类还没有被初始化，那就先初始化直接的父类。
               但是对父类的直接使用不会导致子类被初始化！！！
               代码体现一：
                package com.itheima.classload;
                class Parent
                {
                    static int a = 3;
                    static
                    {
                        System.out.println("父类静态代码块");
                    }
                }
                class Child extends Parent
                {
                    static int b = 4;
                    static
                    {
                        System.out.println("子类静态代码块");
                    }
                }
                public class Test4
                {
                    static
                    {
                        System.out.println("测试类的静态代码块");
                    }
                    public static void main(String[] args)
                    {
                        System.out.println(Child.b);
                    }
                }
                运行结果：
                    测试类的静态代码块
                    父类静态代码块
                    子类静态代码块
                    4
            代码体现二：
                package com.itheima.classload;
                    class Parent1
                    {
                        static int a = 3;
                        static
                        {
                            System.out.println("父类的静态代码块执行了");
                        }
                    }
                    class Child1 extends Parent1
                    {
                        static int b = 4;
                        static
                        {
                            System.out.println("子类的静态代码块执行了");
                        }
                    }
                    public class Test5
                    {
                        static
                        {
                            System.out.println("测试类的静态代码块执行了");
                        }
                        public static void main(String[] args)
                        {
                            Parent1 p1;//这里只是创建了一个引用，所以没有导致初始化
                            System.out.println("---------------------------------");
                            p1 = new Parent1();
                            System.out.println(p1.a);
                            System.out.println(Child1.b);
                        }
                    }
                    运行结果：测试类的静态代码块执行了
                          ---------------------------------
                          父类的静态代码块执行了
                          3
                          子类的静态代码块执行了
                          4
            |--如果类中存在初始化语句，那就从上往下依次执行这些初始化语句
        所有的Java虚拟机实现在每个类或接口被Java程序首次"主动使用"时，才初始化。
有两种类加载器：
    |--Java虚拟机自带的类加载器
        以前没有写过类加载器，代码都能执行，说明JVM有默认的类加载器，其中扩展类加载器和
        系统类加载器是java代码完成的，而根类加载器是c++写的，所以我们无法在Java代码中获
        得该类
        |--根类加载器(Bootstrap)：
            该加载器没有父加载器，它负责加载JVM的核心类库。如java.lang.*等。根类加载
            器从系统属性sun.boot.class.path所指定的目录加载类库。根类加载器的实现依赖
            于底层操作系统，属于JVM实现的一部分，它并没有继承java.lang.ClassLoader类
        |--扩展类加载器(Extension):
            它的父加载器是根类加载器，它从java.ext.dirs系统属性所指定的目录中加载类库，
            或者从JDK的安装目录：jar\lib\ext子目录(扩展目录)下加载类库，如果把用户创建
            的jar文件放在这个目录下，也会自动由扩展类加载器加载。扩展类加载器是纯java
            类，是java.lang.ClassLoader的子类。
        |--系统(应用)类加载器(AppClassLoader):
            系统类加载器也被称为"应用类加载器"，它的父加载器是扩展类加载器，它从环境
            变量classpath或者系统属性java.class.path所指定的目录中加载类，它是用户自
            定义的类加载器的默认父加载器，系统加载器也是纯java类，
            是java.lang.ClassLoader的子类
        注意：父子加载器的关系并非继承

    |--自定义类加载器
        |--Java.lang.ClassLoader的子类
        |--用户可以定制类的加载方式，继承ClassLoader类
    类加载器并不需要等到某个类被首次"主动使用"才加载，JVM规范允许类加载器在预料某个类，将要被
    使用时，预先加载它，如果在预先加载的过程中，遇到了.class文件缺失或存在错误，类加载器必须
    在程序首次主动使用该类时才报告错误(LinkageError)。如果这个类一直没有被程序主动使用，那么
    类加载器就不会报告错误。
父类委托加载机制：
    类加载器用来把类加载到JVM内存中，从JDK1.2版本开始，类加载过程采用父类委托机制，这种机制
    能更好的保障Java平台的安全。在此委托机制当中，各个加载器按照父子关系形成树形结构，除了
    JVM自带的根类加载器以外，其余的类加载器都有且只有一个父加载器。
    比如：当Java程序请求loader1加载器加载Person类时，loader1首先委托自己的父类加载器去加载
          Person类，如果父类能加载，则由父类加载器完成加载任务，否则才由loader1加载器加载该类
    如果某一个类加载器能够成功加载该类，那么这个加载器就被称为定义类加载器；定义类加载器及其
    所有子加载器都被称为初始类加载器。
ClassLoader的构造方法：
    protected  ClassLoader()
        使用方法 getSystemClassLoader() 返回的ClassLoader创建一个新的类加载器，将系统类
        加载器作为父类加载器。因为getSystemClassLoader()方法返回的是系统类加载器。
    protected  ClassLoader(ClassLoader parent)
        使用指定的、用于委托操作的父类加载器创建新的类加载器。
ClassLoader的常用方法：
    static ClassLoader getSystemClassLoader() 返回委托的系统类加载器。
    public Class<?> loadClass(String name) throws ClassNotFoundException
        使用指定的二进制名称来加载类。此方法使用与 loadClass(String, boolean)方法相同的
        方式搜索类。Java 虚拟机调用它来分析类引用。调用此方法
        等效于调用 loadClass(name, false)。
        返回：得到的 Class 对象
    protected Class<?> loadClass(String name,boolean resolve) throws ClassNotFoundException
        使用指定的二进制名称来加载类。此方法的默认实现将按以下顺序搜索类：
            1：调用 findLoadedClass(String) 来检查是否已经加载类。
            2：在父类加载器上调用 loadClass 方法。如果父类加载器为 null，则使用虚拟机
               的内置类加载器。
            3：调用 findClass(String) 方法查找类。
        如果使用上述步骤找到类，并且 resolve 标志为真，则此方法将在得到的Class对象上调用
        resolveClass(Class) 方法。
        鼓励用 ClassLoader 的子类重写 findClass(String)，而不是使用此方法。
        返回：得到的 Class 对象
    protected Class<?> findClass(String name) throws ClassNotFoundException
        使用指定的二进制名称查找类。此方法应该被类加载器的实现重写，该实现按照委托模型来
        加载类。在通过父类加载器检查所请求的类后，此方法将被 loadClass 方法调用。默认实现
        抛出一个 ClassNotFoundException。
        返回：得到的 Class 对象


命名空间：
    每个类加载器都有自己的命名空间，命名空间由该加载器及所有父加载器所加载的类组成。
    在同一个空间中，不会出现类的完整名字(包括包名、类名)相同的两个类；
    在不用的空间中，有可能出现类的完整名字(包括包名、类名)相同的两个类。
    比如：有两个类加载器A和B，他们不是父子关系，A已经把Person类加载到内存，B这个时候也
          可以将Person类加载到内存
运行时包：
    由同一个加载器加载的属于相同包的类组成了运行时包。决定两个类是不是属于同一个运行时包，
    不仅要看它们的包名是否相同，还要看定义类加载器是否相同，只有属于同一运行时包的类才能
    互相访问包可见(即默认访问级别)的类和类成员。这样的限制可以避免用户自定义的类冒充核心
    类库中的类，去访问核心类库的包可见成员。
自定义的类加载器：
    只需继承java.lang.ClassLoader类，然后复写它的findClass(String name)方法即可。   
    部分代码演示：
        package com.itheima.classloader;

        import java.io.BufferedInputStream;
        import java.io.ByteArrayOutputStream;
        import java.io.FileInputStream;
        import java.io.FileNotFoundException;
        import java.io.IOException;
        import java.io.InputStream;

        public class MyClassLoader1 extends ClassLoader
        {
            //类加载器的名字
            private String name;
            //从指定目录下加载
            private String path;
            //指定加载类的文件格式
            private final String fileType = ".class";
            public String getPath() {
                return path;
            }
            public void setPath(String path)
            {
                this.path = path;
            }
            public MyClassLoader1(String name)
            {
                super();
                //加载器的名字
                this.name = name;
            }
            public MyClassLoader1(ClassLoader Parent, String name)
            {
                //显示指定该加载器的父加载器
                super(Parent);
                //该加载器的名字
                this.name = name;
            }
            @Override
            public String toString()
            {
                return this.name;
            }
            private byte[] loadClassData(String name)
            {
                InputStream is = null;
                byte[] bys = new byte[1024];
                ByteArrayOutputStream baos = null;
                name = name.replace(".", "\\");
                try {
                    is = new BufferedInputStream(new FileInputStream(path + name + fileType));
                    baos = new ByteArrayOutputStream();
                    int len = 0;
                    while((len = is.read(bys)) != -1)
                    {
                        baos.write(bys, 0, len);
                    }

                } catch (Exception e) {
                    e.printStackTrace();
                }finally
                {
                    try {
                        baos.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                    try {
                        is.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
                return baos.toByteArray();
            }
            @Override
            public Class<?> findClass(String name)
            {
                byte[] bys = loadClassData(name);
                return defineClass(name, bys, 0, bys.length);
            }
        }

------- android培训、java培训、期待与您交流！ ----------