什麼是實例初始器塊？

實例初始化塊在Java中用於在創建對象時運行初始化邏輯，其執行先於構造函數。它適用於多個構造函數共享初始化代碼、複雜字段初始化或匿名類初始化場景，與靜態初始化塊不同的是它每次實例化時都會執行，而靜態初始化塊僅在類加載時運行一次。

An instance initializer block in Java is a block of code that runs when an instance of a class is created — basically, every time you use the new keyword to create an object. It's used to set up initial state or perform logic before the constructor runs.

Here's how it looks:

 {
    // This is an instance initializer block
    System.out.println("Running instance initializer");
}

It can be useful when you have logic that needs to run regardless of which constructor gets called. Let's break down when and why you might use one.

When Does It Run?

The instance initializer runs right before the constructor body executes. If your class has multiple constructors, this block will run before any of them are called.

For example:

 public class Example {
    {
        System.out.println("Init block");
    }

    public Example() {
        System.out.println("Constructor");
    }
}

When you do new Example() , you'll see:

 Init block
Constructor

This behavior helps avoid repeating initialization code across multiple constructors.

Why Use an Instance Initializer?

There are a few practical reasons to use one:

• You want to share setup code between multiple constructors.
• You need to initialize instance variables in a way that involves more than just a simple assignment.
• You're initializing anonymous classes (in that case, they're often used because there's no explicit constructor).

One common use is initializing collections:

 List<String> names = new ArrayList<>();
{
    names.add("Alice");
    names.add("Bob");
}

This avoids having to do all the adds inside a constructor or a separate method.

How Is It Different from Static Initializers?

There's also something called a static initializer , which looks like this:

 static {
    System.out.println("Static init block");
}

That only runs once — when the class is loaded into memory, not when you create an instance. So static blocks are for setting up static fields or doing one-time class-level setup.

Instance initializers, on the other hand, run every time an object is made.

So, instance initializers aren't something you'll use every day, but they come in handy when you have shared logic across constructors or complex field initialization. They're especially helpful in older Java versions where you might not have had features like constructor chaining as cleanly.

基本上就這些。

以上是什麼是實例初始器塊？的詳細內容。更多資訊請關注PHP中文網其他相關文章！