java 静态代码加载顺序和特性

1、静态代码块格式：

static
{
　　执行语句
}

特点：随着类的加载而执行，且只执行一次，并优先于主函数。用于给类初始化的。

 

2、执行顺序：

示例一

静态代码块随着类加载而加载

有多个静态代码块的，按代码块前后顺序加载

一个代码块，只执行一次。

package javastudy;

class StaticCode1{        
    static{                                //第4步。由第3步触发。
        System.out.println("x");
    }
}

public class StaticDemo2 {
    static{                                //第1步。先加载主函数所在类，所以先加载并执行这段静态代码块。
        System.out.println("y");
    }    
    public static void main(String[] args) {
        new StaticCode1();                //第3加载StaticCode1类。
        new StaticCode1();                //不执行。静态代码块只执行一次
        System.out.println("over");        //第5步。输出打印。
    }
    static{                                //第2步。多个静态代码块之前，按前后顺序执行
        System.out.println("z");
    }
}

输出：

y
z
x
over

 

示例二

 

public class StaticDemo1 {                             

    public static void main(String[] args) {
        StaticDemo1 t1=new StaticDemo1();    //第2步，初始化构造函数，i=9
        System.out.println(t1.i);            //第3步，按顺序执行,9
        speak();                            //第4步，按顺序执行，调用静态函数
        
    }    
    static int i=1;                            //静态变量存到静态区域。    
    static void speak()                        //静态函数存到静态区域。调用时执行。
    {
        System.out.println("a");;
    }
    static {                                //第1步，静态代码块随着类的加载,优先执行且只执行一次。i=3，i+3打印结果是4。
        i=i+3;
        System.out.println(i);
    }
    
    public StaticDemo1(){                    //构造方法，初始化时执行。
        i=i+5;                                //i=9
        System.out.println(i);    
    }
}

输出：

4
9
9
a

 

 

示例三

package javastudy;

public class StaticDemo2 {
    public static void main(String[] args) {
    }
    static{                    //随类加载就执行，不需要实例化
        System.out.println("z");
    }
}

输出：

z

 

示例四

class StaticCode2{        
    
    StaticCode2(){                        //没有调用。
        System.out.println("aa");
    }
    static{                                //1 静态代码块先执行
        System.out.println("x");
    }
    {                                    //2 对象的构造代码块。给对象初始化的。
        System.out.println("cc");
    }
    
    StaticCode2(int i){                    //3 被调用
        System.out.println("aa");
    }
    public static void show(){                //静态方法，没有调用。
        System.out.println("gogogo");
    }
}

public class StaticDemo4 {
    public static void main(String[] args) {
        new StaticCode2(4);                    
    }

}

输出：

x
cc
aa

 

示例五

public class StaticDemo5 {
    static int i=1;
    static{                            
        System.out.println("a");        //第1步。a。且只执行一次
        i++;                            //i=i+1，结果2
    }    
    public StaticDemo5(){
        System.out.println("c");        //第2步。
        i++;                            //i=i+1，结果3
    }
    
    public static void main(String[] args) {
        StaticDemo5 t1=new StaticDemo5();
        System.out.println(t1.i);        //第3步。3
        
        StaticDemo5 t2=new StaticDemo5();    //第4步。c。第二次创建实例。static静态代码块不执行。
        System.out.println(t2.i);        //第5步。又执行了一次StaticDemo5()构造函数。4
    }
}

输出：

a
c
3
c
4

 创建第二个对象StaticDemo5 t2=new StaticDemo5()时，其实i已经先于对象存在于静态区域