[Android]【安卓】【Java】类加载机制和对象加载机制

[Android]【安卓】【Java】类加载机制和对象加载机制

本篇博客已收录到我的安卓开发小结中——点击【安卓开发小结】

---

ME：

一、类的加载机制

类从加载到内存到从内存中卸载，它的生命周期包括7个阶段：
加载–>验证–>准备->解析->初始化–>使用–>卸载
其中 验证–>准备->解析 三个阶段合称 连接 阶段，如下图：

加载、验证、准备、初始化、卸载，这5个阶段的先后顺序是确定的，但解析阶段不一定，它某些情况下可以在初始化之后执行，这是为了支持Java的动态绑定。

加载

加载阶段主要做3件事情：
1、通过一个类的全限定名来获取定义此类的二进制字节流。
2、将这个字节流所代表的静态存储结构转化为方法区的运行时数据结构。
3、在内存中生成一个代表这个这个类的java.lang.Class对象，作为方法区这个类的各种数据的访问入口。
注意：加载阶段未完成时，连接阶段可能已经开始（如一部分字节码文件格式验证），后续这个两个阶段交叉进行，但加载阶段会在连接阶段结束前结束。

验证

验证是连接阶段的第一步，目的是确保Class文件的字节流中包含的信息符合当前虚拟机的要求，并且不会危害当前虚拟机的安全。
它主要完成以下4个动作：
1、文件格式验证。
2、元数据验证。
3、字节码验证。
4、符号引用验证。
注：验证阶段很重要，但不是必须的，它对程序运行期间没有影响，如果引用的类经过反复验证，可以通过-Xverifynone参数来关闭大部分验证措施，以缩短虚拟机类加载时间。

准备

准备阶段是正式为类变量分配内存和设置类变量初始值（各类型的0值）的阶段，内存分配在方法区。实例变量的内存分配在对象初始化时执行，内存分配在堆中。
注：

public static int value=123;

准备阶段过后，value的值为0，而不是123，这是因为准备阶段，还不会执行任何java方法。
但

public static final int value=123

使用了static和final关键字，将出现宏替换效果，准备阶段过后，value的值为123。

解析

解析阶段是虚拟机将常量池里的符号引用替换为直接引用的过程。
主要针对7类符号引用进行：

• 类或接口
• 字段
• 类方法
• 接口方法
• 方法类型
• 方法句柄
• 调用点限定符

初始化

初始化阶段是类加载的最后一步，到这里，才开始执行类中定义的java代码。
初始化阶段是执行类构造器< clinit>的过程，< clinit>方法是由编译器收集的所有的类变量赋值动作和静态语句块static{}组成，收集顺序和语句定义顺序一致。
注：静态语句块可以访问定义在它之前的静态变量，但在它之后的静态变量，可以赋值，但不能访问。如下：

public class Test
{
    static
    {
        i=0;
        System.out.println(i);//这句编译器会报错：Cannot reference a field before it is defined（非法向前应用）
    }
    static int i=1;
}

做如下修改，程序输出1：

public class Test
{
    static
    {
        i=0;
//      System.out.println(i);
    }
    static int i=1;

    public static void main(String args[])
    {
        System.out.println(i);
    }
}

父类构造器< clinit>先执行，即父类的静态成员先于子类执行。
类构造器< clinit>和实例构造器< init>方法不同，它不会显示调用父类的构造器，且如果类中没有静态语句块或静态成员赋值动作，编译器可以不为这个类生产< clinit>构造器。

接口不能定义静态语句块，但有变量赋值操作，所以会生成< clinit>构造器。
但接口的< clinit>构造器不会强制规定要调用父接口的< clinit>构造器，除非父接口定义的变量被使用时，父接口的< clinit>构造器才会被调用，从而初始化。另，接口的实现类在初始化时，一样不会执行接口的< clinit>构造器。

虚拟机会保证一个类的< clinit>()方法在多线程环境中被正确的加锁、同步，如果多个线程同时去初始化一个类，那么只会有一个线程去执行这个类的< clinit>()方法，其他线程都需要阻塞等待，直到活动线程执行< clinit>()方法完毕。
如果在一个类的< clinit>()方法中有耗时很长的操作，就可能造成多个线程阻塞，在实际应用中这种阻塞往往是隐藏的。

jdk1.7规定有且只有5种情况，会对类进行初始化（当然加载、验证、准备、解析会先执行）：
1、 遇到new,getstatic,putstatic,invokestatic这失调字节码指令时，如果类没有进行过初始化，则需要先触发其初始化。生成这4条指令的最常见的Java代码场景是：

• 使用new关键字实例化对象
• 读取或设置一个类的静态字段（被final修饰、已在编译器把结果放入常量池的静态字段除外）
• 调用一个类的静态方法

2、使用java.lang.reflect包的方法对类进行反射调用的时候，如果类没有进行过初始化，则需要先触发其初始化。
3、当初始化一个类的时候，如果发现其父类还没有进行过初始化，则需要先触发其父类的初始化。
4、当虚拟机启动时，用户需要指定一个要执行的主类（包含main()方法的那个类），虚拟机会先初始化这个主类。
5、当使用jdk1.7 动态语言支持时，如果一个java.lang.invoke.MethodHandle实例最后的解析结果REF_getstatic,REF_putstatic,REF_invokeStatic的方法句柄，并且这个方法句柄所对应的类没有进行初始化，则需要先出触发其初始化。

二、对象加载机制

1、JVM会先到方法区查找是否有目标类的.Class对象，有就直接使用，没有，执行上述的类加载过程。
2、把.Class中的所有非静态变量及非静态代码，加载到方法区下的非静态区域内。
3、在堆内存中开辟一块空间。
4、给开辟的控件分配一个地址。
5、把对象所有的非静态成员加载到所开辟的空间下。
6、对所有非静态成员进行默认初始化。
7、构造函数入栈，调用构造函数（先执行隐式3步，再执行程序猿代码）。

① 执行super()语句
② 显示初始化（非静态成员）
③ 执行构造代码块

8、构造函数出栈，把分配的空间地址赋给引用对象。

注：构造函数第一行
① 第一行是this()语句，不执行隐式3步，直到调用的构造方法第一行不是this()方法，执行隐式3步。
② 第一行是super()语句，调用父类的构造方法。
③ 第一行不是this() 也不是super()，执行隐式3步。

---

OTHERS：

参考资料一：Java虚拟机类加载机制

Java虚拟机类加载机制

看到这个题目，很多人会觉得我写我的java代码，至于类，JVM爱怎么加载就怎么加载，博主有很长一段时间也是这么认为的。随着编程经验的日积月累，越来越感觉到了解虚拟机相关要领的重要性。闲话不多说，老规矩，先来一段代码吊吊胃口

public class SSClass
{
    static
    {
        System.out.println("SSClass");
    }
}    
public class SuperClass extends SSClass
{
    static
    {
        System.out.println("SuperClass init!");
    }

    public static int value = 123;

    public SuperClass()
    {
        System.out.println("init SuperClass");
    }
}
public class SubClass extends SuperClass
{
    static 
    {
        System.out.println("SubClass init");
    }

    static int a;

    public SubClass()
    {
        System.out.println("init SubClass");
    }
}
public class NotInitialization
{
    public static void main(String[] args)
    {
        System.out.println(SubClass.value);
    }
}

运行结果：

SSClass
SuperClass init!
123

答案答对了嚒？
也许有人会疑问：为什么没有输出SubClass init。ok~解释一下：对于静态字段，只有直接定义这个字段的类才会被初始化，因此通过其子类来引用父类中定义的静态字段，只会触发父类的初始化而不会触发子类的初始化。
上面就牵涉到了虚拟机类加载机制。如果有兴趣，可以继续看下去。

类加载过程

类从被加载到虚拟机内存中开始，到卸载出内存为止，它的整个生命周期包括：加载（Loading）、验证（Verification）、准备(Preparation)、解析(Resolution)、初始化(Initialization)、使用(Using)和卸载(Unloading)7个阶段。其中准备、验证、解析3个部分统称为连接（Linking）。如图所示。

加载、验证、准备、初始化和卸载这5个阶段的顺序是确定的，类的加载过程必须按照这种顺序按部就班地开始，而解析阶段则不一定：它在某些情况下可以在初始化阶段之后再开始，这是为了支持Java语言的运行时绑定（也称为动态绑定或晚期绑定）。以下陈述的内容都已HotSpot为基准。

加载

在加载阶段（可以参考java.lang.ClassLoader的loadClass()方法），虚拟机需要完成以下3件事情：

1. 通过一个类的全限定名来获取定义此类的二进制字节流（并没有指明要从一个Class文件中获取，可以从其他渠道，譬如：网络、动态生成、数据库等）；
2. 将这个字节流所代表的静态存储结构转化为方法区的运行时数据结构；
3. 在内存中生成一个代表这个类的java.lang.Class对象，作为方法区这个类的各种数据的访问入口；

加载阶段和连接阶段（Linking）的部分内容（如一部分字节码文件格式验证动作）是交叉进行的，加载阶段尚未完成，连接阶段可能已经开始，但这些夹在加载阶段之中进行的动作，仍然属于连接阶段的内容，这两个阶段的开始时间仍然保持着固定的先后顺序。

验证

验证是连接阶段的第一步，这一阶段的目的是为了确保Class文件的字节流中包含的信息符合当前虚拟机的要求，并且不会危害虚拟机自身的安全。
验证阶段大致会完成4个阶段的检验动作：

1. 文件格式验证：验证字节流是否符合Class文件格式的规范；例如：是否以魔术0xCAFEBABE开头、主次版本号是否在当前虚拟机的处理范围之内、常量池中的常量是否有不被支持的类型。
2. 元数据验证：对字节码描述的信息进行语义分析（注意：对比javac编译阶段的语义分析），以保证其描述的信息符合Java语言规范的要求；例如：这个类是否有父类，除了java.lang.Object之外。
3. 字节码验证：通过数据流和控制流分析，确定程序语义是合法的、符合逻辑的。
4. 符号引用验证：确保解析动作能正确执行。

验证阶段是非常重要的，但不是必须的，它对程序运行期没有影响，如果所引用的类经过反复验证，那么可以考虑采用-Xverifynone参数来关闭大部分的类验证措施，以缩短虚拟机类加载的时间。

准备

准备阶段是正式为类变量分配内存并设置类变量初始值的阶段，这些变量所使用的内存都将在方法区中进行分配。这时候进行内存分配的仅包括类变量（被static修饰的变量），而不包括实例变量，实例变量将会在对象实例化时随着对象一起分配在堆中。其次，这里所说的初始值“通常情况”下是数据类型的零值，假设一个类变量的定义为：

   public static int value=123;

那变量value在准备阶段过后的初始值为0而不是123.因为这时候尚未开始执行任何java方法，而把value赋值为123的putstatic指令是程序被编译后，存放于类构造器()方法之中，所以把value赋值为123的动作将在初始化阶段才会执行。
至于“特殊情况”是指：public static final int value=123，即当类字段的字段属性是ConstantValue时，会在准备阶段初始化为指定的值，所以标注为final之后，value的值在准备阶段初始化为123而非0.

解析

解析阶段是虚拟机将常量池内的符号引用替换为直接引用的过程。解析动作主要针对类或接口、字段、类方法、接口方法、方法类型、方法句柄和调用点限定符7类符号引用进行。

初始化

类初始化阶段是类加载过程的最后一步，到了初始化阶段，才真正开始执行类中定义的java程序代码。在准备阶段，变量已经赋过一次系统要求的初始值，而在初始化阶段，则根据程序猿通过程序制定的主观计划去初始化类变量和其他资源，或者说：初始化阶段是执行类构造器< clinit>()方法的过程.
< clinit>()方法是由编译器自动收集类中的所有类变量的赋值动作和静态语句块static{}中的语句合并产生的，编译器收集的顺序是由语句在源文件中出现的顺序所决定的，静态语句块只能访问到定义在静态语句块之前的变量，定义在它之后的变量，在前面的静态语句块可以赋值，但是不能访问。如下

public class Test
{
    static
    {
        i=0;
        System.out.println(i);//这句编译器会报错：Cannot reference a field before it is defined（非法向前应用）
    }
    static int i=1;
}

那么去掉报错的那句，改成下面：

public class Test
{
    static
    {
        i=0;
//      System.out.println(i);
    }
    static int i=1;

    public static void main(String args[])
    {
        System.out.println(i);
    }
}

输出结果是什么呢？当然是1啦~在准备阶段我们知道i=0，然后类初始化阶段按照顺序执行，首先执行static块中的i=0,接着执行static赋值操作i=1,最后在main方法中获取i的值为1。

< clinit>()方法与实例构造器< init>()方法不同，它不需要显示地调用父类构造器，虚拟机会保证在子类< cinit>()方法执行之前，父类的< clinit>()方法已经执行完毕，回到本文开篇的举例代码中，结果会打印输出：SSClass就是这个道理。

由于父类的< clinit>()方法先执行，也就意味着父类中定义的静态语句块要优先于子类的变量赋值操作。
< clinit>()方法对于类或者接口来说并不是必需的，如果一个类中没有静态语句块，也没有对变量的赋值操作，那么编译器可以不为这个类生产< clinit>()方法。

接口中不能使用静态语句块，但仍然有变量初始化的赋值操作，因此接口与类一样都会生成< clinit>()方法。但接口与类不同的是，执行接口的< clinit>()方法不需要先执行父接口的< clinit>()方法。只有当父接口中定义的变量使用时，父接口才会初始化。另外，接口的实现类在初始化时也一样不会执行接口的< clinit>()方法。
虚拟机会保证一个类的< clinit>()方法在多线程环境中被正确的加锁、同步，如果多个线程同时去初始化一个类，那么只会有一个线程去执行这个类的< clinit>()方法，其他线程都需要阻塞等待，直到活动线程执行< clinit>()方法完毕。如果在一个类的< clinit>()方法中有耗时很长的操作，就可能造成多个线程阻塞，在实际应用中这种阻塞往往是隐藏的。

package jvm.classload;

public class DealLoopTest
{
    static class DeadLoopClass
    {
        static
        {
            if(true)
            {
                System.out.println(Thread.currentThread()+"init DeadLoopClass");
                while(true)
                {
                }
            }
        }
    }

    public static void main(String[] args)
    {
        Runnable script = new Runnable(){
            public void run()
            {
                System.out.println(Thread.currentThread()+" start");
                DeadLoopClass dlc = new DeadLoopClass();
                System.out.println(Thread.currentThread()+" run over");
            }
        };

        Thread thread1 = new Thread(script);
        Thread thread2 = new Thread(script);
        thread1.start();
        thread2.start();
    }
}

运行结果：（即一条线程在死循环以模拟长时间操作，另一条线程在阻塞等待）

Thread[Thread-0,5,main] start
Thread[Thread-1,5,main] start
Thread[Thread-0,5,main]init DeadLoopClass

需要注意的是，其他线程虽然会被阻塞，但如果执行< clinit>()方法的那条线程退出< clinit>()方法后，其他线程唤醒之后不会再次进入< clinit>()方法。同一个类加载器下，一个类型只会初始化一次。
将上面代码中的静态块替换如下：

        static
        {
            System.out.println(Thread.currentThread() + "init DeadLoopClass");
            try
            {
                TimeUnit.SECONDS.sleep(10);
            }
            catch (InterruptedException e)
            {
                e.printStackTrace();
            }
        }

运行结果：

Thread[Thread-0,5,main] start
Thread[Thread-1,5,main] start
Thread[Thread-1,5,main]init DeadLoopClass (之后sleep 10s)
Thread[Thread-1,5,main] run over
Thread[Thread-0,5,main] run over

虚拟机规范严格规定了有且只有5中情况（jdk1.7）必须对类进行“初始化”（而加载、验证、准备自然需要在此之前开始）：

1. 遇到new,getstatic,putstatic,invokestatic这失调字节码指令时，如果类没有进行过初始化，则需要先触发其初始化。生成这4条指令的最常见的Java代码场景是：使用new关键字实例化对象的时候、读取或设置一个类的静态字段（被final修饰、已在编译器把结果放入常量池的静态字段除外）的时候，以及调用一个类的静态方法的时候。
2. 使用java.lang.reflect包的方法对类进行反射调用的时候，如果类没有进行过初始化，则需要先触发其初始化。
3. 当初始化一个类的时候，如果发现其父类还没有进行过初始化，则需要先触发其父类的初始化。
4. 当虚拟机启动时，用户需要指定一个要执行的主类（包含main()方法的那个类），虚拟机会先初始化这个主类。
5. 当使用jdk1.7动态语言支持时，如果一个java.lang.invoke.MethodHandle实例最后的解析结果REF_getstatic,REF_putstatic,REF_invokeStatic的方法句柄，并且这个方法句柄所对应的类没有进行初始化，则需要先出触发其初始化。

开篇已经举了一个范例：通过子类引用付了的静态字段，不会导致子类初始化。
这里再举两个例子。
1. 通过数组定义来引用类，不会触发此类的初始化：（SuperClass类已在本文开篇定义）

public class NotInitialization
{
    public static void main(String[] args)
    {
        SuperClass[] sca = new SuperClass[10];
    }
}

运行结果：（无）
2. 常量在编译阶段会存入调用类的常量池中，本质上并没有直接引用到定义常量的类，因此不会触发定义常量的类的初始化：

public class ConstClass
{
    static
    {
        System.out.println("ConstClass init!");
    }
    public static  final String HELLOWORLD = "hello world";
}
public class NotInitialization
{
    public static void main(String[] args)
    {
        System.out.println(ConstClass.HELLOWORLD);
    }
}

运行结果：hello world

附：昨天从论坛上看到一个例子，很有意思，如下：

package jvm.classload;

public class StaticTest
{
    public static void main(String[] args)
    {
        staticFunction();
    }

    static StaticTest st = new StaticTest();

    static
    {
        System.out.println("1");
    }

    {
        System.out.println("2");
    }

    StaticTest()
    {
        System.out.println("3");
        System.out.println("a="+a+",b="+b);
    }

    public static void staticFunction(){
        System.out.println("4");
    }

    int a=110;
    static int b =112;
}

问题是：请问这段程序的输出是什么？
这个是我在论坛上看到的一个问题，我觉得比较经典。
一般对于这类问题，小伙伴们脑海中肯定浮现出这样的knowledge:

Java中赋值顺序：
1. 父类的静态变量赋值
2. 自身的静态变量赋值
3. 父类成员变量赋值和父类块赋值
4. 父类构造函数赋值
5. 自身成员变量赋值和自身块赋值
6. 自身构造函数赋值

ok,按照这个理论输出是什么呢？答案输出:1 4，这样正确嚒？肯定不正确啦，这里不是说上面的规则不正确，而是说不能简单的套用这个规则。
正确的答案是：

2
3
a=110,b=0
1
4

　　是不是有点不可思议？且听我一一道来，这里主要的点之一：实例初始化不一定要在类初始化结束之后才开始初始化。
  类的生命周期是：加载->验证->准备->解析->初始化->使用->卸载，只有在准备阶段和初始化阶段才会涉及类变量的初始化和赋值，因此只针对这两个阶段进行分析；
  类的准备阶段需要做是为类变量分配内存并设置默认值，因此类变量st为null、b为0；（需要注意的是如果类变量是final，编译时javac将会为value生成ConstantValue属性，在准备阶段虚拟机就会根据ConstantValue的设置将变量设置为指定的值，如果这里这么定义：static final int b=112,那么在准备阶段b的值就是112，而不再是0了。）
  类的初始化阶段需要做是执行类构造器（类构造器是编译器收集所有静态语句块和类变量的赋值语句按语句在源码中的顺序合并生成类构造器，对象的构造方法是()，类的构造方法是()，可以在堆栈信息中看到），因此先执行第一条静态变量的赋值语句即st = new StaticTest ()，此时会进行对象的初始化，对象的初始化是先初始化成员变量再执行构造方法，因此设置a为110->打印2->执行构造方法(打印3,此时a已经赋值为110，但是b只是设置了默认值0，并未完成赋值动作)，等对象的初始化完成后继续执行之前的类构造器的语句，接下来就不详细说了，按照语句在源码中的顺序执行即可。
  这里面还牵涉到一个冷知识，就是在嵌套初始化时有一个特别的逻辑。特别是内嵌的这个变量恰好是个静态成员，而且是本类的实例。
  这会导致一个有趣的现象：“实例初始化竟然出现在静态初始化之前”。
  其实并没有提前，你要知道java记录初始化与否的时机。
  看一个简化的代码，把关键问题解释清楚：

public class Test {
    public static void main(String[] args) {
        func();
    }
    static Test st = new Test();
    static void func(){}
}

根据上面的代码，有以下步骤：

1. 首先在执行此段代码时，首先由main方法的调用触发静态初始化。
2. 在初始化Test 类的静态部分时，遇到st这个成员。
3. 但凑巧这个变量引用的是本类的实例。
4. 那么问题来了，此时静态初始化过程还没完成就要初始化实例部分了。是这样么？
5. 从人的角度是的。但从java的角度，一旦开始初始化静态部分，无论是否完成，后续都不会再重新触发静态初始化流程了。
6. 因此在实例化st变量时，实际上是把实例初始化嵌入到了静态初始化流程中，并且在楼主的问题中，嵌入到了静态初始化的起始位置。这就导致了实例初始化完全至于静态初始化之前。这也是导致a有值b没值的原因。
7. 最后再考虑到文本顺序，结果就显而易见了。

---

参考资料二：【Java基础】Java类的加载和对象创建流程的详细分析

【Java基础】Java类的加载和对象创建流程的详细分析

相信我们在面试Java的时候总会有一些公司要做笔试题目的，而Java类的加载和对象创建流程的知识点也是常见的题目之一。接下来通过实例详细的分析一下。

实例问题

实例代码
Parent类

 1 package mytest.javaBase;
 2 
 3 public class Parent {
 4     int a = 10;
 5     static int b = 11;
 6     // 静态代码块
 7     static {
 8         System.out.println("Parent静态代码块：b=" + b);
 9         b++;
10     }
11     // 代码块
12     {
13         System.out.println("Parent代码块： a=" + a);
14         System.out.println("Parent代码块： b=" + b);
15         b++;
16         a++;
17     }
18 
19     // 无参构造函数
20     Parent() {
21         System.out.println("Parent无参构造函数： a=" + a);
22         System.out.println("Parent无参构造函数： b=" + b);
23     }
24 
25     // 有参构造函数
26     Parent(int a) {
27         System.out.println("Parent有参构造函数： a=" + a);
28         System.out.println("Parent有参构造函数： b=" + b);
29     }
30 
31     // 方法
32     void function() {
33         System.out.println("Parent function run ……");
34     }
35 
36 }

Child类

 1 package mytest.javaBase;
 2 
 3 public class Child extends Parent {
 4     int x = 10;
 5     static int y = 11;
 6     // 静态代码块
 7     static {
 8         System.out.println("Child静态代码块：y=" + y);
 9         y++;
10     }
11     // 代码块
12     {
13         System.out.println("Child代码块： x=" + x);
14         System.out.println("Child代码块： y=" + y);
15         y++;
16         x++;
17     }
18 
19     // 构造函数
20     Child() {
21         System.out.println("Child构造函数： x=" + x);
22         System.out.println("Child构造函数： y=" + y);
23     }
24 
25     // 方法
26     void function() {
27         System.out.println("Child function run ……");
28     }
29 
30 }

Test测试类

 1 package mytest.javaBase;
 2 
 3 public class Test {
 4     public static void main(String[] args) {
 5         Child demo = new Child();
 6         demo.function();
 7         System.out.println("…………………………………………………………………………………………………………………………");
 8         Child child = new Child();
 9         child.function();
10     }
11 }

我们可以先不看运行结果，自己思考下，运行结果会是什么，之后再比较下和自己思考的结果是否一样。
运行结果

Parent静态代码块：b=11
Child静态代码块：y=11
Parent代码块： a=10
Parent代码块： b=12
Parent无参构造函数： a=11
Parent无参构造函数： b=13
Child代码块： x=10
Child代码块： y=12
Child构造函数： x=11
Child构造函数： y=13
Child function run ……
…………………………………………………………………………………………………………………………
Parent代码块： a=10
Parent代码块： b=13
Parent无参构造函数： a=11
Parent无参构造函数： b=14
Child代码块： x=10
Child代码块： y=13
Child构造函数： x=11
Child构造函数： y=14
Child function run ……　

结果详细分析
我们运行Test类的main方法
1、 启动JVM，开始分配内存空间；
2、 开始加载Test.class文件，加载到方法区中，在加载的过程中静态的内容要进入静态区中；
3、 在开始运行main方法，这时JVM就会把main调用到栈中运行，开始从方法的第一行往下运行；
4、 在main方法中new Child()；这时JVM就会在方法区中查找有没有Child文件，如果没有就加载Child.class文件，并且Child继承Parent类，所以也要查找有没有Parent类，如果没有也要加载Parent.class文件。
5、 Child.class和Parent.class中的所有的非静态内容会加载到非静态的区域中，而静态的内容会加载到静态区中。静态内容（静态变量，静态代码块，静态方法）按照书写顺序加载。
说明：类的加载只会执行一次。下次再创建对象时，可以直接在方法区中获取class信息。
6、 开始给静态区中的所有静态的成员变量开始默认初始化。默认初始化完成之后，开始给所有的静态成员变量显示初始化。
7、 所有静态成员变量显示初始化完成之后，开始执行静态的代码块。先执行父类的静态代码块，再执行子类的静态代码块。

//这时输出
Parent静态代码块：b=11
Child静态代码块：y=11

说明：>>静态代码块是在类加载的时候执行的，类的加载只会执行一次所以静态代码块也只会执行一次；
>>非静态代码块和构造函数中的代码是在对象创建的时候执行的，因此对象创建(new)一次，它们就会执行一次。
8、 这时Parent.class文件 和 Child.class文件加载完成。
9、 开始在堆中创建Child对象。给Child对象分配内存空间，其实就是分配内存地址。
10、开始对类中的的非静态的成员变量开始默认初始化。
11、开始加载对应的构造方法，执行隐式三步

①有个隐式的super(); 

②显示初始化(给所有的非静态的成员变量)

③执行构造代码块

之后才开始执行本类的构造方法中的代码

super()是调用父类的构造函数，此处即为Parent的构造函数，在Parent的构造函数中也有个隐式三步：首先super()，再执行Parent的显示初始化，然后执行Parent的非静态构造代码块，最后执行Parent的构造函数中的代码。

//这时输出
Parent代码块： a=10
Parent代码块： b=12
Parent无参构造函数： a=11
Parent无参构造函数： b=13　

说明：虽然Parent没有明写extends，但是我们知道在Java中有个超类Object，它是所有类的父类，因此此处Parent类的super()是调用Object的构造函数
Parent的执行完之后，回来继续执行Child自己的隐式三步中的第二步：显示初始化，然后执行Child的非静态代码块的，最后执行Child的构造函数中的代码

//这时输出
Child代码块： x=10
Child代码块： y=12
Child构造函数： x=11
Child构造函数： y=13

12、对象创建完成，把内存的地址赋值给demo使用。
13、执行demo.function()方法。

//这时输出
Child function run ……

14、由于后面又创建(new)了一个新的Child对象，因此重复一下【9】之后的步骤，很容易明白它的输出结果为

Parent代码块： a=10
Parent代码块： b=13
Parent无参构造函数： a=11
Parent无参构造函数： b=14
Child代码块： x=10
Child代码块： y=13
Child构造函数： x=11
Child构造函数： y=14
Child function run ……

简单的画个内存运行示例图

总结

我们知道，我们在创建(new)一个对象的时候，先要去JVM的方法区里获取该对象所对应的类的信息，如果方法区里没有该类的信息，则需要去将它加载进来，加载进来之后，有了该类的信息，我们才能创建一个对象。
一般，Java类被编译后，会生成一个class文件，在运行的时候会将class文件加载到Java虚拟机JVM中，class文件由类装载器装载，在JVM中（准确的来说应该是在JVM的方法区里）将形成一份描述Class结构的元信息对象，通过该元信息对象可以获知Class的结构信息：如构造函数，属性和方法等。
一、类的加载过程
首先，Jvm在执行时，遇到一个新的类时，会到内存中的方法区去找class的信息，如果找到就直接拿来用，如果没有找到，就会去将类文件加载到方法区。在类加载时，静态成员变量加载到方法区的静态区域，非静态成员变量加载到方法区的非静态区域。
静态代码块是在类加载时自动执行的代码，非静态代码块是在创建对象时自动执行的代码，不创建对象不执行该类的非静态代码块。

加载过程：
1、JVM会先去方法区中找有没有相应类的.class存在。如果有，就直接使用；如果没有，则把相关类的.clss加载到方法区。
2、在.class加载到方法区时，先加载父类再加载子类；先加载静态内容，再加载非静态内容
3、加载静态内容：

• 把.class中的所有静态内容加载到方法区下的静态区域内
• 静态内容加载完成之后，对所有的静态变量进行默认初始化
• 所有的静态变量默认初始化完成之后，再进行显式初始化
• 当静态区域下的所有静态变量显式初始化完后，执行静态代码块

4、加载非静态内容：把.class中的所有非静态变量及非静态代码块加载到方法区下的非静态区域内。
5、执行完之后，整个类的加载就完成了。
对于静态方法和非静态方法都是被动调用，即系统不会自动调用执行，所以用户没有调用时都不执行，主要区别在于静态方法可以直接用类名直接调用（实例化对象也可以），而非静态方法只能先实例化对象后才能调用。

二、对象的创建过程
1、new一个对象时，在堆内存中开辟一块空间。
2、给开辟的空间分配一个地址。
3、把对象的所有非静态成员加载到所开辟的空间下。
4、所有的非静态成员加载完成之后，对所有非静态成员变量进行默认初始化。
5、所有非静态成员变量默认初始化完成之后，调用构造函数。
6、在构造函数入栈执行时，分为两部分：先执行构造函数中的隐式三步，再执行构造函数中书写的代码。

   隐式三步：
   ①执行super()语句

   ②显示初始化(对开辟空间下的所有非静态成员变量进行) 

   ③执行构造代码块

7、在整个构造函数执行完并弹栈后，把空间分配的地址赋给引用对象。

三、其他

super语句，可能出现以下三种情况:

1）构造方法体的第一行是this()语句，则不会执行隐式三步，而是调用this()语句所对应的的构造方法，最终肯定会有第一行不是this语句的构造方法。

package mytest.javaBase;

public class Student {

    private String name;

    private String age;

    Student() {
    };

    Student(String name) {
        this.name = name;

    };

    Student(String name, String age) {
        // 不会执行隐式三步
        this(name);
        this.age = age;
    };

}

2）构造方法体的第一行是super()语句，则调用相应的父类的构造方法

3）构造方法体的第一行既不是this()语句也不是super()语句，则隐式调用super()，即其父类的默认构造方法，这也是为什么一个父类通常要提供默认构造方法的原因；

---

参考资料三：java类加载及new对象的过程

/*
SubClass sub = new SubClass();
这句话到底做了什么事情呢？
1.javac编译.java源文件形成.class字节码文件;
2.new SubClass()对象时，先检查有没有父类，有父类，类加载器(ClassLoader)先将父类的Class文件读入内存，创建一个java.lang.Class对象，然后加载子类，类加载器将子类的Class文件读入内存，创建一个java.lang.Class对象;
3.先初始化父类的静态属性，再初始化父类的静态代码块；
4.再初始化子类的静态属性，再初始化子类的静态代码；
5.在堆内存中分配内存空间，分配内存地址，此时是因为父类的特有属性才在堆内存中为父类对象分配空间。
6.初始化父类的特有属性。
7.初始化父类的构造代码块。
8.初始化父类对象相应的构造方法。
9.在堆内存中分配内存空间，分配内存地址，此时是因为子类的特有属性才在堆内存中为子类对象分配空间的。
10.初始化子类的特有属性。
11.初始化子类的构造代码块。
12.初始化子类相应的构造方法。
13.将子类的内存地址赋值给栈中的引用对象。
*/
package com.zhangyike.staticExcise;

// 静态变量

    public static String staticField = "父类--静态变量";

    public String field = "父类--普通变量";

    // 静态块
    static {
        System.out.println(staticField);
        System.out.println("父类--静态块");
    }

    // 初始化块
    {
        System.out.println(field);
        System.out.println("父类--普通块");
    }

    // 构造器
    public ParentClass() {
        System.out.println("父类--构造器");
    }
}

public class SubClass extends ParentClass {

    // 静态变量
    public static String sstaticField = "子类--静态变量";
    // 变量
    public String sField = "子类--变量";

    // 静态块
    static {
        System.out.println(sstaticField);
        System.out.println("子类--静态块");
    }

    // 初始化块
    {
        System.out.println(sField);
        System.out.println("子类--普通块");
    }

    // 构造器
    public SubClass() {
        System.out.println("子类--构造器");
    }

    public static void main(String[] args) {

        System.out.println("顺序:" + "第一次new SubClass");
        SubClass sub = new SubClass();
        System.out.println("顺序:" + "第二次new SubClass");
        new SubClass();
    }
}

程序执行的结果为：

父类–静态变量
父类–静态块
子类–静态变量
子类–静态块
顺序:第一次new SubClass
父类–普通变量
父类–普通块
父类–构造器
子类–变量
子类–普通块
子类–构造器
顺序:第二次new SubClass
父类–普通变量
父类–普通块
父类–构造器
子类–变量
子类–普通块
子类–构造器