Question

我正在尝试转换Java方法：

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

从以下Java文件ExceptionHandlingAsyncTaskExecutor.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
        }
    }
}

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

Answer 1

我认为这是一个Kotlin转换器错误。它将您的代码转换为() -> T而不是Callable<T>（基本相同，但这些实际上是不同的类型）。这是工作代码

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

Answer 2

这就是我这样做的方式，可能过于冗长，但它确实有效。我还实现了handle函数。

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") }

这就是我在测试中称之为......

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()
}

将“Callable <t>”Java方法转换为Kotlin

2 个答案: