[英]super() causes NullPointerException
当我学习梁的书时,我陷入了困境,我不知道发生了什么。 错误的原因是MyArrayList类的构造函数。 作者警告我们不要调用super(object),但是他们没有解释原因。 现在,当我尝试运行代码时,作者是正确的-当我们调用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)
这里的问题是MyAbstractList
中的构造函数在初始化data
之前调用add
。
data
字段在MyArrayList
类中声明和初始化。 但是直到超类初始化完成后才进行初始化,并且在超类初始化期间进行add
调用...当data
仍为null
。
这里的一般问题是,构造函数调用可能被子类覆盖的方法是危险的。 可能在子类初始化发生之前调用重写方法。
在这种情况下, add(E)
可能会被覆盖。 更糟糕的是, add(E)
调用add(E, int)
,因为它在超类中是抽象的,所以肯定会被覆盖。
让我们将代码简化为基本要点:
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);
}
要了解的重要一点是,父类的构造函数在子类甚至尚未初始化之前就被调用(这就是为什么super()
始终必须是构造函数中的第一个调用),这意味着在MyAbstractList
的构造函数运行时, data
仍然为null
。
用内容替换super()
调用意味着在正确设置data
之后 , 在 MyArrayList
初始化时执行for
循环。
本质上,问题在于MyAbstractList
提供了一个构造函数,该构造函数调用将MyAbstractList
类覆盖的方法,这是一种严重的反模式。 MyAbstractList
不应该提供所有样式的构造函数。
有关更多信息,请参见有效的Java项目17,其中指出:
构造函数不得直接或间接调用可重写的方法 。 如果违反此规则,将导致程序失败。 超类构造函数在子类构造函数之前运行,因此子类中的重写方法将在子类构造函数运行之前被调用。 如果重写方法依赖于子类构造函数执行的任何初始化,则该方法将无法正常工作。
声明:本站的技术帖子网页,遵循CC BY-SA 4.0协议,如果您需要转载,请注明本站网址或者原文地址。任何问题请咨询:yoyou2525@163.com.