if i try making a rentableList in another class file it works fine up until i try to us the add method. at which point it returns a NullPointerException, if read over and over but cant figure out why or how to fix it, any ideas?

//begin rentableList*******************************************************************************
import structures.linear.List;
import java.util.NoSuchElementException;

public class RentableList
{
	private List<Rentable> rentables;

	public RentableList(){}

	public void add(Rentable ren)
	{rentables.add(ren);}

}
//end rentableList

//begin rentable*************************************************************************************************

public interface Rentable extends Cloneable
{
	void setInfo(String title,String s1,String s2,String s3,String s4, String productionCo,int setOwned) throws OutOfBoundsException;
	void setCopiesOwned(int copies) throws OutOfBoundsException;
	int getCopiesInStock();
	int getCopiesOwned();
	void checkIn(int check) throws OutOfBoundsException;
	void checkOut(int check) throws OutOfBoundsException;
	String getTitle();
	void updateOwned(int num) throws OutOfBoundsException;
	boolean equals(Object other);
	String toString();
	public Object clone() throws CloneNotSupportedException;

}
//end rentable****************************************************************************************************************

//begin List********************************************************************************************************************
package structures.linear;

/**
 * This class implements a generic unordered list.
 *
 * @author Sesh Venugopal
 *
 * @param <T> The type of objects to be stored in this
 * unordered list.
 */
public class List<T>
{

	/**
	 * Entries in this list, stored in a generic linked
	 * list.
	 */
	LinkedList<T> elements;

	/**
	 * Keeps track of current position when iterating
	 * over this list using the first( ) and next
	 * methods( ).
	 */
	int cursor;

	/**
	 * Initializes this list to empty.
	 *
	 */
	public List()
	{
		elements = new LinkedList<T>();
		cursor = -1;
	}

	/**
	 * Adds a given item to the end of this list.
	 *
	 * @param item Item to be added to the end.
	 */
	public void add(T item)
	{
		elements.add(item);
	}

	/**
	 * Returns the number of items in this list.
	 *
	 * @return Number of items in this list.
	 */
	public int size()
	{
		return elements.size();
	}

	/**
	 * Tells whether this list is empty or not.
	 *
	 * @return True if this list is empty, false
	 * otherwise.
	 */
	public boolean isEmpty()
	{
		return elements.isEmpty();
	}

	/**
	 * Tells whether this list contains a given item.
	 *
	 * @param item Item that is sought in this list.
	 * @return True if item is found, false otherwise.
	 */
	public boolean contains(T item)
	{
		return elements.indexOf(item) != -1;
	}

	/**
	 * Empties this list by removing all items.
	 */
	public void clear()
	{
		elements.clear();
	}

	/**
	 * Removes the first occurrence of a given item
	 * from this list.
	 *
	 * @param item Item to be removed.
	 * @throws NoSuchElementException If this list does
	 * not contain the given item.
	 */
	public void remove(T item)
	{
		elements.remove(item);
	}

	/**
	 * Removes all occurrences of a given item from
	 * this list.
	 *
	 * @param item Item for which all instances are to
	 * be removed.
	 * @throws NoSuchElementException If this list does
	 * not contain the given item.
	 */
	public void removeAll(T item)
	{
		elements.removeAll(item);
	}

	/**
	 * Returns the first item in this list, and sets
	 * the iteration cursor to the first position.
	 *
	 * @return First item in this list, null if list is
	 * empty.
	 */
	public T first()
	{
		if (elements.size() == 0)
		{
			return null;
		}
		cursor = 0;
		return elements.getAt(cursor);
	}

	/**
	 * Sets the cursor to the next position, and
	 * returns the item in this list at that position.
	 * <br> To iterate over this list, there must be a
	 * call to first( ), followed by successive calls
	 * to next( ).
	 *
	 * @return Next item in this list. Null if list is
	 * empty, or cursor is at the end of the list at
	 * the time this method is called, i.e. end of list
	 * was reached.
	 */
	public T next()
	{
		if (cursor < 0 || cursor == (elements.size()-1))
		{
			return null;
		}
		cursor++;
		return elements.getAt(cursor);
	}
}

//end List**********************************************************************************************

//begin LinkedList************************************************************************************************************
package structures.linear;

import java.util.NoSuchElementException;

/**
 * Helper class that implements linked list nodes.
 *
 * @author Sesh Venugopal
 *
 * @param <T> The type of objects to be stored in this
 * node.
 */
class Node<T>
{
	/**
	 * Data
	 */
	T data;

	/**
	 * Next reference
	 */
	Node<T> next;

	/**
	 * Set constructor.<p>
	 * Initializes node with given data and null
	 * reference.
	 *
	 * @param dat Data
	 */
	Node(T dat)
	{
		data = dat;
		next = null;
	}
}

/**
 * This class implements a generic circular linked
 * list (CLL).
 *
 * @author Sesh Venugopal
 *
 * @param <T> The type of objects to be stored in this
 * CLL.
 */
public class LinkedList<T>
{
	/**
	 * Reference to the last node of this CLL
	 */
	Node<T> tail;

	/**
	 * Number of nodes in this CLL.
	 */
	int count;

	/**
	 * Initializes this CLL to empty.
	 */
	public LinkedList()
	{
		tail = null;
		count = 0;
	}

	/**
	 * Adds a new item to the end of this CLL.
	 *
	 * @param item The item to be added to the end of
	 * this CLL.
	 */
	public void add(T item)
	{
		Node<T> itemnode = new Node<T>(item);

		if (count == 0)
		{ // empty list
			itemnode.next = itemnode;
		}
		else
		{
			itemnode.next = tail.next;
			tail.next = itemnode;
		}
		tail = itemnode;
		count++;
	}

	/**
	 * Inserts a new item at a given index in this CLL.
	 *
	 * @param item Item to be inserted.
	 * @param index Index of inserted item.
	 * @throws IndexOutOfBoundsException If the index
	 * is < 0 or >= number of items currently in this
	 * CLL.
	 */
	public void insertAt(T item, int index)
	{
		if (index < 0 || index >= count)
		{
			throw new IndexOutOfBoundsException(index
				+ " < 0 or >= " + count);
		}

		// find predecessor
		Node<T> pred = tail;
		for (int i=0; i < index; i++)
		{
			pred = pred.next;
		}

		// insert after pred
		Node<T> itemnode = new Node<T>(item);
		itemnode.next = pred.next;
		pred.next = itemnode;
		count++;
	}

	/**
	 * Removes the first occurrence of a given item
	 * from this CLL.
	 *
	 * @param item Item to be removed.
	 * @throws NoSuchElementException If this CLL does
	 * not contain the given item.
	 */
	public void remove(T item)
	{
		int i = indexOf(item);
		if (i == -1)
		{
			throw new NoSuchElementException();
		}
		removeAt(i);
	}

	/**
	 * Removes the item at a given index.
	 *
	 * @param index Index of item to be removed.
	 * @return The removed item.
	 * @throws IndexOutOfBoundsException If the index
	 * is < 0 or >= number of items currently in this
	 * CLL.
	 */
	public T removeAt(int index)
	{
		if (index < 0 || index >= count)
		{
			throw new IndexOutOfBoundsException(index
				+ " < 0 or >= " + count);
		}
		T ret=null;
		if (index == 0)
		{
			ret = tail.next.data;
			if (count == 1)
			{ // single element, special case
				tail = null;
			}
			else
			{  // at least two entries
				tail.next = tail.next.next;
			}
			count--;
		}
		else
		{ // at least two entries, and index > 0
			// find the entry just prior to index
			Node<T> prev=tail.next;
			for (int i=0; i < index-1; i++)
			{
				prev = prev.next;
			}
			// remove after prev
			Node<T> curr = prev.next;
			ret = curr.data;  // save for return
			prev.next = curr.next;
			curr.next = null;
			count--;
			if (curr == tail)
			{
				tail = prev;
			}
		}
		return ret;
	}

	/**
	 * Removes all occurrences of a given item from
	 * this CLL.
	 *
	 * @param item The item, all instances of which are
	 * to be removed from this CLL.
	 * @throws NoSuchElementException If this CLL does
	 * not contain the given item.
	 */
	public void removeAll(T item)
	{
		if (count == 0)
		{
			throw new NoSuchElementException();
		}

		// step through all entries
		Node<T> prev=tail, curr=tail.next;
		int oldcount = count;
		for (int i=0; i < oldcount; i++)
		{
			if (item.equals(curr.data))
			{
				prev.next = curr.next;
				curr.data = null;
				curr.next = null;
				count--;
			}
			else
			{
				prev = curr;
			}
			curr = prev.next;
		}
		if (count == oldcount)
		{ // no match
			throw new NoSuchElementException();
		}
		if (count == 0)
		{
			tail = null;
		}
		else
		{
			tail = prev;
		}
	}

	/**
	 * Empties this CLL by removing all items.
	 */
	public void clear()
	{
		tail = null;
		count = 0;
	}

	/**
	 * Replaces the item in this CLL at a given index
	 * by a given item.
	 *
	 * @param item Item that replaces existing item.
	 * @param index Index at which replacement is done.
	 * @throws IndexOutOfBoundsException If the index
	 * is < 0 or >= number of items currently in this
	 * CLL.
	 */
	public void setAt(T item, int index)
	{
		if (index < 0 || index >= count)
		{
			throw new IndexOutOfBoundsException(index
				+ " < 0 or >= " + count);
		}
		Node<T> curr=tail.next;
		for (int i=0; i < index; i++)
		{
			curr = curr.next;
		}
		curr.data = item; // update
	}

	/**
	 * Returns the item at the specified index in this
	 * CLL.
	 *
	 * @param index Position in this CLL from which
	 * item is to be returned.
	 * @return Item at specified index.
	 */
	public T getAt(int index)
	{
		if (index < 0 || index >= count)
		{
			throw new IndexOutOfBoundsException(index
				+ " < 0 or >= " + count);
		}
		// skip over intervening nodes
		Node<T> curr=tail.next;
		for (int i=0; i < index; i++)
		{
			curr = curr.next;
		}
		return curr.data;
	}

	/**
	 * Returns the index of a given item in this CLL.
	 *
	 * @param item Item for which index is to be found.
	 * @return Index of the given item.
	 */
	public int indexOf(T item)
	{
		if (count == 0)
		{
			return -1;
		}

		// step through list nodes
		Node<T> curr=tail.next;
		for (int i=0; i < count; i++)
		{
			if (item.equals(curr.data))
			{
				return i;
			}
			curr = curr.next;
		}
		return -1;
	}

	/**
	 * Returns the number of nodes in this CLL.
	 *
	 * @return Number of nodes in this CLL.
	 */
	public int size()
	{
		return count;
	}

	/**
	 * Tells whether this CLL is empty or not.
	 *
	 * @return True if this CLL is empty, false
	 * otherwise.
	 */
	public boolean isEmpty()
	{
		return count == 0;
	}
} //end linkedList***************************************************************************