Java 静态块、构造块、构造函数执行顺序

最新推荐文章于 2025-05-13 15:17:18 发布

原创最新推荐文章于 2025-05-13 15:17:18 发布 · 2.5k 阅读

3 ·

CC 4.0 BY-SA版权

文章标签：

#java #对象 #class

java 专栏收录该内容

21 篇文章

订阅专栏

本文详细解析了Java中构造块与静态块的执行顺序及其影响因素，通过具体示例展示了不同情况下这些构造机制如何工作。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

请先参照这两个帖子：
http://blog.youkuaiyun.com/kingzone_2008/article/details/45015301
http://bbs.youkuaiyun.com/topics/391001417%20%22%22
静态块：用static申明，JVM加载类时执行，仅执行一次
构造块：类中直接用{}定义，每一次创建对象时执行
执行顺序优先级：静态块>main()>构造块>构造方法
静态块和静态属性优先执行，谁在前就先执行谁
注意：
1、每调用一次构造方法，则执行一次构造块
2、静态块只在类加载的时候加载一次
3、有多个静态变量或块时，按声明顺序加载

public class Practice {  
    public static void main(String[] args) {  
        new Father();  
        new Son();  
    }  
}  
class Father {  
    protected int n = 5;  
    protected static int m = 5;
    public static Father p = new Father();
    public static Father p1 = new Father();

    {//构造块  
        n = n * 2;  
        m = m * 2;  
        System.out.print("父类**构造块**调用；");
        System.out.print("n="+n);  
        System.out.println("  m="+m);  
    }  

    static {//实例化多个对象时，静态块只执行一次，即在第一个实例化对象时执行
        m = m * 2;  
        System.out.println("父类%%静态块%%调用； m="+m);  
    }  


    public Father() {  //父类构造函数
        this.n = n * 10;  
        m = m + 10;  
        System.out.print("父类$$构造函数$$；   n="+n);  
        System.out.println("    m="+m);  
    }  
}  

class Son extends Father {  
    private int sn=3;  
    private static int sm=3;  
    static {  
        m = m + 2;  
        sm=sm+2;  
        System.out.println("【 子类 】@@ 静态块 @@调用；    m="+m);  
    }  
    {  
        n = n + 2;  
        sn=sn+2;  
        m = m + 2;  
        System.out.println("【 子类 】^^ 构造块 ^^调用；");  
        System.out.println("n="+n);  
        System.out.println("sn="+sn);  
        System.out.println("m="+m);  
    }  

    public Son() {  
        this.n = n + 10;  
        sn=sn+10;  
        m = m + 10;  
        System.out.println("【 子 类 】[[ 构造函数 ]]；\nn="+n);  
        System.out.println("m="+m);  
    }  
}

结果：（一）

父类**构造块**调用；n=10  m=10
父类$$构造函数$$；   n=100    m=20
父类**构造块**调用；n=10  m=40
父类$$构造函数$$；   n=100    m=50
父类%%静态块%%调用； m=100
父类**构造块**调用；n=10  m=200
父类$$构造函数$$；   n=100    m=210
【 子类 】@@ 静态块 @@调用；    m=212
父类**构造块**调用；n=10  m=424
父类$$构造函数$$；   n=100    m=434
【 子类 】^^ 构造块 ^^调用；
n=102
sn=5
m=436
【 子 类 】[[ 构造函数 ]]；
n=112
m=446

结果（二）：【将main()函数的new Son()注释掉的运行结果】

**父类**构造块**调用；n=10  m=10
父类$$构造函数$$；   n=100    m=20
父类**构造块**调用；n=10  m=40
父类$$构造函数$$；   n=100    m=50
父类%%静态块%%调用； m=100
父类**构造块**调用；n=10  m=200
父类$$构造函数$$；   n=100    m=210**

结果（三）：【将Father类中的两个引用p、p1注释掉的运行结果，结果二中的new Son();也注释掉】

父类%%静态块%%调用； m=10
父类**构造块**调用；n=10  m=20
父类$$构造函数$$；   n=100    m=30

结果（四）：【将Father类中的两个引用p、p1注释掉的运行结果，结果二中的new Son();不注释掉】

父类%%静态块%%调用； m=10
父类**构造块**调用；n=10  m=20
父类$$构造函数$$；   n=100    m=30
【 子类 】@@ 静态块 @@调用；    m=32
父类**构造块**调用；n=10  m=64
父类$$构造函数$$；   n=100    m=74
【 子类 】^^ 构造块 ^^调用；
n=102
sn=5
m=76
【 子 类 】[[ 构造函数 ]]；
n=112
m=86