WindCoder网

Java代码块执行顺序初探

Java笔记java2163 字约 8 分钟1
Java代码块执行顺序初探

1、仅构造方法

每个类都有构造方法。 如果没有显式地为类定义构造方法，Java编译器将会为该类提供一个默认构造方法。 若定义了有参构造方法，编译器将不会提供默认的无参构造，如需要，需要自己构造。 Java继承中对构造函数是不继承的，只是显式或者隐式调用。

实例

父类A：

public class A {


    public A(){
        System.out.println("A constructor");
    }




    public A(int a){
        System.out.println("A constructor ,num:"+a);
    }
}

子类B：

public class B extends A {


    public B (){
        System.out.println("B constructor");
    }


    public B(int b){
        System.out.println("B constructor ,num:"+b);
    }
}

测试类E：

public class E {
    public static void main(String[] args) {
        System.out.println("E main");
        A a = new B();
        System.out.println("-------------AB可爱分割线-------------");
        B b = new B();


        System.out.println("\n---------小可爱分割线-----------\n");


        A a1 = new B(1);
        System.out.println("-------------AB可爱分割线-------------");
        B b1 = new B(2);
    }
}

测试结果：

E main
A constructor
B constructor
-------------AB可爱分割线-------------
A constructor
B constructor


---------小可爱分割线-----------


A constructor
B constructor ,num:1
-------------AB可爱分割线-------------
A constructor
B constructor ,num:2

解析： Java继承中对构造函数是不继承的，只是显式或者隐式调用，并且必须是在构造函数第一行。这里是隐式调用了super()。 子类不能继承父类的构造器（构造方法或者构造函数），但是父类的构造器带有参数的，则必须在子类的构造器中显式地通过super关键字调用父类的构造器并配以适当的参数列表。 如果父类有无参构造器，则在子类的构造器中用super调用父类构造器不是必须的，如果没有使用super关键字，系统会自动调用父类的无参构造器。 所以先执行父类构造函数，再执行子类构造函数。

2、静态块、构造方法

静态代码块<在java中使用static关键字声明的代码块>。

实例1:

父类A：

public class A {


    static {
        System.out.println("A constructor before static");
    }


    public A(){
        System.out.println("A constructor");
    }




    public A(int a){
        System.out.println("A constructor ,num:"+a);
    }


    static {
        System.out.println("A constructor after static");
    }
}

子类B：

public class B extends A {
    static {
        System.out.println("B constructor before static");
    }
    public B (){
        System.out.println("B constructor");
    }


    public B(int b){
        System.out.println("B constructor ,num:"+b);
    }


    static {
        System.out.println("B constructor after static");
    }
}

测试类E：

public class E {
    public static void main(String[] args) {
        System.out.println("E main");
        A a = new B();
        System.out.println("-------------AB可爱分割线-------------");
        B b = new B();


        System.out.println("\n---------小可爱分割线-----------\n");


        A a1 = new B(1);
        System.out.println("-------------AB可爱分割线-------------");
        B b1 = new B(2);
    }
}

测试结果：

E main
A constructor before static
A constructor after static
B constructor before static
B constructor after static
A constructor
B constructor
-------------AB可爱分割线-------------
A constructor
B constructor


---------小可爱分割线-----------


A constructor
B constructor ,num:1
-------------AB可爱分割线-------------
A constructor
B constructor ,num:2

解析： 静态块用于初始化类，为类的属性初始化。每个静态代码块只会执行一次。 由于JVM在加载类时会执行静态代码块，所以静态代码块先于主方法执行。 如果类中包含多个静态代码块，那么将按照”先定义的代码先执行，后定义的代码后执行”。 静态代码块不能存在于任何方法体内。 静态代码块不能直接访问静态实例变量和实例方法，需要通过类的实例对象来访问。 当父类与子类都有静态代码块和构造函数的时候，执行顺序如下：

  • 父类静态代码块 > 子类静态代码块（Java虚拟机加载类时，就会执行该块代码）。
  • 父类构造函数 > 子类构造函数 （先有父亲，后有孩子）
  • 如果是多级继承关系的话，高层的父类首先执行，然后依次递减。

总结：静态优先执行，父类优先于子类执行。 静态代码块是在JVM加载类的时候执行的，而且静态代码块执行且仅执行一次

实例2：

子类包含静态属性---子类的实例化。 父类A<同实例1> 子类B:

public class B extends A {


    public static A b = new B(3);
    public static A a = new A(2);
    public static B c = new B(1);
    static {
        System.out.println("B constructor before static");
    }
    public B (){
        System.out.println("B constructor");
    }


    public B(int b){
        System.out.println("B constructor ,num:"+b);
    }


    static {
        System.out.println("B constructor after static");
    }
}

测试类F：

public class F {
    public static void main(String[] args) {
        System.out.println("F main");
        A a = new B();
    }
}

测试结果：

F main
A constructor before static
A constructor after static
A constructor
B constructor ,num:3
A constructor ,num:2
A constructor
B constructor ,num:1
B constructor before static
B constructor after static
A constructor
B constructor

解析： 进入main函数，先执行

System.out.println("F main");

得到

F main

执行

A a = new B();

后，先执行父类的静态块得到

A constructor before static
A constructor after static

执行子类静态成员变量（方法块），由于子类包含静态属性和方法，按照“先定义的代码先执行，后定义的代码后执行”的规则，先执行静态属性部分，即：

public static A b = new B(3);
   public static A a = new A(2);
   public static B c = new B(1);

此时由于父类静态部分已经执行，故执行相应的构造函数得到(感觉说是中断类加载过程，执行实例初始化过程更贴切些，这部分可以考虑参考看最后关于“暂停类加载”部分)：

A constructor
B constructor ,num:3
A constructor ,num:2
A constructor
B constructor ,num:1

由于之后子类含有静态块，故继续执行静态块中的打印：

B constructor before static
B constructor after static

最后执行最终的无参构造函数：

A constructor
B constructor

若父类A，改成如下会更直观：

public class A {


   public static A a = new B(12);


   static {
       System.out.println("A constructor before static");
   }


   public A(){
       System.out.println("A constructor");
   }




   public A(int a){
       System.out.println("A constructor ,num:"+a);
   }


   static {
       System.out.println("A constructor after static");
   }
}

此时结果：

F main
A constructor
B constructor ,num:12
A constructor before static
A constructor after static
A constructor
B constructor ,num:3
A constructor ,num:2
A constructor
B constructor ,num:1
B constructor before static
B constructor after static
A constructor
B constructor

实例3：

子类和父类存在相同的静态方法和非静态方法时 父类A：

public class A {


   static {
       System.out.println("A constructor before static");
   }


   public static void getClassStaticFunc(){
       System.out.println("get A static Function");
   }


   public  void getClassFunc(){
       System.out.println("get A  Function");
   }


   public A(){
       System.out.println("A constructor");
   }




   public A(int a){
       System.out.println("A constructor ,num:"+a);
   }


   static {
       System.out.println("A constructor after static");
   }


}

子类B：

public class B extends A {


   static {
       System.out.println("B constructor before static");
   }


   public static void getClassStaticFunc(){
       System.out.println("get B static Function");
   }


   public  void getClassFunc(){
       System.out.println("get B  Function");
   }


   public B (){
       System.out.println("B constructor");
   }


   public B(int b){
       System.out.println("B constructor ,num:"+b);
   }


   static {
       System.out.println("B constructor after static");
   }


}

测试类F：

public class F {
   public static void main(String[] args) {
       System.out.println("F main");
       A a = new B();
       a.getClassStaticFunc();
       a.getClassFunc();
   }
}

测试结果：

F main
A constructor before static
A constructor after static
B constructor before static
B constructor after static
A constructor
B constructor
get A static Function
get B  Function

解析： java中静态属性和静态方法可以被继承，但是没有被重写(overwrite)而是被隐藏。 原因： 1). 静态方法和属性是属于类的，调用的时候直接通过类名.方法名完成对，不需要继承机制及可以调用。如果子类里面定义了静态方法和属性，那么这时候父类的静态方法或属性称之为”隐藏”。如果你想要调用父类的静态方法和属性，直接通过父类名.方法或变量名完成，至于是否继承一说，子类是有继承静态方法和属性，但是跟实例方法和属性不太一样，存在”隐藏”的这种情况。 2). 多态之所以能够实现依赖于继承、接口和重写、重载（继承和重写最为关键）。有了继承和重写就可以实现父类的引用指向不同子类的对象。重写的功能是：“重写”后子类的优先级要高于父类的优先级，但是“隐藏”是没有这个优先级之分的。 3). 静态属性、静态方法和非静态的属性都可以被继承和隐藏而不能被重写，因此不能实现多态，不能实现父类的引用可以指向不同子类的对象。非静态方法可以被继承和重写，因此可以实现多态。

3、构造代码块、静态块、构造方法

构造块：直接在类中定义且没有加static关键字的代码块称为{}构造代码块。 构造代码块在创建对象时被调用，每次创建对象都会被调用，并且构造代码块的执行次序优先于类构造函数。

实例1

父类A：

public class A {


   {
       System.out.println("A constructor before static before 构造块");
   }
   static {
       System.out.println("A constructor before static");
   }


   public A(){
       System.out.println("A constructor");
   }




   public A(int a){
       System.out.println("A constructor ,num:"+a);
   }


   static {
       System.out.println("A constructor after static");
   }


   {
       System.out.println("A constructor after static after 构造块");
   }
}

子类B：

public class B extends A {


   {
       System.out.println("B constructor before static before 构造块");
   }


   static {
       System.out.println("B constructor before static");
   }
   public B (){
       System.out.println("B constructor");
   }


   public B(int b){
       System.out.println("B constructor ,num:"+b);
   }


   static {
       System.out.println("B constructor after static");
   }


   {
       System.out.println("B constructor after static after 构造块");
   }
}

测试类E：

public class E {
    public static void main(String[] args) {
        System.out.println("E main");
        A a = new B();
        System.out.println("-------------AB可爱分割线-------------");
        B b = new B();


        System.out.println("\n---------小可爱分割线-----------\n");


        A a1 = new B(1);
        System.out.println("-------------AB可爱分割线-------------");
        B b1 = new B(2);
    }
}

测试结果：

E main
A constructor before static
A constructor after static
B constructor before static
B constructor after static
A constructor before static before 构造块
A constructor after static after 构造块
A constructor
B constructor before static before 构造块
B constructor after static after 构造块
B constructor
-------------AB可爱分割线-------------
A constructor before static before 构造块
A constructor after static after 构造块
A constructor
B constructor before static before 构造块
B constructor after static after 构造块
B constructor


---------小可爱分割线-----------


A constructor before static before 构造块
A constructor after static after 构造块
A constructor
B constructor before static before 构造块
B constructor after static after 构造块
B constructor ,num:1
-------------AB可爱分割线-------------
A constructor before static before 构造块
A constructor after static after 构造块
A constructor
B constructor before static before 构造块
B constructor after static after 构造块
B constructor ,num:2

解析： 先静态后构造块，先父类后子类。

实例2:

对于非继承类J

public class J {
    public static int k = 0;
    static {
        print("静态块2");
    }
    public static J t1 = new J("t1");
    public static J t2 = new J("t2");
    public static int i = print("i");
    public static int n = 99;
    public int j = print("j");


    {
        print("构造块");
    }
    static {
        print("静态块");
    }


    public J(String str) {
        System.out.println((++k) + ":" + str + "   i=" + i + "    n=" + n);
        ++i;
        ++n;
    }


    public static int print(String str) {
        System.out.println((++k) + ":" + str + "   i=" + i + "    n=" + n);
        ++n;
        return ++i;
    }


    public static void main(String args[]) {
        J t = new J("init");
    }
}

测试结果：

1:静态块2   i=0    n=0
2:j   i=1    n=1
3:构造块   i=2    n=2
4:t1   i=3    n=3
5:j   i=4    n=4
6:构造块   i=5    n=5
7:t2   i=6    n=6
8:i   i=7    n=7
9:静态块   i=8    n=99
10:j   i=9    n=100
11:构造块   i=10    n=101
12:init   i=11    n=102

解析： 典型的暂停类加载。即：类加载过程中，可能调用了实例化过程（因为static可以修饰方法，属性，代码块，内部类），此时则会暂停类加载过程而先执行实例化过程（被打断），执行结束再进行类加载过程。 类加载过程，不涉及构造方法。 实例化过程，涉及构造方法。 先类加载，执行static修饰的部分，遇到属性实例化，中断去执行实例化，完成后继续类加载，如此循环直至结束。

小结

无继承的的初始化顺序

静态成员变量（静态代码块）→普通成员变量→构造器

有继承的初始化顺序

父类静态成员变量、静态代码块→子类静态成员变量、静态代码块→父类普通成员变量、普通代码块→父类构造器→子类普通成员变量、普通代码块→子类构造器。

其他

类加载过程，不涉及构造方法 实例化过程，涉及构造方法 1、类中所有属性的默认值（一举而成） 2、父类静态属性初始化，静态块，静态方法的声明（按出现顺序执行） 3、子类静态属性初始化，静态块，静态方法的声明 （按出现顺序执行） 4 、调用父类的构造方法， 首先父类的非静态成员初始化，构造块，普通方法的声明（按出现顺序执行） 然后父类构造方法 5、 调用子类的构造方法， 首先子类的非静态成员初始化，构造块，普通方法的声明（按出现顺序执行） 然后子类构造方法

参考资料

深入了解Java程序执行顺序 Java中普通代码块，构造代码块，静态代码块区别及代码示例 Java：构造器，构造代码块，静态代码块的执行顺序 Java 继承 在继承中的问题，关于静态代码块，子类和父类的静态代码块的执行情况 JAVA静态方法是否可以被继承？

本文采用 CC BY-NC-SA 4.0 许可，转载请注明出处与作者。

支持一下

如果这篇文章对你有帮助，欢迎打赏或分享。

打赏支持
相关文章智能推荐
1统计一个字符串中每一个字符出现的次数Java笔记本文提供三种方案，本质都是先将字符串转为数组：String.charAt(index)String.split(“”)String.toCharArray()具体如下： /** * 通过Strin2致纯纯的小白杂谈前言群中会有在这条路上走了或长或短的一段的朋友，也肯定会有想入门或刚入门的朋友，感谢你的加入，希望在这里大家有问题可以一起吃讨论，没问题时也能一起嗨，毕竟生活不只有眼前的苟且以及日常的码代码，还有诗3使用Project Lombok编写Fat-free java代码Java笔记英文原文：Write Fat-free Java Code with Project Lombok 前言没想到这次收到的是java的文章，更没想到的是内容是之前在北京实习时一家公司用到过的工具。当初4Java基础小结（三）Java笔记Java 数据结构Java中的数据结构主要包括以下几种接口和类：枚举（Enumeration）位集合（BitSet）向量（Vector）栈（Stack）字典（Dictionary）哈希表（Hasht5Java基础小结（二）Java笔记Java继承继承的特性1、子类拥有父类非private的属性、方法。2、子类可以拥有自己的属性和方法，即子类可以对父类进行扩展。3、子类可以用自己的方式实现父类的方法。4、Java的继承是单继承，但
随机文章随机推荐
暂无随机文章

评论