转换；可调用<；T>&引用；Kotlin的Java方法

我正在尝试转换一个Java方法：

private <T> Callable<T> createCallable(final Callable<T> task) {
    return () -> {
        try {
            return task.call();
        } catch (Exception e) {
            handle(e);
            throw e;
        }
    };
}

private Callable createCallable（最终可调用任务）{
返回（）->{
试一试{
返回task.call（）；
}捕获（例外e）{
手柄（e）；
投掷e；
}
};
}

从以下Java文件导入Kotlin

使用IntelliJ IDEA将代码自动转换为：

private fun <T> createCallable(task: Callable<T>): Callable<T> {
    return {
        try {
            return task.call()
        } catch (e: Exception) {
            handle(e)
            throw e
        }
    }
}

private fun createCallable（任务：Callable）：Callable{
返回{
试一试{
return task.call（）
}捕获（e：例外）{
手柄（e）
掷e
}
}
}

---

这是不正确的。但我必须知道这应该是什么样的正确实现。有什么想法吗？

我认为这是Kotlin转换器的错误。它将代码转换为

（）->T

，而不是

可调用的

（这基本上是相同的，但实际上是不同的类型）。 这是工作代码

private fun <T> createCallable(task: Callable<T>): Callable<T> {
    return Callable {
        try {
            task.call()
        } catch (e: Exception) {
            handle(e)
            throw e
        }
    }
}

private fun createCallable（任务：Callable）：Callable{
返回可调用{
试一试{
task.call（）
}捕获（e：例外）{
手柄（e）
掷e
}
}
}

我就是这样做的，可能太冗长了，但效果不错。我还实现了一个

句柄

函数

import java.util.concurrent.*

private fun <T> createCallable(task: Callable<T>): Callable<T> {
    return object : Callable<T> {
    override fun call(): T  {
            try {
                return task.call()
            } catch (e: Exception) {
                handle(e)
                throw e
            }
        }
    }
}

private fun handle(e: Exception): Unit { println("got exception") }

import java.util.concurrent*
私人娱乐可调用（任务：可调用）：可调用{
返回对象：可调用{
覆盖有趣的调用（）：T{
试一试{
return task.call（）
}捕获（e：例外）{
手柄（e）
掷e
}
}
}
}
私有有趣句柄（e:Exception）：单元{println（“get Exception”）}

这就是我在测试中所说的

fun main(vararg argv: String): Unit {
    val callable1 = object : Callable<Int> {
        override fun call(): Int = 1
    }
    val c1 = createCallable(callable1)
    println("callable1 = ${c1.call()}")

    val callable2 = object : Callable<Unit> {
        override fun call(): Unit { println("Hello"); throw Exception("Hello") }
    }
    val c2 = createCallable(callable2)
    c2.call()
}

fun main（vararg argv:String）：单位{
val callable1=对象：可调用{
重写趣味调用（）：Int=1
}
val c1=createCallable（callable1）
println（“callable1=${c1.call（）}”）
val callable2=对象：可调用{
override fun call（）：单元{println（“Hello”）；抛出异常（“Hello”）}
}
val c2=createCallable（callable2）
c2.call（）
}