选择何时实例化类

Question

我最近为一个赋值编写了一个类，我必须在ArrayList中存储名称（在java中）。 我将ArrayList初始化为实例变量private ArrayList<String> names 。 后来当我根据解决方案检查我的工作时，我注意到他们已经在run()方法中初始化了他们的ArrayList。

我考虑过这一点，我觉得这可能是一个品味问题，但总的来说，在这样的情况下如何选择？ 是否会占用更少的内存或什么？

PS我喜欢Ruby中以@符号开头的实例变量：它们更可爱。

（元问题：对于这个问题，什么是更好的标题？）

Answer 1

用伟大的Knuth的话来说“过早的优化是万恶之源”。

只是担心您的程序正常运行并且没有错误。 这比稍后难以调试的模糊优化要重要得多。

但是要回答你的问题 - 如果你在类成员中初始化，内存将在第一次在代码中提到你的类时被分配（即当你从它调用一个方法时）。 如果在方法中初始化，则在调用此特定方法时，将在稍后进行内存分配。

所以这只是后来初始化的问题......这在业界被称为延迟初始化。

Answer 2

初始化

根据经验，尝试在声明变量时初始化变量。

如果变量的值永远不会改变，请使用final关键字使其明确。 这有助于您推断代码的正确性，虽然我不知道识别final关键字的编译器或JVM优化，但它们肯定是可能的。

当然，这条规则也有例外。 例如，可以在if-else或switch中分配变量。 在这样的情况下，“空白”声明（没有初始化的声明）优于在读取虚拟值之前保证被覆盖的初始化。

/* DON'T DO THIS! */
Color color = null;
switch(colorCode) {
  case RED: color = new Color("crimson"); break;
  case GREEN: color = new Color("lime"); break;
  case BLUE: color = new Color("azure"); break;
}
color.fill(widget);

现在，如果出现无法识别的颜色代码，则会出现NullPointerException 。 最好不要分配无意义的null 。 编译器会在color.fill()调用时产生错误，因为它会检测到您可能没有初始化color 。

为了在这种情况下回答你的问题，我必须看到有问题的代码。 如果解决方案在run()方法中初始化它，它必须用作临时存储，或者作为“返回”任务结果的方式。

如果集合用作临时存储，并且不能在方法之外访问，则应将其声明为局部变量，而不是实例变量，并且很可能应该在方法中声明它的位置进行初始化。

并发问题

对于一个开始的编程课程，你的教师可能并没有试图用并发编程的复杂性来面对你 - 尽管如果是这样的话，我不确定你为什么使用Thread 。 但是，根据CPU设计的当前趋势，任何正在学习编程的人都需要牢牢掌握并发性。 我会尝试在这里深入研究一下。

从线程的run方法返回结果有点棘手。 这个方法是Runnable接口，没有什么能阻止多个线程执行单个实例的run方法。 由此产生的并发问题是Java 5中引入的Callable接口背后的动机的一部分。它与Runnable非常相似，但可以以线程安全的方式返回结果，如果无法执行任务则抛出Exception 。

这有点偏离，但如果你很好奇，请考虑以下示例：

class Oops extends Thread { /* Note that thread implements "Runnable" */

  private int counter = 0;

  private Collection<Integer> state = ...;

  public void run() {
    state.add(counter);
    counter++;
  }

  public static void main(String... argv) throws Exception {
    Oops oops = new Oops();
    oops.start();
    Thread t2 = new Thread(oops); /* Now pass the same Runnable to a new Thread. */
    t2.start(); /* Execute the "run" method of the same instance again. */
    ...
  }
}

在main方法结束时，你几乎不知道Collection的“状态”是什么。 两个线程同时处理它，我们还没有指定集合是否可以安全地并发使用。 如果我们在线程内初始化它，至少我们可以说最终， state将包含一个元素，但我们不能说它是0还是1。

Answer 3

来自wikibooks ：

Java中的变量有三种基本的范围：

• 在类的方法中声明的局部变量，对方法执行的时间有效（并仅占用存储）。 每次调用该方法时，都会使用该变量的新副本。

• 实例变量，在类中声明但在任何方法之外。 只要相应的对象在内存中，它就有效并占用存储空间; 程序可以实例化该类的多个对象，并且每个对象都获得其自己的所有实例变量的副本。 这是面向对象编程的基本数据结构规则; 类被定义为保存特定于给定系统中的“对象类”的数据，并且每个实例保存其自己的数据。

• 静态变量，在类中声明为static，在任何方法之外。 无论从该类实例化多少个对象，这种变量只有一个副本。

所以是的，内存消耗是一个问题，特别是如果run（）内的ArrayList是本地的。

Answer 4

我并不完全理解你的完整问题。

但就我现在所理解的而言，性能/内存的好处将相当小。 因此，我绝对赞成易用性方面。

所以最适合你的是什么。 仅在需要时解决性能/内存优化问题。

Answer 5

我个人的经验法则是对它们进行初始化，至少使用默认值：

1. 在退火时，即

   private ArrayList<String> myStrings = new ArrayList<String>();

2. 在构造函数中

如果它确实是一个实例变量，并表示对象的状态，那么它会在构造函数退出时完全初始化。 否则，您可以尝试在变量具有值之前尝试访问该变量。 当然，这不适用于您将自动获得默认值的基元。

对于静态（类级别）变量，请在声明或静态初始化程序中初始化它们。 如果我做计算或其他工作来获取值，我使用静态初始化程序。 如果您只是调用new Foo()或将变量设置为已知值，请在声明中初始化。

Answer 6

您必须避免Lazy初始化。 它会在以后导致问题。
但是如果你必须这样做，因为初始化太重了，你必须这样做：

静态字段：

// Lazy initialization holder class idiom for static fields
private static class FieldHolder {
   static final FieldType field = computeFieldValue();
}
static FieldType getField() { return FieldHolder.field; }

实例字段：

// Double-check idiom for lazy initialization of instance fields
private volatile FieldType field;
FieldType getField() {
   FieldType result = field;
   if (result == null) { // First check (no locking)
      synchronized(this) {
         result = field;
         if (result == null) // Second check (with locking)
            field = result = computeFieldValue();
      }
   }
   return result;
}

根据Joshua Bolch的书“Effective Java™Second Edition”（ISBN-13：978-0-321-35668-0）：
“明智地使用延迟初始化”