在ScheduledThreadPoolExecutor中重写泛型方法的java问题

Question

我试图从java重写这个方法。util。同时发生的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);

本课程：

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=新的QueueItemTask（c，task）；//，任务）； ^ 其中X#1，X#2是类型变量： X#1扩展方法decoriteTask中声明的对象（可调用、可运行的ScheduledFuture） X#2扩展类队列中声明的QueueItem

Answer 2

将X类型参数添加到QueueItemTask类声明中，并且不要用X类型覆盖decorateTask方法中的V类型：

import test.QueueItem;

public class Queue<X extends QueueItem> extends ScheduledThreadPoolExecutor {

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

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

  public static class QueueItemTask<X>
      extends FutureTask<X>
      implements RunnableScheduledFuture<X> {

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

    public QueueItemTask(Callable<X> item, RunnableScheduledFuture<X> 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);
    }
  }

}