Java 为什么我们可以分配FutureTask<；V>；面向未来<；V>；变量

以下是《Java并发实践》一书中让我困惑的片段：

interface Computable<A, V> {
    V compute(A arg) throws InterruptedException;
}

public class Memoizer3<A, V> implements Computable<A, V> {
        private final Map<A, Future<V>> cache
                 = new ConcurrentHashMap<A, Future<V>>();
        private final Computable<A, V> c;

        public Memoizer3(Computable<A, V> c) { this.c = c; }

        public V compute(final A arg) throws InterruptedException {
            Future<V> f = cache.get(arg);
            if(f == null) {
                Callable<V> eval = new Callable<V>() {
                    @Override
                    public V call() throws Exception {
                        return c.compute(arg);
                    }
                };
                FutureTask<V> ft = new FutureTask<V>(eval);

                //How could it happen???
                f = ft;

                cache.put(arg, ft);
                ft.run();
            }
            try {
                return f.get();
            } catch (InterruptedException e) {
                throw launderThrowable(e.getCause());
            }
        }
    }

接口可计算{
V compute（A arg）抛出InterruptedException；
}
公共类Memoizer3实现可计算{
私有最终映射缓存
=新的ConcurrentHashMap（）；
私有最终可计算c；
公共备忘录3（可计算的c）{this.c=c；}
public V compute（最后一个参数）抛出InterruptedException{
Future f=cache.get（arg）；
如果（f==null）{
Callable eval=新的Callable（）{
@凌驾
public V call（）引发异常{
返回c.compute（arg）；
}
};
FutureTask ft=新的FutureTask（eval）；
//这怎么会发生？？？
f=英尺；
cache.put（arg，ft）；
ft.run（）；
}
试一试{
返回f.get（）；
}捕捉（中断异常e）{
扔掉可清洗的垃圾（如getCause（））；
}
}
}

正如代码所示，f的类型是Future，而ft的类型是FutureTask。为什么我们可以将ft指定给变量f？

Future

是一个由

FutureTask

实现的接口，所以这样做没有什么错。如果类

C

实现了接口

I

，则可以将该类分配给类型为

C

的变量以及类型为

I

的变量。请注意，在第二种情况下，您将只能与

I

公开的方法子集交互，而不是与

C

提供的整套方法交互

---

FutureTask

FutureTask的文档是FutureTask接口的基础具体实现，并提供异步处理。