Java 中的静态块

Mohammad Irfan 2023年1月30日 2022年5月1日

Java Java Static

Java 中的静态块示例
Java 6 中的静态块
Java 7 或更高版本中的静态块
Java 中的静态块和构造函数
Java 中的多个静态块

Java 在对象初始化之前使用静态块来执行代码。当我们用 static 关键字声明一个块时，我们称它为静态块。

它在 Java 中也称为静态初始化块或静态初始化块。当类加载到内存中时，静态块体内的代码会执行一次。

语法：

 static {
        //body of the staic block
    }

在 Java 中，静态块总是在 main 方法之前执行，因为它在类加载和对象创建之前存储在内存中。

Java 中的静态块示例

让我们通过这个例子来看看。在这里，我们创建了一个静态块来检查执行顺序。

静态块首先执行，甚至在 main() 方法之前。

// Java Static Block Example 
public class SimpleTesting {
    // creating static block
    static {
        System.out.println("This is static block");
    }
    public static void main(String[] args) {
        System.out.println("This is main method");
    }
}

输出：

This is static block
This is main method

这里，JVM 首先执行静态块，在静态块完全执行之后，它执行 main() 方法。

这里可能会出现一个问题：我们可以在不创建 main() 方法的情况下使用静态块吗？答案是肯定的。

我们可以做 JDK version 1.6 或以前的版本；否则，它将在运行时显示错误。

Java 6 中的静态块

在这里，我们创建了一个静态块，并且该类不包含 main() 方法。此代码执行良好并显示所需的结果。

public class SimpleTesting {
    static {
        System.out.println("This is static block");
    }
}

输出：

This is static block

Java 7 或更高版本中的静态块

如果我们在没有 main() 方法的类中声明静态块，则代码不会编译并向控制台抛出错误。

public class SimpleTesting {
    static {
        System.out.println("This is static block");
    }
}

输出：

Error: Main method not found in class Example_1, please define the main method as:
   public static void main(String[] args)
or a JavaFX application class must extend javafx.application.Application

让我们再看一个静态块的例子。

在这里，我们在另一个类中创建了一个静态块，并且在另一个类中声明了 main() 方法。

使用类名访问其变量时，代码执行得很好。请参见下面的示例。

class Sample {
    static int a;
    int b;
    // creating the static block
    static {
        a = 20;
        System.out.println("Static block");
    }
}
public class SimpleTesting {
    public static void main(String[] args) {
        // accessing a without creating an object
        System.out.println(Sample.a);
    }
}

输出：

Static block
20

Java 中的静态块和构造函数

请注意，静态块在构造函数之前执行。请参见下面的示例。

class Sample {
    static int a;
    int b;
    // creating the static block
    static {
        a = 20;
        System.out.println("I am static block");
    }
    // creating the constructor
    Sample() {
        System.out.println("I am constructor");
    }
}
public class SimpleTesting {
    public static void main(String[] args) {
        // creating the objects
        Sample obj1 = new Sample();
        Sample obj2 = new Sample();
    }
}

输出：

I am static block
I am constructor
I am constructor

如果我们创建 5 个对象，那么实例块会执行 10 次，但静态块的执行并不依赖于对象的创建。

它的执行取决于类的加载，我们知道，类只加载一次，因此静态块只会执行一次。

public class SimpleTesting {
    // Declaring two instance blocks.
    {
        System.out.println("This is instance block-1");
    }
    {
        System.out.println("This instance block-2");
    }
    // Declaring two static blocks.
    static {
        System.out.println("Static block-1");
    }
    static {
        System.out.println("Static block-2");
    }

    // Declaring zero parameter constructor.
    SimpleTesting() {
        System.out.println("0 argument constructor");
    }

    // Declaring one parameter constructor with int parameter named a.
    SimpleTesting(int a) {
        System.out.println("1 argument constructor");
    }

    public static void main(String[] args) {
        // Creating an object of class.
        new SimpleTesting(); // Nameless object.

        // Creating another object of class and passing an integer argument value.
        new SimpleTesting(20); // Nameless object.
    }
}

输出：

Static block-1
Static block-2
This is instance block-1
This instance block-2
0 argument constructor
This is instance block-1
This instance block-2
1 argument constructor

Java 中的多个静态块

Java 允许在一个类中创建任意数量的静态块。我们在一个类中创建了两个静态块，代码执行得很好。

public class SimpleTesting {
    static {
        System.out.println("I am static block - 1");
    }
    static {
        System.out.println("I am static block - 2");
    }

    public static void main(String[] args) {
        System.out.println("I am main method");
    }
}

输出：

I am static block - 1
I am static block - 2
I am main method

在下面的例子中，我们在一个类中定义了一个 method、constructor、instant block、static block。

查看执行顺序以了解 JVM 执行优先级。

public class SimpleTesting {
    int x = 10;
    static int y = 20;

    void fun1(int a) {
        System.out.println("This is instance method");
    }

    static void fun2(String str) {
        System.out.println("This is static method");
    }

    SimpleTesting() {
        System.out.println("0 argument constructor");
    }

    SimpleTesting(int a) {
        System.out.println("1 argument constructor");
    }

    {
        System.out.println("This is instance block");
    }
    static {
        System.out.println("This is static block");
    }

    public static void main(String[] args) {
        SimpleTesting at = new SimpleTesting();
        SimpleTesting at2 = new SimpleTesting(10);
        at.fun1(50);
        SimpleTesting.fun2("Name");
    }
}

输出：

This is static block
This is instance block
0 argument constructor
This is instance block
1 argument constructor
This is instance method
This is static method