相同点:都是在JVM加载类时且在构造方法执行之前执行,在类中都可以定义多个,

    一般在代码块中对一些static变量进行赋值。

不同点:静态代码块在非静态代码块之前执行

(静态代码块—>非静态代码块—>构造方法)。

静态代码块只在第一次new执行一次,之后不再执行,而非静态代码块在每new一次就执行一次。非静态代码块可在普通方法中定义(不过作用不大);而静态代码块不行。


JVM加载类时会执行这些静态的代码块,如果static代码块有多个,JVM将按照它们在类中出现的先后顺序依次执行它们,每个代码块只会被执行一次。

Example1:

public class PuTong {

   public PuTong(){

       System.out.print("默认构造方法!-->");

   }


   //非静态代码块

   {

       System.out.print("非静态代码块!-->");

   }


   //静态代码块

   static{

       System.out.print("静态代码块!-->");

   }


   public static void test(){

       {

           System.out.println("普通方法中的代码块!");

       }

   }

}


//测试类

public class TestClass {


   /**

    * 区别两次new静态与非静态代码块执行情况

    */

   public static void main(String[] args) {

       PuTong c1 = new PuTong();

       c1.test();


       PuTong c2 = new PuTong();

       c2.test();

   }

}


/*

运行输出结果是:

静态代码块!-->非静态代码块!-->默认构造方法!-->普通方法中的代码块!

非静态代码块!-->默认构造方法!-->普通方法中的代码块!

*/

Example2:

package tags;


public class Child extends Father{

   static {

       System.out.println("child-->static");

   }

   private int n = 20;

   {

       System.out.println("Child Non-Static");

       n = 30;

   }

   public int x = 200;

   public Child() {

       this("The other constructor");

       System.out.println("child constructor body: " + n);

   }

   public Child(String s) {

       System.out.println(s);

   }

   public void age() {

       System.out.println("age=" + n);

   }

   public void printX() {

       System.out.println("x=" + x);

   }

   public static void main(String[] args) {

       new Child().printX();

   }

}


class Father {

       static {

           //System.out.println("n+"+n);

           //当n定义在下面时,会提示Cannot reference a field before it is defined,

           //所以必须把n定义移到上面才可以输出

           System.out.println("super-->static");

       }

       public static int n = 10;

       public int x = 100;

       public Father() {

           System.out.println("super's x=" + x);

           age();

       }

       {

           System.out.println("Father Non-Static");

       }

       public void age(){

           System.out.println("nothing");

       }

}


有两个要点:

1、父类、子类非静态代码块何时初始化?

2、父类调用重写方法时,到底执行的是哪个方法?



结果:


super-->static

child-->static

Father Non-Static

super's x=100

age=0

Child Non-Static

The other constructor

child constructor body: 30

x=200



父类静态代码块 -> 子类静态代码块

-> 父类非静态代码块 -> 父类构造函数

-> 子类非静态代码块 -> 子类构造函数




java中,在使用new操作符创建一个类的实例对象的时候,开始分配空间并将成员变量初始化为默认的数值,注意这里并不是指将变量初始化为在变量定义处的初始值,而是给×××赋值0,给字符串赋值null 这一点于C++不同,(student.name = null , student.age = 0 )


然后在进入类的构造函数。

在构造函数里面,首先要检查是否有this或者super调用,this调用是完成本类本身的构造函数之间的调用,super调用是完成对父类的调用。二者只能出现一个,并且只能作为构造函数的第一句出现。在调用this和super的时候实现程序的跳转,转而执行被调用的this构造函数或者super构造函数。

在this和super执行完毕,程序转而执行在类定义的时候进行的变量初始化工作。

这个执行完毕,才是构造函数中剩下的代码的执行。