我们都知道，在Java语言中，有静态字段和实例字段，但是，它们两者之间的初始化是有区别的。

其中，需要说明的一点就是：静态字段由类调用，实例字段由对象调用！！！

1. 静态字段

static 静态字段 / 静态变量 的初始化过程，由Java虚拟机JVM加载类后，自动进行静态字段初始化。

①静态字段的默认初始化：静态字段设置为其类型的默认值。

②静态字段的声明初始化：静态字段设置为声明时的初始化值。

③静态字段的静态块初始化：依次调用静态块进行初始化。

从源程序的角度看，静态字段以上三种初始化的顺序：

①首先进行默认初始化。

②然后根据声明初始化、静态块初始化这两者在程序中的顺序来依次进行！！！（两者谁先谁后是不一定的）

2. 实例字段

实例字段 / 实例变量 的初始化过程，由new进行实例初始化。

①实例字段的默认初始化：实例字段设置为其类型的默认值。

②实例字段的声明初始化：实例字段设置为声明时的初始化值。

③实例字段的实例构造方法初始化：根据实例构造方法签名，调用实例构造方法进行初始化。

从源程序的角度看，实例字段以上三种初始化的顺序：

①首先必须进行默认初始化。

②然后进行声明初始化。

③最后进行实例构造方法的初始化。

因为实例字段相对来说，比较好理解，所以我们在这里重点对静态字段的初始化进行讲解！！！

我们依次来看下面的五个程序！！！👇👇👇

Program Ⅰ： （没有静态块，静态变量的声明初始化的顺序不同）

class Test1 {
  public Test1() {
    System.out.println("Test1实例构造函数之前 a="+Test.a+",b="+Test.b);
    Test.a++;
    Test.b++;
    System.out.println("Test1实例构造函数之后 a="+Test.a+",b="+Test.b);
  }
}
public class Test {
  public static Test1 t=new Test1();
  public static int a;
  public static int b=10;
  public static void main(String[] args) {
    System.out.println("最后的结果:a="+Test.a+",b="+Test.b);
  }
}

Program Output Ⅰ：

Program Analysis Ⅰ：

按此顺序初始化静态变量：默认初始化→声明初始化

默认初始化：静态变量按照声明的顺序依次设置为该类型的默认值。

声明初始化：静态变量按声明的顺序依次设置为声明初始化的值，如果没有声明初始化就跳过。

静态字段初始化流程如下：

1. 默认初始化：类被加载后，首先静态字段会进行默认初始化。结果：t=null，a=0，b=0

2. 声明初始化：①首先进行静态字段t的声明初始化，创建Test1的实例，调用实例构造方法，执行之后的结果：a=1，b=1

                         ②然后进行静态字段a和b的声明初始化，因为静态字段a没有声明初始化，所以就跳过，并执行Test.a++，                     此时a=1；但是静态字段b由声明初始化，结果b=10。（大家对照这个流程，看一下上面的代码和运行结果）

Program Ⅱ：（没有静态块，静态变量的声明初始化的顺序不同）

class Test1 {
  public Test1() {
    System.out.println("Test1实例构造函数之前 a="+Test.a+",b="+Test.b);
    Test.a++;
    Test.b++;
    System.out.println("Test1实例构造函数之后 a="+Test.a+",b="+Test.b);
  }
}
public class Test {
  public static int a;
  public static int b=10;
        public static Test1 t=new Test1();
  public static void main(String[] args) {
    System.out.println("最后的结果:a="+Test.a+",b="+Test.b);
  }
}

Program Output Ⅱ：

Program Analysis Ⅱ：

按此顺序初始化静态变量：默认初始化→声明初始化

默认初始化：静态变量按照声明的顺序依次设置为该类型的默认值。

声明初始化：静态变量按声明的顺序依次设置为声明初始化的值，如果没有声明初始化就跳过。

静态字段初始化流程如下：

1. 默认初始化：类被加载后，首先静态字段会进行默认初始化。结果：t=null，a=0，b=0。

2. 声明初始化：①首先进行静态字段a和b的声明初始化，因为静态字段a没有声明初始化，所以就跳过，结果还是a=0；但                     静态字段b有声明初始化，所以结果是b=10。

                        ②然后再进行静态字段t的声明初始化，创建Test1的实例，调用实例构造方法，Test.a++，Test.b++，执行                     之后的结果是a=1，b=11。（大家对照这个流程，看一下上面的代码和运行结果）

Program Ⅲ：（有静态块，静态块定义在声明初始化语句之后）

class Test1 {
  public Test1() {
    System.out.println("Test1实例构造函数之前 a="+Test.a+",b="+Test.b);
    Test.a++;
    Test.b++;
    System.out.println("Test1实例构造函数之后 a="+Test.a+",b="+Test.b);
  }
}
public class Test {
  public static Test1 t=new Test1();
  public static int a;
  public static int b=10;
  static {
    a=20;
    System.out.println("static静态代码块1之后 a="+Test.a+",b="+Test.b);
  }
  static {
    b=30;
    System.out.println("static静态代码块2之后 a="+Test.a+",b="+Test.b);
  }
  public static void main(String[] args) {
    System.out.println("最后的结果:a="+Test.a+",b="+Test.b);
  }
}

Program Output Ⅲ：

Program Analysis Ⅲ：

按此顺序初始化静态变量：默认初始化→声明初始化→静态代码块初始化

默认初始化：静态变量按照声明的顺序依次设置为该类型的默认值。

声明初始化：静态变量按声明的顺序依次设置为声明初始化的值，如果没有声明初始化就跳过。

静态代码块初始化：按照静态代码块的顺序依次设置静态字段的值。

静态字段初始化流程如下：

1. 默认初始化：类被加载后，首先静态字段会进行默认初始化。 结果：t=null，a=0，b=0。

2. 声明初始化：①首先进行静态字段t的声明初始化，创建Test1的实例，调用实力构造方法，执行之后的结果是a=1，b=1

                         ②进行静态字段a和b的声明初始化，因为静态字段a没有声明初始化，所以就跳过，结果还是a=1；但是静                    态字段b有声明初始化，所以结果是b=10。

3. 静态代码块初始化：①首先执行静态代码块1，对静态字段a进行静态块初始化，结果是a=20，b=10。

                                    ②然后执行静态代码块2，对静态字段b进行静态块初始化，结果是a=20，b=30。（大家对照这个流程，看一下上面的代码和运行结果）

Program Ⅳ：（有静态块，静态块定义在声明初始化语句之前）

class Test1 {
  public Test1() {
    System.out.println("Test1实例构造函数之前 a="+Test.a+",b="+Test.b);
    Test.a++;
    Test.b++;
    System.out.println("Test1实例构造函数之后 a="+Test.a+",b="+Test.b);
  }
}
public class Test {
  static {
    a=20;
    System.out.println("static静态代码块1之后 a="+Test.a+",b="+Test.b);
  }
  static {
    b=30;
    System.out.println("static静态代码块2之后 a="+Test.a+",b="+Test.b);
  }
  public static Test1 t=new Test1();
  public static int a;
  public static int b=10;
  public static void main(String[] args) {
    System.out.println("最后的结果:a="+Test.a+",b="+Test.b);
  }
}

Program Output Ⅳ：

Program Analysis Ⅳ：

按此顺序初始化静态变量：默认初始化→静态代码块初始化→声明初始化

默认初始化：静态变量按照声明的顺序依次设置为该类型的默认值。

静态代码块初始化：按静态块的顺序依次设置静态字段的值。

声明初始化：静态变量按声明的顺序依次设置为声明初始化的值，如果没有声明初始化就跳过。

静态字段初始化流程如下：

1. 默认初始化：类被加载后，首先静态字段会进行默认初始化。 结果：t=null，a=0，b=0。

2. 静态代码块初始化：①首先执行静态代码块1，对静态字段a进行静态块初始化，结果是a=20，b=0。

                                    ②然后执行静态代码块2，对静态字段b进行静态块初始化，结果是a=20，b=30。

3. 声明初始化：①首先进行静态字段t的声明初始化，创建Test1的实例，调用实例构造方法，执行后的结果是a=21，b=31

                         ②然后进行静态字段a和b的声明初始化，因为静态字段a没有声明初始化，所以就跳过，结果还是a=21；                      但是静态字段b有声明初始化，所以结果是b=10。（大家对照这个流程，看一下上面的代码和运行结果）

Program Ⅴ：（有静态块，声明初始化语句在两个静态块定义之间）

class Test1 {
  public Test1() {
    System.out.println("Test1实例构造函数之前 a="+Test.a+",b="+Test.b);
    Test.a++;
    Test.b++;
    System.out.println("Test1实例构造函数之后 a="+Test.a+",b="+Test.b);
  }
}
public class Test {
  static {
    a=20;
    System.out.println("static静态代码块1之后 a="+Test.a+",b="+Test.b);
  }
  public static Test1 t=new Test1();
  public static int a;
  public static int b=10;
  static {
    b=30;
    System.out.println("static静态代码块2之后 a="+Test.a+",b="+Test.b);
  }
  public static void main(String[] args) {
    System.out.println("最后的结果:a="+Test.a+",b="+Test.b);
  }
}

Program Output Ⅴ：

Program Analysis Ⅴ：

按此顺序初始化静态变量：默认初始化→静态代码块1初始化→声明初始化→静态代码块2初始化

默认初始化：静态变量按照声明的顺序依次设置为该类型的默认值。

静态代码块初始化：按静态块的顺序依次设置静态字段的值。

声明初始化：静态变量按声明的顺序依次设置为声明初始化的值，如果没有声明初始化就跳过。

静态字段初始化流程如下：

1. 默认初始化：类被加载后，首先静态字段会进行默认初始化。 结果：t=null，a=0，b=0。

2. 静态代码块1初始化：对静态字段a进行静态块初始化，结果a=20，b=0。

3. 声明初始化：①首先进行静态字段t的声明初始化，创建Test1的实例，调用实例构造方法，执行之后结果是a=21，b=1。

                         ②然后进行静态字段a和b的声明初始化，因为静态字段a没有声明初始化，所以就跳过，结果还是a=21；                      但是静态字段b有声明初始化，所以结果是b=10。

4. 静态代码块2初始化：对静态字段b进行静态块初始化，结果a=21，b=30。（大家对照这个流程，看一下上面的代码和运行结果）

根据上面这五个Java小程序，大家可能觉得比较多，看起来不舒服，但是静态字段这部分内容还是很重要的！！！

所以希望大家可以耐心的去理解每一个程序代码，对我们后面的Java知识的学习还是有很大帮助的！！！😊😊😊