例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.
        }
    }

    // ...

}

There is one more subtle reason to initialize outside the constructor that no one has mentioned before (very specific I must say). If you are using UML tools to generate class diagrams from the code (reverse engineering), most of the tools I believe will note the initialization of Example 1 and will transfer it to a diagram (if you prefer it to show the initial values, like I do). They will not take these initial values from Example 2. Again, this is a very specific reason - if you are working with UML tools, but once I learned that, I am trying to take all my default values outside of constructor unless, as was mentioned before, there is an issue of possible exception throwing or complicated logic.

另一种选择是使用依赖注入。

class A{
   B b;

   A(B b) {
      this.b = b;
   }
}

This removes the responsibility of creating the B object from the constructor of A. This will make your code more testable and easier to maintain in the long run. The idea is to reduce the coupling between the two classes A and B. A benefit that this gives you is that you can now pass any object that extends B (or implements B if it is an interface) to A's constructor and it will work. One disadvantage is that you give up encapsulation of the B object, so it is exposed to the caller of the A constructor. You'll have to consider if the benefits are worth this trade-off, but in many cases they are.

没有区别——实例变量初始化实际上是由编译器放在构造函数中。 第一个变体可读性更强。 你不能对第一个变体进行异常处理。 另外还有初始化块，它也由编译器放在构造函数中: { a =新a (); ｝

检查孙的解释和建议

在本教程中:

但是，字段声明不是任何方法的一部分，因此它们不能像语句那样被执行。相反，Java编译器自动生成实例字段初始化代码，并将其放入类的构造函数中。初始化代码按照在源代码中出现的顺序插入构造函数，这意味着字段初始化器可以使用在它之前声明的字段的初始值。

此外，您可能希望惰性地初始化字段。如果初始化字段是一个昂贵的操作，你可以在需要的时候立即初始化它:

ExpensiveObject o;

public ExpensiveObject getExpensiveObject() {
    if (o == null) {
        o = new ExpensiveObject();
    }
    return o;
}

最后(正如Bill所指出的)，为了依赖管理，最好避免在类中的任何地方使用new操作符。相反，使用依赖注入更可取——即让其他人(另一个类/框架)实例化并注入你的类中的依赖项。

例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.
        }
    }

    // ...

}

第二种选择更可取，因为它允许在ctors中使用不同的逻辑进行类实例化，并使用ctors链接。如。

class A {
    int b;

    // secondary ctor
    A(String b) {
         this(Integer.valueOf(b));
    }

    // primary ctor
    A(int b) {
         this.b = b;
    }
}

所以第二种选择更加灵活。