class MyClass extends FooClass {
    String a = null;

    public MyClass() {
        super();     // Superclass calls init();
    }

    @Override
    protected void init() {
        super.init();
        if (something)
            a = getStringYadaYada();
    }
}

关于以上，

String a = null;

Null init可以避免，因为它是默认值。 然而，如果您需要另一个默认值， 然后，由于初始化顺序不受控制， 我将修改如下:

class MyClass extends FooClass 
{
    String a;
    {
        if( a==null ) a="my custom default value";
    }
    ...

例2不太灵活。如果您添加了另一个构造函数，则需要记住在该构造函数中实例化字段。直接实例化字段，或者在getter中引入延迟加载。

如果实例化需要的不仅仅是一个简单的new，请使用初始化块。不管使用的构造函数是什么，这个函数都将运行。如。

public class A {
    private Properties properties;

    {
        try {
            properties = new Properties();
            properties.load(Thread.currentThread().getContextClassLoader().getResourceAsStream("file.properties"));
        } catch (IOException e) {
            throw new ConfigurationException("Failed to load properties file.", e); // It's a subclass of RuntimeException.
        }
    }

    // ...

}

我在回复中没有看到以下内容:

在声明时进行初始化的一个可能的优势可能是，在当今的IDE中，您可以非常容易地跳转到变量的声明(大多数情况下) Ctrl-<hover_over_the_variable>-<left_mouse_click>)在你的代码中的任何地方。然后立即看到该变量的值。否则，你必须“搜索”初始化完成的位置(主要是:构造函数)。

这个优势当然是次要的，所有其他逻辑推理，但对一些人来说，“特征”可能更重要。

我个人的“原则”(几乎从未被打破)是:

的开头声明所有变量 一块 使所有变量为final，除非它们 不能 每行声明一个变量 永远不要在某处初始化变量 宣布 只初始化a中的东西 构造函数时使用 的构造函数 初始化

我的代码是这样的:

public class X
{
    public static final int USED_AS_A_CASE_LABEL = 1; // only exception - the compiler makes me
    private static final int A;
    private final int b;
    private int c;

    static 
    { 
        A = 42; 
    }

    {
        b = 7;
    }

    public X(final int val)
    {
        c = val;
    }

    public void foo(final boolean f)
    {
        final int d;
        final int e;

        d = 7;

        // I will eat my own eyes before using ?: - personal taste.
        if(f)
        {
            e = 1;
        }
        else
        {
            e = 2;
        }
    }
}

This way I am always 100% certain where to look for variables declarations (at the start of a block), and their assignments (as soon as it makes sense after the declaration). This winds up potentially being more efficient as well since you never initialize a variable with a value that is not used (for example declare and init vars and then throw an exception before half of those vars needed to have a value). You also do not wind up doing pointless initialization (like int i = 0; and then later on, before "i" is used, do i = 5;.

我非常重视一致性，所以遵循这个“规则”是我一直在做的事情，它使处理代码变得更容易，因为你不需要到处寻找东西。

你的里程可能会有所不同。

使用依赖注入或延迟初始化总是更可取的，已经在其他回答中详细解释过了。

当你不想或不能使用这些模式时，对于基元数据类型，有三个令人信服的原因，我可以想到为什么最好在构造函数之外初始化类属性:

避免重复=如果你有多个构造函数，或者当你需要添加更多构造函数时，你将不必在所有构造函数体中重复初始化; 改进的可读性=你可以很容易地从类外部判断哪些变量需要初始化; 减少代码行数=在声明时每执行一次初始化，构造函数中就会减少一行。

我今天以一种有趣的方式被烧伤了:

class MyClass extends FooClass {
    String a = null;

    public MyClass() {
        super();     // Superclass calls init();
    }

    @Override
    protected void init() {
        super.init();
        if (something)
            a = getStringYadaYada();
    }
}

看到错误了吗?结果是，在父类构造函数被调用之后才调用a = null初始化式。由于超类构造函数调用init()， a的初始化之后是a = null初始化。