List injection that does not allow execution

I made my own array-based list implementation and did not limit invalid arguments. If I create with cast, MyList<String> myList = new MyList<String>()it will still accept all other arguments (int, float, double, etc.). How can I fix this if a data type is specified that will be accepted; if the data type is not specified, then I want it to work as it is now.

Here is my code:

public class MyList <T> implements MyListInterface
{

    private Object[] contents;
    private int size;

    public MyList()
    {
        this(10);
    }

    public MyList(int length)
    {
        contents = new Object[length];
        size = 0;
    }

    private void alterArraySize(int value)
    {
        int len = 0;

        //Value is 1 shrink array; value is 2 then double it
        switch (value)
        {
            case 1:
                len = contents.length / 2;
                break;
            case 2:
                len = contents.length * 2;
                break;
        }

        Object[] copyArr = new Object[len];

        //Copy array
        for (int i = 0; i < size; i++)
        {
            copyArr[i] = contents[i];
        }

        contents = copyArr;
    }

    public <T> boolean insertHead(T newEntry)
    {

        size++;

        if ((size + 1) == contents.length)
            alterArraySize(2);

        //Shift elements up one
        for (int i = size; i >= 0; i--)
            contents[i + 1] = contents[i];

        contents[0] = newEntry;

        return true;
    }


    public <T> boolean insertTail(T newEntry)
    {
        //If the number of items in the list
        if ((size + 1) == contents.length)
            alterArraySize(2);

        //Put the newEntry in the last slot in the array
        contents[size++] = newEntry;

        return true;
    }

    public <T> Object deleteHead()
    {
        //Set temp to first item in the array
        Object temp = contents[0];

        //Delete the first item
        contents[0] = null;

        //Shift all items in the list down one position
        for (int i = 1; i < size; i++)
        {
            contents[i - 1] = contents[i];
        }

        //Update size to accommodate for the item deletion
        size--;
        return temp;
    }


    public <T> Object deleteTail()
    {
        //Set temp to last item in array
        Object temp = contents[--size];

        //Delete the last item
        contents[size] = null;

        //Resize if the number of items in the list is half the length
        if (size <= contents.length / 2)
            alterArraySize(1);

        return temp;
    }


    public void display()
    {
        for (int i = 0; i < size; i++)
            System.out.println(contents[i]);
    }


    public <T> int contains(T anEntry)
    {
        for (int i = 0; i < size; i++)
        {
            if (contents[i].equals(anEntry))
                return ++i;
        }

        return 0;
    }


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


    public boolean isFull()
    {
        //List can't be full
        return size == contents.length;
    }

    public <T> Object get(int givenPosition)
    {
        if ((givenPosition >= 1) && (givenPosition <= size))
            return contents[givenPosition - 1];

        return null;
    }

    public <T> void set(T s, int givenPosition)
    {
        contents[givenPosition - 1] = s;
    }

    public <T> Object remove(int givenPosition)
    {
        Object temp = null;

        //Check if givenPosition is valid and shift elements after remove
        if ((givenPosition >= 1) && (givenPosition <= size))
        {
            temp = contents[givenPosition - 1];
            for (int i = givenPosition; i < size; i++)
            {
                contents[i - 1] = contents[i];
            }

            contents[size--] = null;
        }

        return temp;
    }

    public int size()
    {
        return size;
    }

}