Java代码块

在java中用{}括起来的称为代码块，代码块可分为以下四种：

• 普通代码块：
• 类中方法的方法体相当于建立了一个作用域(里面定义的外面不能访问，外面定义的里面可以访问),然后执行。
• 代码的执行顺序和书写顺序一致。

public class Test{ public static void main(String[] args){
{
int i=3;
System.out.println(“普通代码块”);
}
//可以重新定义i，如果不定义则访问不到代码块里的i
int i=1;
System.out.println(i); //1 } }

• 交换代码块和外面定义的位置：

public class Test{ public static void main(String[] args){
int i=1;
{
//报错，因为外面已经定义了i变量
//int i=3;
//可以重新赋值
i=3;
System.out.println(“普通代码块”);
}
System.out.println(i); //3 } }

• 构造代码块：
• 构造块会在创建对象时被调用，每次创建时都会被调用，优先于类构造函数执行。
• 定义

public class CodeBlock {
//构造代码块的定义
{
System.out.println(“构造代码块”);
} } 测试类 public static void main(String[] args){
//每次创建时都会被调用，优先于类构造方法执行
new CodeBlock(); //构造代码块
new CodeBlock(); //构造代码块
new CodeBlock(); //构造代码块 }

静态代码块：

• 用static{}包裹起来的代码片段，只会执行一次。静态代码块优先于构造块执行。

• 定义：

public class CodeBlock {
//构造代码块的定义
{
System.out.println(“构造代码块”);
}
//静态代码块的定义，只会执行一次。
static{
System.out.println(“静态代码块”);
} }

• 测试类

public static void main(String[] args){
//构造代码块每次创建时都会被调用，优先于类构造方法执行
//静态代码块只有第一次创建时会被调用，优先于类构造方法执行
//静态代码块优先于构造代码块

//静态代码块第一次创建时会被调用
new CodeBlock();	//执行结果：静态代码块 构造代码块
//第二次就没有
new CodeBlock();	//执行结果：构造代码块 }

• 同步代码块：

使用synchronized(){}包裹起来的代码块，在多线程环境下，对共享数据的读写操作是需要互斥进行的，否则会导致数据的不一致性。同步代码块需要写在方法中。

普通代码块和构造代码块的区别
构造代码块是在类中定义的，而普通代码块是在方法体中定义的。且普通代码块的执行顺序和书写顺序一致。

静态代码块和构造代码块的异同点

• 相同点：都是JVM加载类后且在构造函数执行之前执行，在类中可定义多个，一般在代码块中对一些static变量进行赋值。
• 不同点：静态代码块在非静态代码块之前执行。静态代码块只在第一次new时执行一次，之后不在执行。而非静态代码块每new一次就执行一次。
  代码的执行顺序

静态代码块>构造代码块>构造方法>普通代码块

• 例如：

• 定义静态代码块、构造代码块、构造方法、普通代码块：

public class CodeBlock {
static{
System.out.println(“静态代码块”);
}
{
System.out.println(“构造代码块”);
}
public CodeBlock(){
System.out.println(“无参构造方法”);
}

 public void sayHello(){
     {
         System.out.println("普通代码块");
     }
 }  }

• 测试结果

public static void main(String[] args) {
System.out.println(“执行了main方法”);
new CodeBlock().sayHello();
//静态代码块
//执行了main方法
//构造代码块
//无参构造方法
//普通代码块
System.out.println("===============");
new CodeBlock().sayHello();
//构造代码块
//无参构造方法
//普通代码块 }

父类和之类执行顺序

• 对象的初始化顺序：首先执行父类静态的内容，父类静态的内容执行完毕后，接着去执行子类的静态的内容，当子类的静态内容执行完毕之后，再去看父类有没有构造代码块，如果有就执行父类的构造代码块，父类的构造代码块执行完毕，接着执行父类的构造方法；父类的构造方法执行完毕之后，它接着去看子类有没有构造代码块，如果有就执行子类的构造代码块。子类的构造代码块执行完毕再去执行子类的构造方法。

• 总之一句话:静态代码块内容先执行，接着执行父类构造代码块和构造方法，然后执行子类构造代码块和构造方法。
  例如：

• 定义父类：

public class SuperClass {
static{
System.out.println(“父类静态代码块”);
}
{
System.out.println(“父类构造代码块”);
}
public SuperClass(){
System.out.println(“父类构造函数”);
} }

• 定义子类：

public class SubClass extends SuperClass{
static{
System.out.println(“子类静态代码块”);
}

{
    System.out.println("子类构造代码块");
}
 
public SubClass(){
    System.out.println("子类构造函数");
} }

• 测试：

public static void main(String[] args) {
SubClass sb = new SubClass();
System.out.println("============");
SubClass sb1 = new SubClass(); }

• 打印结果：

//父类静态代码块
//子类静态代码块
//父类构造代码块
//父类构造函数
//子类构造代码块
//子类构造函数
//============
//父类构造代码块
//父类构造函数
//子类构造代码块
//子类构造函数