java synchronized 局部代码块

本文主要讲述java中代码块的细节

2）3）示例代码如下：

public class CodeBlockDetail {
    public static void main(String[] args) {

        // 类别加载的情况举例
        // 1.是对象创建时
//        new AA();
        // 2.创建子类对象，父类先加载
//        new BB();
        // 3.使用类的静态属性/方法
//        System.out.println(Cat.age);

        // 静态代码块在类加载时执行，并且只执行一次
        // 非静态代码块，随着对象的创建，被调用.
//        CC c1 = new CC();
//        CC c2 = new CC();
        // 当调用静态变量/方法时，非静态代码块不会被调用，只会调用静态代码块
//        System.out.println(CC.age);
        CC.getAge();
    }

}

class CC {
    public static int age = 10;
//    private String name = "Tom";

    public static void getAge(){
        System.out.println(age);
    }
    static {
        System.out.println("CC的static代码块2在执行...");
    }
    {
        System.out.println("CC的非静态代码块别执行...");
    }
}

class Animal {

    static {
        System.out.println("Animal的static代码块4在执行...");
    }
}

class Cat extends Animal{

    public static int age = 20;
    static {
        System.out.println("Cat的static代码块3在执行...");
    }
}

class BB extends AA {
    static {
        System.out.println("BB的static代码块2在执行...");
    }
}

class AA {
    // 静态代码块,随着类的加载而执行
    static {
        System.out.println("AA的static代码块1在执行...");
    }
}

 

4）示例代码如下：

public class CodeBlockDetail01 {
    public static void main(String[] args) {
        A a = new A(100);

    }
}

class A {
    /*
    静态代码块和静态方法，先于普通代码块和普通方法执行。
    构造器最后被调用....
     */
    {
        System.out.println("非static代码块...");
    }
    public int id = getId();
    // 非静态代码块


    // 静态代码块
    static {
        System.out.println("static静态代码块...");
    }

    // 静态变量只能由静态方法赋初始值...
    public static int age = getAge();

    public static int getAge(){
        System.out.println("getAge()...");
        return 100;
    }

    public int getId(){
        System.out.println("getId()");
        return 50;
    }

    public A(int id) {
        System.out.println("public A(int id)调用...");
        this.id = id;
    }
}

运行结果：

 

 5）示例代码如下：

public class CodeBlockDetail02 {
    public static void main(String[] args) {
        BBB bbb = new BBB();
    }
}

/** 静态方法/变量/代码块，随着类信息的加载而加载。
 * (1) AAA的static代码块
 * (2) BBB的static代码块
 * (3) AAA的普通代码块....
 * (4) public AAA()构造器....
 * (5) BBB的非静态代码块....
 * (6) public BBB()构造器....
 */
class AAA {
    static {
        System.out.println("AAA的static代码块");
    }
    {
        System.out.println("AAA的普通代码块....");
    }
    public AAA(){
        // (1)super()调用父类的无参构造器
        // (2)本类的普通代码块
        System.out.println("public AAA()构造器....");
    }

}
class BBB extends AAA{
    static {
        System.out.println("BBB的static代码块");
    }
    {
        System.out.println("BBB的非静态代码块....");
    }
    public BBB() {
        // (1) super()，调用父类的无参构造器.
        // (2) 本类的普通代码块
        System.out.println("public BBB()构造器....");
    }
}

运行结果：

 

6）示例代码如下：

public class CodeBlockDetail03 {
    public static void main(String[] args) {
        Cc cc = new Cc();
    }
}

/**
 * (1) Aa的静态代码块
 * (2) Bb的静态代码块
 * (3) Cc的静态代码块
 * (4) Aa的非静态代码块
 * (5) public Aa()构造器
 * (6) Bb的非静态代码块
 * (7) public Bb()构造器
 * (8) Cc的非静态代码块
 * (9) public Cc()构造器
 */
class Aa {
    {
        System.out.println("Aa的非静态代码块");
    }
    static {
        System.out.println("Aa的静态代码块");
    }
    public Aa() {
        // (1) super()父类的构造器
        // (2) 本类的普通代码块
        System.out.println("public Aa()构造器");
    }

}
class Bb extends Aa{
    {
        System.out.println("Bb的非静态代码块");
    }
    static {
        System.out.println("Bb的静态代码块");
    }
    public Bb() {
        // (1) super()父类的构造器
        // (2) 本类的普通代码块
        System.out.println("public Bb()构造器");
    }

}
class Cc extends Bb{
    {
        System.out.println("Cc的非静态代码块");
    }
    static {
        System.out.println("Cc的静态代码块");
    }
    public Cc() {
        // (1) super()父类的构造器
        // (2) 本类的普通代码块
        System.out.println("public Cc()构造器");
    }

}

运行结果：

 

综合示例代码：【困难】

1 public class CodeBlockDetail03 {
  2     public static void main(String[] args) {
  3         /**
  4          * (1)加载类的信息,静态成员随着类的加载而执行
  5          * 1.1执行父类的静态方法，对静态成员变量赋值和静态代码块，【二者按照定义的顺序执行】
  6          * 1.2执行子类的静态方法，对静态成员变量赋值和静态代码块.
  7          * 1.3执行父类的非静态方法，对非静态变量赋值
  8          * 1.4执行子类的非静态方法，对非静态变量赋值，此时类加载完成.
  9          * (2)调用构造器，创建对象
 10          * 2.1默认第一行是super()，即调用父类的无参构造器
 11          * 2.2默认第二行是本类的普通代码块【非静态代码块】的执行
 12          *  Cc的构造器->Bb的构造器->Aa的构造器，
 13          *  先执行super(),调用父类构造器,接着调用本类的普通代码块
 14          */
 15 
 16         Cc cc = new Cc();
 17     }
 18 }
 19 
 20 /**
 21  * (1) Aa的public static int getVal()
 22  * (2) Aa的静态代码块
 23  * (3) Bb的public static int getVal()
 24  * (4) Bb的静态代码块
 25  * (5) Cc的public static int getVal()
 26  * (6) Cc的静态代码块
 27  * (7) Aa的public int getAid()
 28  * (8) Aa的非静态代码块
 29  * (9) public Aa()构造器
 30  * (10) Bb的public int getBid()
 31  * (11) Bb的非静态代码块
 32  * (12) public Bb()构造器
 33  * (13) Cc的public int getCid()
 34  * (14) Cc的非静态代码块
 35  * (15) public Cc()构造器
 36  */
 37 class Aa {
 38     /*
 39     静态成员只能调用静态成员(属性/方法)
 40     普通变量既能调用静态成员，又能调用非静态成员
 41      */
 42     public static int sa_id = getVal();
 43     public int aid = getAid();
 44     {
 45         System.out.println("Aa的非静态代码块");
 46     }
 47     static {
 48         System.out.println("Aa的静态代码块");
 49     }
 50     public Aa() {
 51         // (1) super()父类的构造器
 52         // (2) 本类的普通代码块
 53         System.out.println("public Aa()构造器");
 54     }
 55 
 56     public static int getVal(){
 57         System.out.println("Aa的public static int getVal()");
 58         return 1;
 59     }
 60 
 61     public int getAid(){
 62         System.out.println("Aa的public int getAid()");
 63         return 1;
 64     }
 65 
 66 }
 67 class Bb extends Aa{
 68     public static int sb_id = getVal();
 69     public int b_id = getBid();
 70 
 71     {
 72         System.out.println("Bb的非静态代码块");
 73     }
 74     static {
 75         System.out.println("Bb的静态代码块");
 76     }
 77     public Bb() {
 78         // (1) super()父类的构造器
 79         // (2) 本类的普通代码块
 80         System.out.println("public Bb()构造器");
 81     }
 82 
 83     public static int getVal(){
 84         System.out.println("Bb的public static int getVal()");
 85         return 10;
 86     }
 87 
 88     public int getBid(){
 89         System.out.println("Bb的public int getBid()");
 90         return 10;
 91     }
 92 
 93 }
 94 class Cc extends Bb{
 95     public static int sc_id = getVal();
 96     public int c_id = getCid();
 97     {
 98         System.out.println("Cc的非静态代码块");
 99     }
100     static {
101         System.out.println("Cc的静态代码块");
102     }
103     public Cc() {
104         // (1) super()父类的构造器
105         // (2) 本类的普通代码块
106         System.out.println("public Cc()构造器");
107     }
108 
109     public static int getVal(){
110         System.out.println("Cc的public static int getVal()");
111         return 100;
112     }
113 
114     public int getCid(){
115         System.out.println("Cc的public int getCid()");
116         return 100;
117     }
118 
119 }

 

运行结果：