Java 什么是初始化块？

我们可以将代码放入构造函数、方法或初始化块中。初始化块的用途是什么？每个java程序都必须有它吗

初始化块在初始化类时和调用构造函数之前执行。它们通常放置在大括号中的构造函数上方。在你的课堂上根本没有必要把它们包括在内

---

它们通常用于初始化引用变量。这提供了一个很好的解释

初始化块在初始化类时和调用构造函数之前执行。它们通常放置在大括号中的构造函数上方。在你的课堂上根本没有必要把它们包括在内

---

它们通常用于初始化引用变量。这是一个很好的解释

这个问题并不完全清楚，但这里简要介绍了初始化对象中数据的方法。假设您有一个类a，它包含一个对象列表

1） 在字段声明中输入初始值：

class A {
    private List<Object> data = new ArrayList<Object>();
}

A类{
私有列表数据=新的ArrayList（）；
}

2） 在构造函数中指定初始值：

class A {
    private List<Object> data;
    public A() {
        data = new ArrayList<Object>();
    }
}

A类{
私人名单数据；
公共A（）{
数据=新的ArrayList（）；
}
}

这两种方法都假定您不希望将“数据”作为构造函数参数传递

如果将重载构造函数与上述内部数据混合使用，事情会变得有点棘手。考虑：

class B {
    private List<Object> data;
    private String name;
    private String userFriendlyName;

    public B() {
        data = new ArrayList<Object>();
        name = "Default name";
        userFriendlyName = "Default user friendly name";
    }

    public B(String name) {
        data = new ArrayList<Object>();
        this.name = name;
        userFriendlyName = name;
    }

    public B(String name, String userFriendlyName) {
        data = new ArrayList<Object>();
        this.name = name;
        this.userFriendlyName = userFriendlyName;
    }
}

B类{
私人名单数据；
私有字符串名称；
私有字符串userFriendlyName；
公共图书馆B（）{
数据=新的ArrayList（）；
name=“默认名称”；
userFriendlyName=“默认用户友好名称”；
}
公共B（字符串名称）{
数据=新的ArrayList（）；
this.name=名称；
userFriendlyName=名称；
}
公共B（字符串名称、字符串userFriendlyName）{
数据=新的ArrayList（）；
this.name=名称；
this.userFriendlyName=userFriendlyName；
}
}

请注意，有很多重复的代码。您可以通过使构造函数相互调用来解决此问题，也可以使用每个构造函数调用的私有初始化方法：

class B {
    private List<Object> data;
    private String name;
    private String userFriendlyName;

    public B() {
        this("Default name", "Default user friendly name");
    }

    public B(String name) {
        this(name, name);
    }

    public B(String name, String userFriendlyName) {
        data = new ArrayList<Object>();
        this.name = name;
        this.userFriendlyName = userFriendlyName;
    }
}

B类{
私人名单数据；
私有字符串名称；
私有字符串userFriendlyName；
公共图书馆B（）{
此（“默认名称”、“默认用户友好名称”）；
}
公共B（字符串名称）{
这个(名字,名字),；
}
公共B（字符串名称、字符串userFriendlyName）{
数据=新的ArrayList（）；
this.name=名称；
this.userFriendlyName=userFriendlyName；
}
}

或

B类{
私人名单数据；
私有字符串名称；
私有字符串userFriendlyName；
公共图书馆B（）{
init（“默认名称”、“默认用户友好名称”）；
}
公共B（字符串名称）{
init（名称、名称）；
}
公共B（字符串名称、字符串userFriendlyName）{
init（名称，userFriendlyName）；
}
私有void init（字符串_name，字符串_userFriendlyName）{
数据=新的ArrayList（）；
this.name=名称；
this.userFriendlyName=userFriendlyName；
}
}

这两者（或多或少）是等价的

我希望这能为您提供一些关于如何初始化对象中的数据的提示。我不会谈论静态初始化块，因为目前这可能有点高级

---

编辑：我将您的问题解释为“如何初始化我的实例变量”，而不是“初始化程序块如何工作”，因为初始化程序块是一个相对高级的概念，从问题的语气来看，您似乎在询问更简单的概念。我可能错了。

这个问题并不完全清楚，但这里简要介绍了初始化对象中数据的方法。假设您有一个类a，它包含一个对象列表

1） 在字段声明中输入初始值：

class A {
    private List<Object> data = new ArrayList<Object>();
}

A类{
私有列表数据=新的ArrayList（）；
}

2） 在构造函数中指定初始值：

class A {
    private List<Object> data;
    public A() {
        data = new ArrayList<Object>();
    }
}

A类{
私人名单数据；
公共A（）{
数据=新的ArrayList（）；
}
}

这两种方法都假定您不希望将“数据”作为构造函数参数传递

如果将重载构造函数与上述内部数据混合使用，事情会变得有点棘手。考虑：

class B {
    private List<Object> data;
    private String name;
    private String userFriendlyName;

    public B() {
        data = new ArrayList<Object>();
        name = "Default name";
        userFriendlyName = "Default user friendly name";
    }

    public B(String name) {
        data = new ArrayList<Object>();
        this.name = name;
        userFriendlyName = name;
    }

    public B(String name, String userFriendlyName) {
        data = new ArrayList<Object>();
        this.name = name;
        this.userFriendlyName = userFriendlyName;
    }
}

B类{
私人名单数据；
私有字符串名称；
私有字符串userFriendlyName；
公共图书馆B（）{
数据=新的ArrayList（）；
name=“默认名称”；
userFriendlyName=“默认用户友好名称”；
}
公共B（字符串名称）{
数据=新的ArrayList（）；
this.name=名称；
userFriendlyName=名称；
}
公共B（字符串名称、字符串userFriendlyName）{
数据=新的ArrayList（）；
this.name=名称；
this.userFriendlyName=userFriendlyName；
}
}

请注意，有很多重复的代码。您可以通过使构造函数相互调用来解决此问题，也可以使用每个构造函数调用的私有初始化方法：

class B {
    private List<Object> data;
    private String name;
    private String userFriendlyName;

    public B() {
        this("Default name", "Default user friendly name");
    }

    public B(String name) {
        this(name, name);
    }

    public B(String name, String userFriendlyName) {
        data = new ArrayList<Object>();
        this.name = name;
        this.userFriendlyName = userFriendlyName;
    }
}

B类{
私人名单数据；
私有字符串名称；
私有字符串userFriendlyName；
公共图书馆B（）{
此（“默认名称”、“默认用户友好名称”）；
}
公共B（字符串名称）{
这个(名字,名字),；
}
公共B（字符串名称、字符串userFriendlyName）{
数据=新的ArrayList（）；
this.name=名称；
this.userFriendlyName=userFriendlyName；
}
}

或

B类{
私人名单数据；
私有字符串名称；
私有字符串userFriendlyName；
公共图书馆B（）{
init（“默认名称”、“默认用户友好名称”）；
}
公共B（字符串名称）{
init（名称、名称）；
}
公共B（字符串名称、字符串userFriendlyName）{
init（名称，userFriendlyName）；
}
私有void init（字符串_name，字符串_userFriendlyName）{
数据=新的ArrayList（）；
public class StaticTest extends parent {
    static {
        System.out.println("inside satic block");
    }

    StaticTest() {
        System.out.println("inside constructor of child");
    }

    {
        System.out.println("inside initialization block");
    }

    public static void main(String[] args) {
        new StaticTest();
        new StaticTest();
        System.out.println("inside main");
    }
}

class parent {
    static {
        System.out.println("inside parent Static block");
    }
    {
        System.out.println("inside parent initialisation block");
    }

    parent() {
        System.out.println("inside parent constructor");
    }
}

inside parent Static block
inside satic block
inside parent initialisation block
inside parent constructor
inside initialization block
inside constructor of child
inside parent initialisation block
inside parent constructor
inside initialization block
inside constructor of child
inside main

public class StaticInitializationBlock {

    static int staticVariable;
    int instanceVariable;

    // Static Initialization Block
    static { 
        System.out.println("Static block");
        staticVariable = 5;

    }

    // Instance Initialization Block
    { 

        instanceVariable = 7;
        System.out.println("Instance Block");
        System.out.println(staticVariable);
        System.out.println(instanceVariable);

        staticVariable = 10;
    }


    public StaticInitializationBlock() { 

        System.out.println("Constructor");
    }

    public static void main(String[] args) {
        new StaticInitializationBlock();
        new StaticInitializationBlock();
    }

}

Static block
Instance Block
5
7
Constructor
Instance Block
10
7
Constructor

abstract class Aircraft {

    protected Integer seatCapacity;

    {   // Initial block 1, Before Constructor
        System.out.println("Executing: Initial Block 1");
    }

    Aircraft() {
        System.out.println("Executing: Aircraft constructor");
    }

    {   // Initial block 2, After Constructor
        System.out.println("Executing: Initial Block 2");
    }

}

class SupersonicAircraft extends Aircraft {

    {   // Initial block 3, Internalizing a instance variable
        seatCapacity = 300;
        System.out.println("Executing: Initial Block 3");
    }

    {   // Initial block 4
        System.out.println("Executing: Initial Block 4");
    }

    SupersonicAircraft() {
        System.out.println("Executing: SupersonicAircraft constructor");
    }
}

Executing: Initial Block 1
Executing: Initial Block 2
Executing: Aircraft constructor
Executing: Initial Block 3
Executing: Initial Block 4
Executing: SupersonicAircraft constructor
Seat Capacity - 300