Java 中初始化器与构造器的使用 [英] Use of Initializers vs Constructors in Java

问题描述

所以我最近一直在复习我的 Java 技能，并且发现了一些我以前不知道的功能.静态和实例初始化器就是两种这样的技术.

So I've been brushing up on my Java skills as of late and have found a few bits of functionality that I didn't know about previously. Static and Instance Initializers are two such techniques.

我的问题是什么时候会使用初始化程序而不是将代码包含在构造函数中?我已经想到了几个明显的可能性:

My question is when would one use an initializer instead of including the code in a constructor? I've thought of a couple obvious possibilities:

• 静态/实例初始化器可用于设置最终"静态/实例变量的值，而构造函数不能

• static/instance initializers can be used to set the value of "final" static/instance variables whereas a constructor cannot

静态初始化器可用于设置类中任何静态变量的值，这应该比在开始时使用if (someStaticVar == null)//do stuff"代码块更有效每个构造函数的

static initializers can be used to set the value of any static variables in a class, which should be more efficient than having an "if (someStaticVar == null) // do stuff" block of code at the start of each constructor

这两种情况都假设设置这些变量所需的代码比简单的var = value"更复杂，否则似乎没有任何理由使用初始化程序而不是在声明时简单地设置值变量.

Both of these cases assume that the code required to set these variables is more complex than simply "var = value", as otherwise there wouldn't seem to be any reason to use an initializer instead of simply setting the value when declaring the variable.

然而，虽然这些不是微不足道的收获(尤其是设置最终变量的能力)，但似乎应该使用初始化器的情况相当有限.

However, while these aren't trivial gains (especially the ability to set a final variable), it does seem that there are a rather limited number of situations in which an initializer should be used.

对于构造函数中所做的很多事情，当然可以使用初始化程序，但我真的不明白这样做的原因.即使一个类的所有构造函数都共享大量代码，对我来说，使用私有 initialize() 函数似乎比使用初始化器更有意义，因为它不会让你在编写新的代码时运行该代码构造函数.

One can certainly use an initializer for a lot of what is done in a constructor, but I don't really see the reason to do so. Even if all constructors for a class share a large amount of code, the use of a private initialize() function seems to make more sense to me than using an initializer because it doesn't lock you into having that code run when writing a new constructor.

我错过了什么吗?是否有一些其他情况应该使用初始化程序?或者它真的只是一个在非常特定情况下使用的相当有限的工具?

Am I missing something? Are there a number of other situations in which an initializer should be used? Or is it really just a rather limited tool to be used in very specific situations?

推荐答案

静态初始化器就像 cletus 提到的那样很有用，我以同样的方式使用它们.如果您有一个在类加载时要初始化的静态变量，那么静态初始化器是一种可行的方法，特别是因为它允许您进行复杂的初始化并且仍然使静态变量保持为 finalfinal代码>.这是一个巨大的胜利.

Static initializers are useful as cletus mentioned and I use them in the same manner. If you have a static variable that is to be initialized when the class is loaded, then a static initializer is the way to go, especially as it allows you to do a complex initialization and still have the static variable be final. This is a big win.

我发现if (someStaticVar == null)//do stuff"很混乱并且容易出错.如果它被静态初始化并声明为 final，那么你就避免了它是 null 的可能性.

I find "if (someStaticVar == null) // do stuff" to be messy and error prone. If it is initialized statically and declared final, then you avoid the possibility of it being null.

但是，当你说:

静态/实例初始化器可用于设置final"的值静态/实例变量而构造函数不能

static/instance initializers can be used to set the value of "final" static/instance variables whereas a constructor cannot

我假设您说的是两者:

• 静态初始化器可用于设置最终"静态变量的值，而构造函数则不能
• 实例初始值设定项可用于设置最终"实例变量的值，而构造函数则不能

你第一点是对的，第二点是错的.例如，您可以这样做:

and you are correct on the first point, wrong on the second. You can, for example, do this:

class MyClass {
    private final int counter;
    public MyClass(final int counter) {
        this.counter = counter;
    }
}

此外，当构造函数之间共享大量代码时，处理此问题的最佳方法之一是链接构造函数，提供默认值.这很清楚正在做什么:

Also, when a lot of code is shared between constructors, one of the best ways to handle this is to chain constructors, providing the default values. This makes is pretty clear what is being done:

class MyClass {
    private final int counter;
    public MyClass() {
        this(0);
    }
    public MyClass(final int counter) {
        this.counter = counter;
    }
}

这篇关于Java 中初始化器与构造器的使用的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！