java - 在 ScheduledThreadPoolExecutor 中重写通用方法时出现问题

Question

我正在尝试从 java.util.concurrent.ScheduledThreadPoolExecutor 重写此方法

protected <V> RunnableScheduledFuture<V> decorateTask(Callable<V> callable,RunnableScheduledFuture<V> task)

我收到此错误:

incompatible types: java.util.concurrent.Callable<X> cannot be converted to java.util.concurrent.Callable<X>

引用该行:

QueueItemTask t2 = new QueueItemTask(c, task);

来自这个类(class):

package test;

import org.apache.log4j.Logger;

//import java.util.concurrent.*;                                                
import java.util.concurrent.RunnableScheduledFuture;
import java.util.concurrent.ScheduledThreadPoolExecutor;
import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;
import java.util.concurrent.Delayed;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
import java.util.concurrent.ExecutionException;

import test.QueueItem;

public class Queue<X extends QueueItem> extends ScheduledThreadPoolExecutor {

    @Override
    protected <X> RunnableScheduledFuture<X> decorateTask(
                                                        Callable<X> c, RunnableScheduledFuture<X> task) {
        QueueItemTask t2 = new QueueItemTask(c, task);                

        return (RunnableScheduledFuture<X>)t2;
    }

    public Queue(){
        super(1); // only one thread                                            
    }

    public class QueueItemTask
        extends FutureTask<X>
        implements RunnableScheduledFuture<X>
    {
        Logger log = Logger.getLogger(this.getClass());

        private Callable<X> item;
        private RunnableScheduledFuture<X> task;

        public QueueItemTask(Callable<X> item, RunnableScheduledFuture task){
            super(item);

            this.item = item;
            this.task = task;
        }

        public X getItem(){
            return (X)this.item;
        }

        public void run() {
            task.run();
        }
       public boolean isPeriodic() {
            return task.isPeriodic();
        }
        public boolean cancel(boolean mayInterruptIfRunning) {
            return task.cancel(mayInterruptIfRunning);
    }
        public boolean isCancelled() {
            return task.isCancelled();
        }
        public boolean isDone() {
            return task.isDone();
        }
        public X get()
            throws InterruptedException, ExecutionException {
            return task.get();
        }
        public X get(long timeout, TimeUnit unit)
            throws InterruptedException, ExecutionException, TimeoutException {
            return task.get(timeout, unit);
        }
    public long getDelay(TimeUnit unit) {
            return task.getDelay(unit);
        }
        public int compareTo(Delayed o) {
            return task.compareTo(o);
        }
    }

}

我也尝试过不使用泛型 - 只是使用 QueueItem 而不是 X，并且得到基本上相同的错误，除了一种泛型类型是完全限定的，即。

incompatible types: java.util.concurrent.Callable<QueueItem> cannot be converted to java.util.concurrent.Callable<test.QueueItem>

感谢任何帮助!

Answer 1

结束这个问题b/c我尝试了一个不同的javac，它给出了一个更有用的错误:

不兼容的类型:Callable 无法转换为 Callable QueueItemTask t2 = new QueueItemTask(c, 任务);//， 任务); ^ 其中 X#1,X#2 是类型变量: X#1 扩展了decorateTask(Callable,RunnableScheduledFuture)方法中声明的对象 X#2 扩展了 Queue 类中声明的 QueueItem