局部代码块 构造代码块 静态代码块 成员变量 静态变量执行顺序

局部代码块

           局部位置在方法内部,用于限定变量的生命周期,及早释放变量,提高内存利用率。
            {}

构造代码块

              在类中的成员位置(就是成员变量和成员方法可以在的位置)。在构造方法执行之前执行。
              每一次调构造方法执行前都会自动先执行构造代码块。
              {}

静态代码块

            在类中的成员位置,用{}括起来的代码,只不过他用static修饰了。

            static{}

成员变量

             在类体中定义的变量为成员变量，作用范围（scope）是整个类，只要在这个类中都可以访问到它。

             private int a = 3;

静态变量

            用static修饰的变量。

            static T t = new T();

这 五者之间的加载顺序(可以参考https://blog.csdn.net/qq_35654259/article/details/84400317)

             a:静态变量的 默认初始化

             b:静态变量的显示初始化

             c:成员变量的默认初始化

             d:成员变量的显示初始化

       注意：

      a: 静态代码块的执行是在c之前和静态变量的定义是按照代码顺序执行的(无论程序创建多少次对象,静态代码块只加载一次)

      b:构造代码块的执行是在d之后和成员变量的定义是按照代码顺序执行的(构造代码块都会在构造方法执行之前执行,构造方法调用多少次构造代码块就执行多少次)

     c:  局部代码块是在调用成员方法时才执行

例子:

package day08;

class T  implements Cloneable{
	  public static int k = 0;
	  public static  T t1 = new T("t1");//3 
	  public static  T t2 = new T("t2");//6
	  public static int i = print("i");//7
	  public static int n = 99;
	  
	  public int j = print("j");//1 4 9
	  

	  {
	      print("构造快");//2 5  10
	  }
	  
	  static {
	      print("静态块");//8
	  }
	  
	  public T(String str) {
	      System.out.println((++k) + ":" + str + "  i=" + i + "  n=" + n);
	      ++n; ++ i;
	  }
	  
	  public static int print(String str){
	      System.out.println((++k) +":" + str + "   i=" + i + "   n=" + n);
	      ++n;
	      return ++ i;
	  }
	  
	  public static void main(String[] args){
	      T t = new T("init");//11
	  }
	}

结果：

 

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

解释：

    上面的数字代表打印的顺序（下面外之讲解重要的部分）

     a:先调用main方法,加载T 的字节码文件

      b:进行T t1 = NUll(默认初始化),之后进行T t1 = new T("t1");(显示初始化)

            在T t1 = new T("t1")过程中(在这里可以理解为调用构造方法) ~想一想构造方法执行前要做哪些步骤

           b.1: j = 0;(成员变量的默认初始化) j= print(j)； ~打印(在这里要注意 i和 j还没有显示初始化 这边是按照static变量顺序进行显示初始化)

            b.2： print("构造快");(构造代码快的初始化)

            b.3   T(String str) 执行构造方法

 

          c:进行T t2 = NUll(默认初始化),之后进行T t2 = new T("t2");(显示初始化)            ~(仔细看就会发现跟b步骤一样)

            在T t2 = new T("t2")过程中(在这里可以理解为调用构造方法) ~想一想构造方法执行前要做哪些步骤

               c.1: j = 0;(成员变量的默认初始化) j= print(j)； ~打印(在这里要注意 i和 j还没有显示初始化 这边是按照static变量顺序进行显示初始化)

              c.2： print("构造快");(构造代码快的初始化)

               c.3   T(String str) 执行构造方法

 

            d: i = print("i");(static成员变量的显示初始化)

                  打印

             e:n = 99;(static成员变量的显示初始化)

             f:print("静态块")(static静态代码块的执行)

 

             g:T t = new T("init");//加载完后开始执行main方法语句

                g.1: j = 0;(成员变量的默认初始化) j= print(j)； ~打印(在这里要注意 i和 j还没有显示初始化 这边是按照static变量顺序进行显示初始化)

                g.2: print("构造快");(构造代码快的初始化)

                 g.3: T(String str) 执行构造方法