在我读梁书的时候，我陷入了困境，我不明白发生了什么。错误的原因是MyArrayList类的构造函数。作者警告我们不要称超级（对象），但他们没有解释原因。现在，当我尝试运行代码时，作者是对的 - 当我们调用super（object）时，我得到一个错误。这个错误的原因是什么？
MyArrayList.java
public class MyArrayList<E> extends MyAbstractList<E> {
public static final int INITIAL_CAPACITY = 16;
private E[] data = (E[])new Object[INITIAL_CAPACITY];
/** Create a default list */
public MyArrayList() {
}
/** Create a list from an array of objects */
public MyArrayList(E[] objects) {
/*for (int i = 0; i < objects.length; i++)
add(objects[i]); // Warning: don't use super(objects)! */
super(objects); //!!! AUTHOR WARNS US ABOUT NOT INVOKING THIS LINE !!!
}
/** Add a new element at the specified index in this list */
public void add(int index, E e) {
ensureCapacity();
// Move the elements to the right after the specified index
for (int i = size - 1; i >= index; i--)
data[i + 1] = data[i];
// Insert new element to data[index]
data[index] = e;
// Increase size by 1
size++;
}
/** Create a new larger array, double the current size */
private void ensureCapacity() {
if (size >= data.length) {
E[] newData = (E[])(new Object[size * 2 + 1]);
System.arraycopy(data, 0, newData, 0, size);
data = newData;
}
}
/** Clear the list */
public void clear() {
data = (E[])new Object[INITIAL_CAPACITY];
size = 0;
}
/** Return true if this list contains the element */
public boolean contains(E e) {
for (int i = 0; i < size; i++)
if (e.equals(data[i])) return true;
return false;
}
/** Return the element from this list at the specified index */
public E get(int index) {
return data[index];
}
/** Return the index of the first matching element in this list.
* Return -1 if no match. */
public int indexOf(E e) {
for (int i = 0; i < size; i++)
if (e.equals(data[i])) return i;
return -1;
}
/** Return the index of the last matching element in this list
* Return -1 if no match. */
public int lastIndexOf(E e) {
for (int i = size - 1; i >= 0; i--)
if (e.equals(data[i])) return i;
return -1;
}
/** Remove the element at the specified position in this list
* Shift any subsequent elements to the left.
* Return the element that was removed from the list. */
public E remove(int index) {
E e = data[index];
// Shift data to the left
for (int j = index; j < size - 1; j++)
data[j] = data[j + 1];
data[size - 1] = null; // This element is now null
// Decrement size
size--;
return e;
}
/** Replace the element at the specified position in this list
* with the specified element. */
public E set(int index, E e) {
E old = data[index];
data[index] = e;
return old;
}
/** Override toString() to return elements in the list */
public String toString() {
StringBuilder result = new StringBuilder("[");
for (int i = 0; i < size; i++) {
result.append(data[i]);
if (i < size - 1) result.append(", ");
}
return result.toString() + "]";
}
/** Trims the capacity to current size */
public void trimToSize() {
if (size != data.length) { // If size == capacity, no need to trim
E[] newData = (E[])(new Object[size]);
System.arraycopy(data, 0, newData, 0, size);
data = newData;
}
}
}
MyList.java
public interface MyList<E> {
/** Add a new element at the end of this list */
public void add(E e);
/** Add a new element at the specified index in this list */
public void add(int index, E e);
/** Clear the list */
public void clear();
/** Return true if this list contains the element */
public boolean contains(E e);
/** Return the element from this list at the specified index */
public E get(int index);
/** Return the index of the first matching element in this list.
* Return -1 if no match. */
public int indexOf(E e);
/** Return true if this list contains no elements */
public boolean isEmpty();
/** Return the index of the last matching element in this list
* Return -1 if no match. */
public int lastIndexOf(E e);
/** Remove the first occurrence of the element o from this list.
* Shift any subsequent elements to the left.
* Return true if the element is removed. */
public boolean remove(E e);
/** Remove the element at the specified position in this list
* Shift any subsequent elements to the left.
* Return the element that was removed from the list. */
public E remove(int index);
/** Replace the element at the specified position in this list
* with the specified element and returns the new set. */
public Object set(int index, E e);
/** Return the number of elements in this list */
public int size();
}
MyAbstractList.java
public abstract class MyAbstractList<E> implements MyList<E> {
protected int size = 0; // The size of the list
/** Create a default list */
protected MyAbstractList() {
}
/** Create a list from an array of objects */
protected MyAbstractList(E[] objects) {
for (int i = 0; i < objects.length; i++)
add(objects[i]);
}
/** Add a new element at the end of this list */
public void add(E e) {
add(size, e);
}
/** Return true if this list contains no elements */
public boolean isEmpty() {
return size == 0;
}
/** Return the number of elements in this list */
public int size() {
return size;
}
/** Remove the first occurrence of the element o from this list.
* Shift any subsequent elements to the left.
* Return true if the element is removed. */
public boolean remove(E e) {
if (indexOf(e) >= 0) {
remove(indexOf(e));
return true;
}
else
return false;
}
}
TestMyArrayList.java
public class TestMyArrayList {
public static void main(String[] args)
{
String[] str = {"manisa","turkey","germany"};
MyList<String> list = new MyArrayList<String>(str);
list.add("America");
list.add(0,"Canada");
list.add(1,"England");
System.out.println(list);
}
}
以下是错误代码：
Exception in thread "main" java.lang.NullPointerException
at MyArrayList.ensureCapacity(MyArrayList.java:36)
at MyArrayList.add(MyArrayList.java:21)
at MyAbstractList.add(MyAbstractList.java:16)
at MyAbstractList.<init>(MyAbstractList.java:11)
at MyArrayList.<init>(MyArrayList.java:16)
at TestMyArrayList.main(TestMyArrayList.java:8)
答案 0 :(得分：3)
这里的问题是MyAbstractList中的构造函数在add初始化之前正在调用data。
在data类中声明并初始化MyArrayList字段。但是，在超类初始化完成之后，初始化才会发生，并且在超类初始化期间进行add调用... data仍然是null {1}}。
这里的一般问题是构造函数调用可能被子类覆盖的方法是危险的。在子类初始化发生之前，可能会调用override方法。
在这种情况下，add(E)可以被覆盖。更糟糕的是，add(E)调用add(E, int)，它肯定会被覆盖，因为它在超类中是抽象的。
答案 1 :(得分：3)
让我们将代码简化为基本要素：
public abstract class MyAbstractList<E> {
protected int size = 0; // The size of the list
protected MyAbstractList() {}
protected MyAbstractList(E[] objects) {
for (int i = 0; i < objects.length; i++)
add(objects[i]);
}
public class MyArrayList<E> extends MyAbstractList<E> {
public static final int INITIAL_CAPACITY = 16;
private E[] data = (E[])new Object[INITIAL_CAPACITY];
public MyArrayList(E[] objects) {
super(objects); // this call to super() executes before data is initialized
}
}
public static void main(String[] args) {
String[] str = {"manisa","turkey","germany"};
MyList<String> list = new MyArrayList<String>(str);
}
要理解的重要一点是父母班级＆＃39;在子类被初始化之前调用构造函数（这就是为什么super()必须始终是构造函数中的第一个调用），这意味着当MyAbstractList的构造函数正在运行时{{1仍然是data。
将null调用替换为其内容意味着super()循环在for初始化时执行，在 MyArrayList正确设置后执行
本质上，问题是data提供了一个构造函数，该构造函数调用将被子类重写的方法，这是一种严重的反模式。 MyAbstractList不应该提供add-all样式构造函数。
有关更多信息，请参阅有效Java项目17，其中注明：
构造函数不得直接或间接调用可覆盖的方法。如果违反此规则，将导致程序失败。超类构造函数在子类构造函数之前运行，因此在子类构造函数运行之前将调用子类中的重写方法。如果重写方法依赖于子类构造函数执行的任何初始化，则该方法将不会按预期运行。