Java 为什么我会遇到类强制转换异常？

作业内容如下：
使用普通队列数组给出优先级队列的完整实现。对于普通队列，请使用第402页的版本

第402页内容如下：

公共类优先队列
{
专用阵列队列[]队列；
...

在此实现中，构造函数使用以下语句为队列数组分配内存：

queues = (ArrayQueue<E>[]) new Object[highest+1];

queues=（ArrayQueue[]）新对象[highest+1]；

然而：

线程“main”java.lang.ClassCastException中的异常：[Ljava.lang.Object；无法强制转换为[Lpriorityqueue.Queue； priorityqueue.priorityqueue.（priorityqueue.java:17） 位于priorityqueue.priorityqueue.main（priorityqueue.java:67） Java结果：1

data=（队列[]）新对象[highPriority]异常；

public class PriorityQueue<T>
{

    private Queue<T>[] data;
    private int size, hprior;
    @SuppressWarnings("unchecked")

    public PriorityQueue(int highPriority)
    {
        if(highPriority < 1)
            throw new RuntimeException("Invalid priority number!");

        data =  (Queue<T>[]) new Object[highPriority]; //Error line 17

        for(int i = 0; i < highPriority; i++)
        {
           data[i] = new Queue<>();
        }

    size = 0;
    }

    public void add(int priority, T element)
    {
        if(priority > data.length)
            throw new RuntimeException("Invalid priority number!");

        data[priority-1].enqueue(element);
        size++;
    }

    public T remove()
    {
        if(empty())
            throw new RuntimeException("Priority Queue is Empty!");

        T element = null;

        for(int i = data.length; i < 0; i--)
        {
          if(data[i].size()!=0)
              element = (T) data[i].dequeue();
          break;
        }

        return element;
    }

    public int size()
    {
        return size;
    }

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

    public static void main(String[] args) 
    {
       PriorityQueue<String> pq = new PriorityQueue<>(10); //Error at line 67
       pq.add(1, "hi");
       pq.add(2, "there!");

       System.out.println(pq.remove());
    }


}

class Queue<T> 
{
    private int front, rear, size;
    public final static int DEFAULT_CAPACITY = 64;
    private T[] queue;

    public Queue(int capacity)
    {
        queue = (T[]) new Object[capacity];
        size = 0;
        front = 0;
        rear = 0;
    }

    public Queue()
    {
        this(DEFAULT_CAPACITY);
    }

    public void enqueue(T element)
    {
        if(size() == queue.length)
            throw new RuntimeException("Queue Full!");

        queue[rear]= element;
        rear = (rear +1) % queue.length;
        size++;
    }

    public T dequeue()
    {
        if(empty())
            throw new RuntimeException("Queue empty!");

        T element = queue[front];
        front = (front +1) % queue.length;
        size--;

        return element;
    }

    public int size()
    {
        return size;
    }

    public T front()
    {
        return queue[front];
    }

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

公共类优先队列
{
专用队列[]数据；
私有内部大小，hprior；
@抑制警告（“未选中”）
公共优先级队列（int高优先级）
{
if（高优先级<1）
抛出新的RuntimeException（“无效的优先级编号！”）；
数据=（队列[]）新对象[高优先级]；//错误行17
for（int i=0；i数据长度）
抛出新的RuntimeException（“无效的优先级编号！”）；
数据[priority-1]。排队（元素）；
大小++；
}
公共部门不能删除（）
{
if（空（））
抛出新的RuntimeException（“优先级队列为空！”）；
T元素=null；
对于（int i=data.length；i<0；i--）
{
如果（数据[i].size（）！=0）
元素=（T）数据[i].dequeue（）；
打破
}
返回元素；
}
公共整数大小（）
{
返回大小；
}
公共布尔空（）
{
返回大小==0；
}
公共静态void main（字符串[]args）
{
PriorityQueue pq=新的PriorityQueue（10）；//第67行出错
pq.添加（1，“hi”）；
pq.添加（2，“那里！”）；
System.out.println（pq.remove（））；
}
}
类队列
{
私人内特前，后，尺寸；
公共最终静态int默认容量=64；
私有T[]队列；
公共队列（整数容量）
{
队列=（T[]）新对象[容量]；
尺寸=0；
正面=0；
后部=0；
}
公共队列（）
{
这（默认容量）；
}
公共无效排队（T元素）
{
if（size（）==queue.length）
抛出新的运行时异常（“队列已满！”）；
队列[后部]=元素；
后=（后+1）%queue.length；
大小++；
}
公共T出列（）
{
if（空（））
抛出新的RuntimeException（“队列为空！”）；
T元素=队列[前端]；
前端=（前端+1）%queue.length；
大小--；
返回元素；
}
公共整数大小（）
{
返回大小；
}
公共交通前线（
{
返回队列[前面]；
}
公共布尔空（）
{
返回大小==0；
}
}

您不能将

对象

随机强制转换为其他类型。如果您想要一个

队列[]

，您需要实际构造一个队列。您无法使用泛型创建数组，因此您必须执行以下操作：

Queue<T>[] queue = (Queue<T> []) new ArrayDeque[10]; //or whatever concrete implementation you want.

Queue[]Queue=（Queue[]）new ArrayDeque[10]；//或任何您想要的具体实现。

你不能将

对象[]

强制转换为

队列[]

，因为

对象[]

不是

队列[]

。如果你想要

队列[]

，你需要创建一个。为什么你认为

新对象[]

可以强制转换为

队列[]？？你应该强烈地考虑使用<代码>清单>代码>，因为数组和泛型不能很好地混合，但是使用<代码>列表 s将很好。Cube不会自动将对象从一种类型转换为另一种类型，它可以例如不神奇地使<>代码>队列< /COD>对象脱离<代码>对象< /代码>对象。在转换时，不会将
对象
转换为
队列
，也不会将
对象[]
转换为
队列[]
，但我们也不能创建
新队列[]
。还有什么其他选项？@Jesper
Queue<T>[] queue = (Queue<T> []) new ArrayDeque[10]; //or whatever concrete implementation you want.