轉換「可贖回<T>」的Java方法科特林

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

到科特林。

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

這是不正確的：

的代碼被使用的IntelliJ IDEA到自動轉換。但我必須明白這個應該是什麼正確的實現。有任何想法嗎？

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