代码块的分类和执行顺序

1.代码块概念以及分类

使用 {} 定义的一段代码称为代码块。根据代码块定义的位置以及关键字，又可分为以下四种：

普通代码块
构造块
静态块
同步代码块

1.1 普通代码块

普通代码块：定义在方法中的代码块.

public class Main{
 public static void main(String[] args) {
 { //直接使用{}定义，普通方法块
 int x = 10 ;
 System.out.println("x1 = " +x);
 }
 int x = 100 ;
 System.out.println("x2 = " +x);
 }
}
 
// 执行结果
x1 = 10
x2 = 100

1.2 构造代码块

构造块：定义在类中的代码块(不加修饰符)。也叫：实例代码块。构造代码块一般用于初始化实例成员变量。

public class Student{    
//实例成员变量 
	private String name;
	private String gender;   
    private  int age;    
    private double score;     
    public Student() { 
 		 System.out.println("I am Student init()!"); 
   }     
  //实例代码块 
  { 
  	this.name = "bit"; 
  	this.age = 12; this.sex = "man";     
    System.out.println("I am instance init()!");
   } 
    public void show(){ 
      System.out.println("name: "+name+" age: "+age+" sex: "+sex);
    }
} 
public class Main {
	 public static void main(String[] args) { 
 		Student stu = new Student(); stu.show();
  	} 
 } 

// 运行结果 
I am instance init()! 
I am Student init()! 
name: bit age: 12 sex: man

1.3 静态代码块

使用static定义的代码块称为静态代码块。一般用于初始化静态成员变量。

public class Student{    
private String name;
    private String gender;
    private int  age;    
    private double score;    
    private static String classRoom;    
    //实例代码块   
    {        
	    this.name = "bit";
	    this.age = 12；
	          this.gender = "man";
        System.out.println("I am instance init()!");
   }
 
    // 静态代码块
    static {
        classRoom = "bit306";
        System.out.println("I am static init()!");
   }
 
    public Student(){
        System.out.println("I am Student init()!");
   }
 
    public static void main(String[] args) {
        Student s1 = new Student();
        Student s2 = new Student();
   }
}

注意事项：
静态代码块不管生成多少个对象，其只会执行一次
静态成员变量是类的属性，因此是在JVM加载类时开辟空间并初始化的
如果一个类中包含多个静态代码块，在编译代码时，编译器会按照定义的先后次序依次执行(合并)
实例代码块只有在创建对象时才会执行

2.代码块执行顺序

【在没有继承关系时的执行顺序】

class Person {
    public String name;
    public int age;
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
        System.out.println("构造方法执行");
   }
   {
        System.out.println("实例代码块执行");
   }
    static {
        System.out.println("静态代码块执行");
   }
}
 
public class TestDemo {
    public static void main(String[] args) {
        Person person1 = new Person("bit",10);
        System.out.println("============================");
        Person person2 = new Person("gaobo",20);
   }
}

执行结果：
静态代码块
执行实例代码块
执行构造方法执行
============================
实例代码块执行
构造方法执行

1. 静态代码块先执行，并且只执行一次，在类加载阶段执行
2. 当有对象创建时，才会执行实例代码块，实例代码块执行完成后，最后构造方法执行

【继承关系上的执行顺序】

class Person {
    public String name;
    public int age;
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
        System.out.println("Person：构造方法执行");
   }
   {
        System.out.println("Person：实例代码块执行");
   }
    static {
        System.out.println("Person：静态代码块执行");
   }
}
 
class Student extends Person{
 
    public Student(String name,int age) {
        super(name,age);
        System.out.println("Student：构造方法执行");
   }
 
   {
        System.out.println("Student：实例代码块执行");
   }
    
    static {
        System.out.println("Student：静态代码块执行");
   }
 
 
}
 
public class TestDemo4 {
 
    public static void main(String[] args) {
        Student student1 = new Student("张三",19);
        System.out.println("===========================");
        Student student2 = new Student("gaobo",20);
          }
 
    public static void main1(String[] args) {
        Person person1 = new Person("bit",10);
        System.out.println("============================");
        Person person2 = new Person("gaobo",20);
   }
}

执行结果：
Person：静态代码块执行
Student：静态代码块执行
Person：实例代码块执行
Person：构造方法执行
Student：实例代码块执行
Student：构造方法执行
===========================
Person：实例代码块执行
Person：构造方法执行
Student：实例代码块执行
Student：构造方法执行

通过分析执行结果，得出以下结论：
1、父类静态代码块优先于子类静态代码块执行，且是最早执行
2、父类实例代码块和父类构造方法紧接着执行
3、子类的实例代码块和子类构造方法紧接着再执行
4、第二次实例化子类对象时，父类和子类的静态代码块都将不会再执行