title: super() causes NullPointerException
body: <p>While I am studying Liang's book I am stuck at a point and I don't understand what is going on. The cause of error is the constructor of MyArrayList class. The author warns us about not calling super(object), but they didn't explain the reason. Now when I try and run the code the author is right - when we call super(object) I get an error. What is the cause of this error?</p>
  
  <p><strong>MyArrayList.java</strong></p>
  
  <pre><code>public class MyArrayList&lt;E&gt; extends MyAbstractList&lt;E&gt; {
    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 &lt; 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 &gt;= 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 &gt;= 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 &lt; 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 &lt; 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 &gt;= 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 &lt; 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 &lt; size; i++) {
        result.append(data[i]);
        if (i &lt; 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;
      }
    }
  }
  </code></pre>
  
  <p><strong>MyList.java</strong></p>
  
  <pre><code>public interface MyList&lt;E&gt; {
    /** 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();
  }
  </code></pre>
  
  <p><strong>MyAbstractList.java</strong></p>
  
  <pre><code>public abstract class MyAbstractList&lt;E&gt; implements MyList&lt;E&gt; {
    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 &lt; 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) &gt;= 0) {
        remove(indexOf(e));
        return true;
      }
      else
        return false;
    }
  }
  </code></pre>
  
  <p><strong>TestMyArrayList.java</strong></p>
  
  <pre><code>public class TestMyArrayList {
      public static void main(String[] args)
      {
  
          String[] str = {"manisa","turkey","germany"};
  
          MyList&lt;String&gt; list = new MyArrayList&lt;String&gt;(str);
  
          list.add("America");
          list.add(0,"Canada");
          list.add(1,"England");
          System.out.println(list);
      }
  }
  </code></pre>
  
  <p><strong>Here is the error code :</strong> </p>
  
  <pre><code>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.&lt;init&gt;(MyAbstractList.java:11)
      at MyArrayList.&lt;init&gt;(MyArrayList.java:16)
      at TestMyArrayList.main(TestMyArrayList.java:8)
  </code></pre>