Java类的加载_java类什么加载-CSDN博客

本文链接：https://blog.csdn.net/qq_32931825/article/details/60574126

无父类

加载顺序

为静态变量开辟空间（默认初始化），然后显示初始化
静态代码块
静态方法
new语句明确首地址，在堆内存中为对象开辟相应大小的空间（默认初始化），此时有了this这一概念
成员变量的显示初始化。
构造代码块
构造函数

代码

public class Main {
    public static void main(String args[])
    {
        /*1*/
        Demo a=new Demo();    /*堆*/
//      /*2*/
//      Demo.funtion2();
//      /*3*/
//      Demo b=new Demo();
//      b.funtion1();
//      /*4*/
//      Demo c=new Demo();
//      System.out.println(c.dNum1);
//      /*5*/
//      Demo d=new Demo();
//      System.out.println(d.dNum2);
//      /*6*/
//      System.out.println(Demo.dNum3);
//      /*7*/
//      System.out.println(Demo.dNum4);

    }
}
class Demo
{
    int dNum1=5;           /*堆*/
    final int dNum2=10;    /*堆*/
    static int dNum3=15;   /*堆->方法区->静态方法区*/
    final static int dNum4=20;  /*堆->方法区->常量池*/

    {      /*堆->方法区*/
        System.out.println("构造代码块        " + dNum1 + "    " + dNum2 + "    " + dNum3 + "    " + dNum4);
    }

    static    /*堆->方法区->静态方法区*/
    {
        System.out.println("静态代码块        " +dNum3 +"   "+ dNum4);
    }

    Demo()      /*堆->方法区*/
    {
        System.out.println("默认构造函数    " + dNum1 + "    " + dNum2 + "    " + dNum3 + "    " + dNum4);
    }

    void funtion1()      /*堆->方法区*/
    {
        System.out.println("普通成员方法    "+ dNum1 + "    " + dNum2 + "    " + dNum3 + "    " + dNum4);
    }

    static void funtion2()     /*堆->方法区->静态方法区*/
    {
        System.out.println("静态方法    " + dNum3 + "    " + dNum4);
    }

}

输出

/* 1 */

静态代码块 15 20
构造代码块 5 10 15 20
默认构造函数 5 10 15 20

/* 2 */

静态代码块 15 20
静态方法 15 20

/* 3 */

静态代码块 15 20
构造代码块 5 10 15 20
默认构造函数 5 10 15 20
普通成员方法 5 10 15 20

/* 4 */

静态代码块 15 20
构造代码块 5 10 15 20
默认构造函数 5 10 15 20
5

/* 5 */

静态代码块 15 20
构造代码块 5 10 15 20
默认构造函数 5 10 15 20
10

/* 6 */

静态代码块 15 20
15

/* 7 */

20

final关键字引用

额外：final关键字修饰一个变量时,是引用不能变，还是引用的对象不能变？
答：http://blog.csdn.net/u012110719/article/details/46334413

有父类

加载顺序

父类加载，为父类的静态变量开辟空间（默认初始化），然后显示初始化
父类的静态代码块
父类的静态方法
子类的静态变量开辟空间（默认初始化），然后显示初始化
子类的静态代码块
子类的静态方法
父类super这一概念
父类成员变量的显示初始化。
父类的构造代码块
父类的构造函数
子类new语句明确首地址，在堆内存中为对象开辟相应大小的空间（默认初始化），此时有了this这一概念
子类成员变量的显示初始化。
子类构造代码块
子类构造函数

代码

public class Main {
    public static void main(String args[])
    {
        /*1*/
        Demo a=new Demo();
//      /*2*/
//      Demo.funtion2();
//      /*3*/
//      Demo b=new Demo();
//      b.funtion1();
//      /*4*/
//      Demo c=new Demo();
//      System.out.println(c.dNum1);
//      /*5*/
//      Demo d=new Demo();
//      System.out.println(d.dNum2);
//      /*6*/
//      System.out.println(Demo.dNum3);
//      /*7*/
//      System.out.println(Demo.dNum4);
//      /*8*/
//      Demo d=new Demo();
//      System.out.println(d.fNum2);
//      /*9*/
//      System.out.println(Demo.fNum3);
//      /*10*/
//      System.out.println(Demo.fNum4);
    }
}
class Demo extends Father
{
    int dNum1=5;           /*堆*/
    final int dNum2=10;    /*堆*/
    static int dNum3=15;   /*静态方法区*/
    final static int dNum4=20;       /*常量池*/

    {
        System.out.println("子类的      构造代码块        " + dNum1 + "    " + dNum2 + "    " + dNum3 + "    " + dNum4);
    }

    static
    {
        System.out.println("子类的      静态代码块        " +dNum3 +"   "+ dNum4);
    }

    Demo()
    {
        System.out.println("子类的      默认构造函数    " + dNum1 + "    " + dNum2 + "    " + dNum3 + "    " + dNum4);
    }

    void funtion1()
    {
        System.out.println("子类的      普通成员方法    "+ dNum1 + "    " + dNum2 + "    " + dNum3 + "    " + dNum4);
    }

    static void funtion2()
    {
        System.out.println("子类的     静态方法    " + dNum3 + "    " + dNum4);
    }
}

class Father
{
    int fNum1=-5;         /*堆*/
    final int fNum2=-10;  /*堆*/
    static int fNum3=-15; /*静态方法区*/
    final static int fNum4=-20;        /*常量池*/

    {
        System.out.println("父类的      构造代码块        " + fNum1 + "    " + fNum2 + "    " + fNum3 + "    " + fNum4);
    }

    static
    {
        System.out.println("父类的      静态代码块        " +fNum3 +"   "+ fNum4);
    }

    Father()
    {
        System.out.println("父类的      默认构造函数    " + fNum1 + "    " + fNum2 + "    " + fNum3 + "    " + fNum4);
    }

    void funtion1()
    {
        System.out.println("父类的     普通成员方法    "+ fNum1 + "    " + fNum2 + "    " + fNum3 + "    " + fNum4);
    }

    static void funtion2()
    {
        System.out.println("父类的     静态方法    " + fNum3 + "    " + fNum4);
    }
}