代码块解析

一、分类

根据代码块出现的位置以及关键字，分为四个代码块

1、普通代码块

2、构造块

3、静态代码快

      I、 非主类的中的静态代码块

      II、主类中的静态代码块

4、同步代码块

二、概念

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

/*
public class Test{
     public static void main(String[] args) {
         
        int a = 0;
        {
            int b = 0;
        }
     }
 }
*/
/*
 public class Test{
     public static void main(String[] args) {
        {
            int a = 0;  //这个变量在出这个普通方法块后，无效
        }
         int a = 0;  //因此a没有重复定义
     }
 }
*/

public class Test{
     public static void main(String[] args) {
        int a = 0; //a在整个方法中有效
        {
            int a = 0;//错误，已在main方法中定义了a变量
        }
        
     }
 }

2、构造块

      定义在类中的代码块（不加任何修饰符），在对象产生时，优先于构造方法执行，有几个对象，就调用几次构造方法

      用于在构造方法执行前完成一些属性的初始化操作

 public class Test{
    //构造块
    {
        System.out.println("构造块");
    }
    public static void main(String[] args) {
        //没有对象创建时，不执行，没有输出
        //创建对象后执行
        new Test(); //输出：构造块
    }
 }

3、静态代码块：（用于给静态区初始化）

      I、非主类中的静态代码块

class A{
    static {
        System.out.println("非主类的静态块")
    }
}
public class Test{
    public static void main(String[] args) {
        
    }
 }

           在类加载时执行（类使用的时候），优先于构造块执行，无论有多少对象产生，都只调用一次

      II、主类中的静态代码块

class A{
    static {
        System.out.println("非主类的静态块")
    }
}
public class Test{
    static {
        System.out.println("主类的静态块")
    }
    public static void main(String[] args) {
        
    }
 }

执行过程：

           非主类中的静态代码块，在类加载时执行（类使用的时候），优先于构造块执行，无论有多少对象产生，都只调用一次

class A{
    {
        System.out.println("1.非主类的构造块"); //只调用一次
    }
    static {
        System.out.println("2.非主类的静态块");
    }
}
public class Test{
    public static void main(String[] args) {
        new A();
        new A();
        new A();
    }
 }
/*输出结果：
2.非主类的静态块
1.非主类的构造块
1.非主类的构造块
1.非主类的构造块
*/

           主类中的静态块优先于主方法执行

public class Test{
    static {
        System.out.println("1.主类的静态块");
    }
    public static void main(String[] args) {
        System.out.println("2.主方法");
    }
 }
 //输出结果：
 //1.主类的静态块
 //2.主方法

4、同步代码块（多线程部分）

在多线程中为解决同一时刻多个线程同时访问共享资源是产生的问题，提出了锁的机制，而被锁住的代码块就称为同步代码块。

同步代码块同时只能被一个线程所访问，从而保证了线程的互斥访问

synchronized(this) { // 表示为程序逻辑上锁
if(this.ticket>0) { // 还有票
try {
Thread.sleep(20);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} // 模拟网络延迟
System.out.println(Thread.currentThread().getName()+",还有" +this.ticket --
+" 张票");
}
}

 

1、综合构造块和静态块

public class B extends A{
    public B(){
        System.out.println("4.B方法的构造方法");
    }
    {
        System.out.println("5.B方法的构造块");
    }
    static {
        System.out.println("6.B方法的静态块");
    }
    public static void main(String[] args){
        System.out.println("7.start-----------");
        new B();
        new B();
        System.out.println("8.end-------------");
    }
}

输出结果：

6.B方法的静态块
7.start-----------
A
5.B方法的构造块
4.B方法的构造方法
A
5.B方法的构造块
4.B方法的构造方法
8.end-------------

 

2、内部类的静态块和构造块

public class Test3{
    static class Test{
        public Test(){
            System.out.println("1.内部类的构造方法");
        }
        {
            System.out.println("2.内部类的构造块");
        }
        static {
            System.out.println("3.内部类的静态块");
        }
    }
    static{
        System.out.println("4.主类中的静态块");
    }
    public static void main(String[] args){
        System.out.println("5.start----------");
        new Test();
        new Test();
        System.out.println("6.end------------");
    }
}