Question

我想知道下面的代码是否有意义，因为编译器警告“空白的最终字段对象可能尚未初始化”。有没有更好的方法呢？

public abstract Test {
  protected final ArrayList<Object> objects;
}

public TestSubA extends Test {

  public TestSubA() {
    objects = new ArrayList<Objects>(20);
    // Other stuff
  }
}

public TestSubB extends Test {

  public TestSubB() {
    objects = new ArrayList<Objects>(100);
    // Other stuff
  }
}

Answer 1

我会让字段最终并强制构造函数传递值：

public abstract class Test {
  private final ArrayList<Object> objects;

  protected ArrayList<Object> getObjects() {
    return objects;
  }

  protected Test(ArrayList<Object> objects) {
    this.objects = objects;
  }
}

public class TestSubA extends Test {

  public TestSubA() {
    super(new ArrayList<Object>(20));
    // Other stuff
  }
}

public class TestSubB extends Test {

  public TestSubB() {
    super(new ArrayList<Object>(100));
    // Other stuff
  }
}

Answer 2

直接在子类的构造函数中初始化最终参数的问题是，您需要在一行中完成所有操作，因为super（）必须是构造函数的第一个语句。所以相反，我更喜欢使构造函数非公共，并创建一个像这样的静态构建方法：

public abstract class Test {
  protected final ArrayList<Object> objects;

  protected Test(ArrayList<Object> objects) {
    this.objects = objects;
  }
}

public class TestSubA extends Test {
  public static TestSubA build() {
    ArrayList<Object> objects = new ArrayList<Object>(20);
    objects.put(...);
    // Other stuff
    return new TestSubA(objects);
  }

  private TestSubA(ArrayList<Object> objects) {
    super(objects);
  }
}

Answer 3

在抽象类构造函数中实例化对象，并将差异传递给该构造函数。

Answer 4

一般来说，在基类中始终设置字段的构造函数可能更好，而不是没有设置它的默认构造函数。然后，子类可以使用super（value）

显式地在其构造函数的第一行传递参数

最终未初始化字段的抽象类

4 个答案: