Java 列表实现不解析强制转换

我制作了自己的基于数组的列表实现，它不限制无效参数。如果我使用强制转换创建，MyList MyList=new MyList（），它仍将接受所有其他参数（int、float、double等）。如果指定了一个数据类型，那么我该如何解决这个问题呢；如果没有指定数据类型，那么我希望它现在可以正常工作

这是我的密码：

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;
    }

}

公共类MyList实现MyListInterface
{
私有对象[]内容；
私有整数大小；
公共MyList（）
{
这（10）；
}
公共MyList（整型长度）
{
内容=新对象[长度]；
尺寸=0；
}
私有void alterArraySize（int值）
{
int len=0；
//值为1收缩数组；值为2，然后将其加倍
开关（值）
{
案例1：
len=contents.length/2；
打破
案例2：
len=contents.length*2；
打破
}
Object[]copyArr=新对象[len]；
//复制数组
对于（int i=0；i=0；i--）
目录[i+1]=目录[i]；
内容[0]=新条目；
返回true；
}
公共布尔insertTail（T newEntry）
{
//如果列表中的项目数
if（（大小+1）=contents.length）
交替排列（2）；
//将新条目放入数组中的最后一个插槽中
内容[大小++]=新条目；
返回true；
}
公共对象deleteHead（）
{
//将temp设置为数组中的第一项
对象温度=内容[0]；
//删除第一项
内容[0]=null；
//将列表中的所有项目下移一个位置
对于（int i=1；i如果（size所有方法本身都是泛型的。因此，它们都有自己的类型参数，与类声明的类型参数无关。下面的方法声明是泛型的：

public <T> boolean insertHead(T newEntry)

此外，您的方法的返回类型应为
T
，而不是
Object
，否则在调用端将失败。更改方法：

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

    return null;
}

public Object get（int-givenPosition）
{
如果（（给定位置>=1）和&（给定位置=1）和（givenPosition谢谢！这解决了我的问题。那么这是否意味着该类接受泛型，因为它在类定义中存在？而且由于每个类都从类型对象继承，它将只解析为作为强制转换传递的任何类，否则它是泛型的，因为类定义中存在泛型。@Whoppa你说-"每个类都从类型对象继承？*。是的，这个类是泛型的，因为类名称后面跟有
。我的印象是每个类都是从类型对象派生的。就像字符串从类型对象继承一样，节点从对象继承一样。我的想法错了吗？@Whoppa首先，你的方法不应该有ret
Object
的urn类型，而应该是
T
。在从方法返回到
T
时添加适当的强制转换。是的，传递的原语将自动装箱到相应的包装器。@Whoppa如果方法的返回类型是
Object
。然后调用
get（）
方法对于
MyList
，您希望它返回一个
字符串
，并将返回值存储在
字符串
引用中。这将导致编译器错误。请尝试。
public <T> Object get(int givenPosition)
{
    if ((givenPosition >= 1) && (givenPosition <= size))
        return contents[givenPosition - 1];

    return null;
}

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

    return null;
}