Java 扩展异步任务类的奇怪行为

我正在使用我自己的通用抽象类（MyAsyncTask），它扩展了AsyncTasks，并且需要一种方法来取消当前运行的所有MyAsyncTasks

abstract class MyAsyncTask<Params, Progress, Result> 
         extends AsyncTask<Params, Progress, Result> {
    ...
}

在我看来，编写一个接口是合理的

interface Cancelable {
    public Boolean cancel(Boolean mayInterruptIfRunning);
}

并让MyAsyncTask实现它：

abstract class MyAsyncTask<Params, Progress, Result> 
         extends AsyncTask<Params, Progress, Result> implements Cancelable {

    private static WeakHashMap<Cancelable, Void> taskList = new WeakHashMap<Cancelable, Void>();

    public MyAsyncTask() {
        taskList.add(this, null);
    }

    public static void cancelAll() {
            Iterator<Cancelable> iterator = taskList.keySet().iterator();

            while (iterator.hasNext()) {
                Cancelable task = iterator.next();

                if (task != null) {
                    task.cancel(true);
                    iterator.remove();
                }
            }
    }

    ...

}

现在我的问题是： 1） 为什么允许我定义这个cancel方法，即使超类中有相同的final方法？ 2） 哪一个-如果我执行new MyAsyncTask（）.cancel（）；，将执行原始的一个或我的方法

我尝试用普通java模拟这种情况

abstract interface A {
    public Boolean cancel(Boolean a);
}

abstract class B<T> {
    public final Boolean cancel(Boolean a) {
        System.out.println("B.cacncel called");
        return a;
    }
}

abstract class C<T> extends B<T> implements A {}

class D extends C<Void> {}

class TestApp {
    public static void main(String[] args) {
        D x = new D();
        x.cancel(true);
    }
}

抽象接口A{
公共布尔取消（布尔a）；
}
抽象B类{
公共最终布尔值取消（布尔值a）{
System.out.println（“称为B.cacncel”）；
返回a；
}
}
抽象类C扩展了B实现了{}
类D扩展了C{}
类TestApp{
公共静态void main（字符串[]args）{
D x=新的D（）；
x、 取消（真）；
}
}

但在这种情况下，我不必在类D中实现cancel方法，因为它已经在类B中实现了。那么，AsyncTask有什么特别之处？为什么我必须重新实现cancel方法

---

谢谢。

不，

AsyncTask

具有

布尔取消（布尔）

而您具有

布尔取消（布尔）

这个类编译得很好

public class Test {

    public Boolean d(Boolean v) { return false; }

    public boolean d1(boolean v1) { return true; } 

}

abstract interface A {
    public Boolean cancel(Boolean a);
}

abstract class B<T> {
    public final Boolean cancel(Boolean a) {
        System.out.println("B.cacncel called");
        return a;
    }
}

abstract class C<T> extends B<T> implements A {}

class D extends C<Void> {}

class TestApp {
    public static void main(String[] args) {
        D x = new D();
        x.cancel(true);
    }
}

public class Test {

    public Boolean d(Boolean v) { return false; }

    public boolean d1(boolean v1) { return true; } 

}