java 的运行过程

例子看
ChineseBreakfast.java

构造对象时，先给属性赋值，后调用构造方法

创建对象的执行顺序
1 分配内存
2 初使化变量，给默认初值
3 赋值（可选）
4 执行本类的构造方法

java的运行过程
1 调用super()；this();
2 调用父类构造方法
a 调用super()；this();
b 调用父类构造方法
3 初使化本类实例变量
4 执行本类构造方法



java的运行过程 
一,我们所看不到的: 
1,如果java文件没有package,就默认给文件加上"无名"package; 
2,默认导入java.lang包,所以我们的java程序中可以使用Sting,Math,Integer等类,包括一些异常类; 
3,如果生成的类没有父类,则为这个类隐式加上父类:Object;因此,包括Object中的许多方法可以使用; 
4,字段的初始化; 
二,我们所看的到的: 
既然看的到,就先看程序运行结果: 

package com.andrew;

public class Test {
    public Test() {
        System.out.println(" 构造函数");
    }

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

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

}
运行结果: 
static{} 
main() 


显然,程序运行时,先运行: 
static 
{ 
System.out.println("static{}"); 
} 
再调用main(); 


注意: 我们可以得到一个副产品:不用main方法也能运行的程序: 
public class JRun1 { 

static 
{ 

System.out.println("no main()"); 
System.exit(0); 
} 

} 


如果我们在类中建立一个对象: 
package com.andrew;

public class Test {

    public Test() {
        System.out.println(" 构造函数");
    }

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

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

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

}

运行结果: 
static{} 
main() 
{} 
构造函数 

从而,我们得出: 
建立一个非主类对象,顺序为:静态初始化块static{}-->初始化块{}-->构造函数constructor; 


那么,牵涉到继承,运行流程又如何? 

看程序: 
package com.andrew;

class JRun1Father {
    JRun1Father() {
        System.out.println("父类构造函数");
    }

    static {
        System.out.println("父类静态初始化块");
    }
    {
        System.out.println("父类初始化块");
    }
}

public class Test extends JRun1Father {

    public Test() {
        System.out.println("子类构造函数");
    }

    static {
        System.out.println("子类静态初始化块");

    }
    {
        System.out.println("子类初始化块");
    }

    public static void main(String[] args) {
        // System.out.println("主方法)");
        new Test();
    }

}

运行结果: 

父类静态初始化块 
子类静态初始化块 
父类初始化块 
父类构造函数 
子类初始化块 
子类构造函数 

所以,牵涉到父类:父静态-->子静态-->父初始化及构造-->子初始化及构造; 
注意:初始化块和构造是接连运行的,不会父类子类交替. 


*/
//pack.java
class superPack {
    superPack() {
        System.out.println("父类构造函数");
    }

    {
        System.out.println("父类初始化代码块");
    }
    static {
        System.out.println("父类静态代码块");
    }
}

class subPack extends superPack {
    subPack() {
        System.out.println("子类构造函数");
    }

    {
        System.out.println("子类初始化代码块");
    }
    static {
        System.out.println("子类静态代码块");
    }
};

public class pack {
    pack() {

        System.out.println("pack构造函数");

    }

    static {
        System.out.println("pack静态代码块");
    }

    {
        System.out.println("pack初始化代码块");
    }

    public static void main(String[] args) {
        superPack testPack = new subPack();
    }
};








/*

静态初始化块static{}
在类加载时被执行
并且只执行一次
静态初始化块static{}不用创建对象也能被执行

初始化块{}得创建对象才能执行
并且优先于构造方法


实例变量优先于初始化块{}


运行结果: 
父 静
父类静态实例变量
父类静态初始化块 

子 静
子类静态实例变量
子类静态初始化块 


调用super()；this();

父 实
父 初始化块{}
调用父类构造方法

a 调用super()；this();

b 父 实
c 父 初始化块{}
d 调用父类构造方法

3 初使化本类实例变量
4 本类 初始化块{}
5 执行本类构造方法



程序块执行顺序
（加载类
连接相关资源
Main方法）
静态变量最好排在静态初始化块前面
父类静态变量、静态初始化块（两者的顺序由具体的程序块决定，看程序前后）
子类静态变量、静态初始化块（两者的顺序由具体的程序块决定，看程序前后）
父类实例变量、动态显式初始化块
子类实例变量、动态显式初始化块
父类构造方法
子类构造方法

*/
package com.andrew;

import static java.lang.System.*;

public class Test extends SuperClass {

    static B a = new B();
    static {
        System.out.println("sun static");

    }

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

}


class SuperClass {
    static A a = new A();
    static {
        System.out.println("super static");

    }
}


class A {
    A() {
        System.out.println("super A");
    }
}


class B {
    B() {
        System.out.println("sun B");
    }
}