代码块

1364字约5分钟

2025-09-23

代码块的使用细节

无论我们调用那个构造器，都会优先调用方法块中的属性，然后在调用你调用的那个构造器
代码块就相当于是另一种形式的构造器（也就是对构造器的补充），可以做到初始化的作用

按理说每创建一个相同对象的时候都会执行一次代码块，但是静态代码块比较特殊，当静态代码块被执行过一次之后，那么下次在创建对象的时候就不会在继续执行该态代码块了

public class staticClass {
    public static void main(String[] args) {
//        这里创建了两个 A 类的对象
//        当一个类中有一个静态代码块和一个普通代码块时，则会优先执行静态代码块
//        但是静态代码块只被执行了一次
//        而普通代码块则被执行了两次
        new A();
        new A();
    }
}

class A {
    {
        System.out.println("A类普通代码块被执行。。。");
    }
    static {
        System.out.println("A类静态代码块被执行。。。");
    }
}

// 运行结果
A类静态代码块被执行。。。
A类普通代码块被执行。。。
A类普通代码块被执行。。。

因为当我们调用子类时，则会优先调用子类中的构造器，而构造器中又默认的有 super 关键字，所以调用子类的构造器时则会优先调用父类中的构造器，在调用构造器之前会优先调用代码块，所以当我们调用子类时则会优先调用父类中的代码块，其次在调用父类中的构造器，然后在调用子类中的代码块，最后在调用子类中的构造器，这样以此类推

调用静态成员（静态方法和静态变量）时，普通代码块不会被调用，但是静态代码块会被调用

public class staticClass {
    public static void main(String[] args) {
        A.info();
    }
}

class A {
    public static void info() {
        System.out.println("info被调用。。。");
    }
    static {
        System.out.println("静态代码块被调用。。。");
    }
    {
        System.out.println("普通代码块被调用。。。");
    }
}

// 运行结果
静态代码块被调用。。。
info被调用。。。

如果调用的是普通成员，那么静态成员和普通成员都会被调用，因为调用普通成员首先要创建对象，而创建对象则会调用静态成员

public class staticClass {
    public static void main(String[] args) {
        System.out.println("a = " + new A().a);
    }
}

class A {
    int a;
    static {
        System.out.println("静态代码块被调用");
    }
    {
        a = 10;
        System.out.println("普通代码块");
    }
    public A() {
//        在运行构造器之前会先调用普通代码块
        System.out.println("都创建对象了，构造器怎么可能不会被调用?");
    }
}

// 运行结果
静态代码块被调用
普通代码块
都创建对象了，构造器怎么可能不会被调用
a = 10

静态代码块和静态属性是同一级的，普通代码块和普通属性也是同一级的
静态的优先级要高于普通的优先级
在一个类中，有一个普通代码块和一个普通属性，因为它们的运行优先级是一样的，所以运行的顺序就是从上往下运行，静态的也是一样的
运行顺序就是在一个类中先从上往下运行静态代码（静态代码块和静态属性初始化），然后在从上往下运行普通代码（普通代码块和普通属性初始化），最后在运行构造器
调用构造器时会优先调用 super(); 调用完之后在执行普通代码块
静态代码块只能调用静态的方法和属性，普通代码块则可以调用任意的方法和属性
在继承中，先调用父类中的静态代码，在调用子类中的静态代码；然后在调用父类中的普通代码（普通代码块、普通属性初始化），在调用父类中的构造器；最后在调用子类中的普通代码块（普通代码块、普通属性初始化），在调用子类中的构造器；在同级的代码中则是按从上往下的顺序运行

public class staticClass {
 public static void main(String[] args) {
     B b = new B();
 }
}

class A {
 int a = Return();
 public int Return() {
     System.out.println("父类的普通方法被调用");
     return 10;
 }
 {
     System.out.println("父类中的普通代码块被调用");
 }
 static {
     System.out.println("父类中的静态代码块被调用");
 }
 public A() {
     // super();
     // 调用普通代码块
     System.out.println("父类中的构造器被调用");
 }
}

class B extends A {
 int a = Return1();
 public int Return1() {
     System.out.println("子类的普通方法被调用");
     return 20;
 }
 {
     System.out.println("子类中的普通代码块被调用");
 }
 static {
     System.out.println("子类中的静态代码块被调用");
 }
 public B() {
     System.out.println("子类中的构造器被调用");
 }
}

// 运行结果
父类中的静态代码块被调用
子类中的静态代码块被调用
父类的普通方法被调用
父类中的普通代码块被调用
父类中的构造器被调用
子类的普通方法被调用
子类中的构造器被调用