首页 文章

使用函数引用在Kotlin中重写Java代码发生SAM类型冲突

提问于
浏览 次
4

我有一个示例Java代码使用方法引用，我想重写为Kotlin . Java版本使用方法参考，解决方案简短明了 . 但另一方面，我不能在Kotlin中使用方法参考 . 我设法编写的唯一版本如下所示 . 似乎 Function3 { s: String, b: Boolean, i: Int -> combine(s, b, i) } 可以用更干净的方式编写（如果可能的方法参考将是完美的） .

我是Kotlin的新手，所以我会感激任何线索 .

Java

import io.reactivex.Observable;

public class TestJava {

    Observable<String> strings() {
        return Observable.just("test");
    }

    Observable<Boolean> booleans() {
        return Observable.just(true);
    }

    Observable<Integer> integers() {
        return Observable.just(1);
    }

    void test() {
        Observable.combineLatest(strings(), booleans(), integers(),
                this::combine);
    }

    double combine(String s, boolean b, int i) {
        return 1.0;
    }
}

Kotlin

import io.reactivex.Observable
import io.reactivex.functions.Function3

class TestKotlin {

    fun strings(): Observable<String> {
        return Observable.just("test")
    }

    fun booleans(): Observable<Boolean> {
        return Observable.just(true)
    }

    fun integers(): Observable<Int> {
        return Observable.just(1)
    }

    fun test() {
        Observable.combineLatest(strings(), booleans(), integers(),
                Function3 { s: String, b: Boolean, i: Int -> combine(s, b, i) })
    }

    fun combine(s: String, b: Boolean, i: Int): Double {
        return 1.0
    }
}

EDIT

以下Kotlin中的方法引用给出了错误 .

fun test() {
    Observable.combineLatest(strings(), booleans(), integers(), this::combine)
}

fun test() {
    Observable.combineLatest(strings(), booleans(), integers(), TestKotlin::combine)
}

使用提供的参数不能调用以下任何函数：@CheckReturnValue @SchedulerSupport public final fun combineLatest（p0：（（Observer） - > Unit）！，p1：（（Observer） - > Unit）！，p2 :( （Observer） - > Unit）！，p3：（（???，???，???） - > ???）！）：Observable <（??? ??? ???）>！在io.reactivex.Observable中定义@CheckReturnValue @SchedulerSupport public open fun combineLatest（p0：ObservableSource！，p1：ObservableSource！，p2：ObservableSource！，p3：io.reactivex.functions.Function3！）：Observable <（??? . ???）>！在io.reactivex.Observable中定义@CheckReturnValue @SchedulerSupport public open fun combineLatest（p0：Function！，out（??? .. ???）>！，p1：Int，vararg p2：ObservableSource！）：Observable <（？ ?? .. ???）>！在io.reactivex.Observable中定义

EDIT 2

RxKotlin解决了答案中提到的问题 .

import io.reactivex.rxkotlin.Observables

class TestKotlin {

    fun test() {
        Observables.combineLatest(strings(), booleans(), integers(), this::combine)
    }

}
java lambda kotlin rx-java2 method-reference

2 回答

  • 4

    您也可以在Kotlin中使用Function Reference Expression，就像Java中的方法引用表达式一样 . 例如， combine 函数引用为Kotlin中的 KFunction3 ，如下所示：

    val f: kotlin.reflect.KFunction3<String, Boolean, Int, Double> = this::combine

    在java中，方法引用表达式可以分配给任何 compatible Functional Interface，但是您不能将Function Reference Expression分配给任何函数类型，即使它们是 compatible ，例如：

    val f:io.reactivex.functions.Function3<String,Boolean,Int,Double> =this::combine
//                                                type mismatch error     ---^

    实际上，Kotlin使用SAM Conversions将lambda / Function Reference Expression转换为Java Functional Interface的实现，这意味着Kotlin执行如下操作：

    fun test() = TODO()

val exector:Executor = TODO()

exector.execute(::test)

//::test compile to java code as below:
Runnable task = new Runnable(){
   public void run(){
      test();
   }
};

    Why 方法参考表达式可以在Java中正常工作，但在Kotlin中使用Function Reference Expression失败了吗？

    基于上面的内容，您可以看到rx-java2中有许多重载的 combineLatest 方法 . 例如，以下两个不能使Kotlin正确使用Function Reference Expression：

    combineLatest(
       ObservableSource<out T1>,
       ObservableSource<out T2>,
       ObservableSource<out T3>, 
       Function3<T1, T2, T3, out R>
)

combineLatest(
       ObservableSource<out T1>,
       ObservableSource<out T2>,
       ObservableSource<out T3>, 
       ObservableSource<out T4>, 
       Function4<T1, T2, T3, T4, out R>
)

    正如我所说，Kotlin使用SAM Conversions将lambda / Function Reference Expression转换为Java Functional Interface，但它无法直接分配给Java Functional Interface .

    Kotlin中 combineLatest 方法的第4个参数，编译器根本无法推断其类型，因为第4个参数类型可以是 io.reactivex.functions.Function3 或 ObservableSource . 因为 ObservableSource 也是一个Java Functional Interface .

    遇到像这样的SAM Conversion冲突时，可以使用将lambda转换为特定SAM类型的 adapter function ，例如：

    typealias RxFunction3<T1, T2, T3, R> = io.reactivex.functions.Function3<T1,T2,T3,R>

val f: RxFunction3<String, Boolean, Int, Double> = RxFunction3{ s, b, i-> 1.0}

    因此，在使用lambda / Function Reference Expression之前必须使用自适应，例如：

    typealias RxFunction3<T1, T2, T3, R> = io.reactivex.functions.Function3<T1,T2,T3,R>

fun <T1,T2,T3,R> KFunction3<T1,T2,T3,R>.toFunction3(): RxFunction3<T1, T2,T3,R> {
    return RxFunction3 { t1, t2, t3 -> invoke(t1, t2, t3) }
}

    Then 您可以使用如下的Function Reference Expression，例如：

    Observable.combineLatest(
        strings(),
        booleans(), 
        integers(), 
        //             v--- convert KFunction3 to RxFunction3 explicitly
        this::combine.toFunction3()
)
    回复于
  • 6

    @ holi-java答案很棒，它解释了为什么会出现这个问题，在这里我为那些只想摆脱问题的人提供快速解决方案：

    在 rxJava2 中使用 io.reactivex.rxkotlin.Observables 而不是 io.reactivex.Observable 来组合您的observable：

    Observables.combineLatest(src1, src2, ::yourFunction)

    这应该是开箱即用的 .

    回复于

相关问题