Implementation of generic unordered list in java This question is a follow-up question of this question. These features are added to the new class - 


Generic class
User is capable of setting the size
List interface has been added
Iterator class has been added


As of now I still have some questions after developing this class.


Does this list interface have enough methods/behavior?
Why do I have to type cast from next() while returning data?
When I am testing this class I have to do this Iterator&lt;Integer&gt; itr = ((UnorderedList) ul).iterator(); why?


Thanks to him to open my eyes to design a class to iterate over a structure. My prof of Data Structure even did not specify or taught students important things like this. 

If this class is still lacking anything then as always suggestions and advice are appreciated.

//List interface

package lists.arrayLists;

public interface List&lt;T&gt;
{
    boolean isFull();
    boolean isEmpty();
    boolean add(T data);
    void remove(T data);
    boolean find(T data);
    int size();
}


// Unordered List class

package lists.arrayLists.unorderedList;

import lists.arrayLists.List;
import java.lang.IndexOutOfBoundsException;
import java.util.Iterator;
import java.util.NoSuchElementException;

public class UnorderedList&lt;T&gt; implements List&lt;T&gt;, Iterable&lt;T&gt;
{
    private static int MAX_SIZE = 100;
    private int size;
    private Node&lt;T&gt;[] nodeElements;

    public UnorderedList()
    {
        nodeElements = new Node[MAX_SIZE];
    }

    public UnorderedList(int capacity)
    {
        MAX_SIZE = capacity;
        nodeElements = new Node[MAX_SIZE];
    }

    @Override
    public boolean isFull()
    {
        return (size() == MAX_SIZE);
    }

    @Override
    public boolean isEmpty()
    {
        return (size() == 0);
    }

    @Override
    public int size()
    {
        return size;
    }

    @Override
    public boolean add(T data)
    {
        try
        {
            Node&lt;T&gt; node = new Node&lt;&gt;(data);
            nodeElements[size++] = node;
            return true;
        }
        catch (IndexOutOfBoundsException ex)
        {
            System.out.println(ex.getMessage());
            throw new IndexOutOfBoundsException();
        }
    }

    @Override
    public void remove(T data)
    {
        int index = locate(data);
        try
        {
            nodeElements[index] = nodeElements[size() - 1];
            size--;
        }
        catch (IndexOutOfBoundsException ex)
        {
            throw new NoSuchElementException();
        }
    }

    @Override
    public boolean find(T data)
    {
        return (locate(data) &gt;= 0);
    }

    private int locate(T data)
    {
        for (int index = 0; index &lt; size(); index++)
        {
            if (data == nodeElements[index].getData())
            {
                return index;
            }
        }
        return - 1;
    }

    @Override
    public Iterator&lt;T&gt; iterator()
    {
        return new ULIterator&lt;T&gt;();
    }

    private class ULIterator&lt;T&gt; implements Iterator&lt;T&gt;
    {
        private int currentIndex = 0;

        @Override
        public boolean hasNext()
        {
            return (currentIndex &lt; size());
        }

        @Override
        public T next()
        {
            if(hasNext())
            {
                return (T)nodeElements[currentIndex++].getData();
            }
            else
            {
                throw new NoSuchElementException();
            }
        }
    }
}


// Node class

package lists.arrayLists.unorderedList;

public class Node&lt;T&gt;
{
    private T data;

    public Node(T data)
    {
        this.data = data;
    }

    public T getData()
    {
        return data;
    }
}
Does this list interface have enough methods/behavior?

Yes, it is enough. If you want to extend it consider implementing java.util.Collection interface.

Why do I have to type cast from next() while returning data?
When I am testing this class I have to do this Iterator itr = ((UnorderedList) ul).iterator(); why?

Those two questions are related. You need a cast to UnorderedList since you didn't put iterator() function in your List interface. And cast for next() is required since you used (UnorderedList) ul instead of (UnorderedList&lt;Integer&gt;) ul.
If MAX_SIZE is a constant it should have final modifier and shouldn't be changed in UnorderedList(int capacity). You might use nodeElements.length instead.
Node class looks pointless, there is nothing wrong with using T[] nodeElements or  better Object[] nodeElements, since generic arrays are tricky to construct.
You also shouldn't catch IndexOutOfBoundsException when you can just check if index is valid before accessing it.