Milyen veszélyek vannak, amikor egy lambdát Java-ból Kotlin-metódusba továbbítunk?

Java-ból Kotlinban lévő metódusnak átadott lambda esetén:

1. SAM-konverzió: A Java-beli lambda egy funkcionális interfésznek (egy absztrakt metódussal rendelkező interfész) kell megfeleljen, hogy az automatikus konverzió megtörténjen Kotlinban. Ha a lambda nem felel meg ennek az interfésznek, az automatikus konverzió nem fog megtörténni, és kézi átalakítás vagy wrapper szükséges.
2. Nullable típus: A Java-ból származó Kotlin-funkcionális típus alapértelmezés szerint nem nullable (() -> Unit). Ha a Kotlin-metódus nullable típust (() -> Unit)? vár, akkor lehet, hogy explicit módon meg kell adni a nullable típust Kotlinban a Java-ból való híváskor.
3. Kivételek: A Java lambda belsejében keletkező kivételek nem kezelődnek automatikusan Kotlinban. A Kotlin-kódnak ezeket explicit módon kell kezelnie try-catch segítségével.
4. Teljesítmény: Bár a SAM-konverzió általában hatékony, bizonyos esetekben a lambda-hoz tartozó túlzott wrapper-objektumok létrehozása kismértékben befolyásolhatja a teljesítményt.
5. Verziókompatibilitás: A Kotlin és Java közötti kölcsönhatás jellemzői változhatnak a fordítók között, így frissítéskor figyelmet igényelhet.

Példa:

// Java-kód
interface MyFunctionalInterface {
    void doSomething();
}

class JavaConsumer {
    public void consume(MyFunctionalInterface callback) {
        callback.doSomething();
    }
}

// Kotlin-kód
class KotlinUser {
    fun useConsumer(consumer: JavaConsumer) {
        // Automatikus SAM-konverzió Java lambda-ból Kotlin funkcionális típusra
        consumer.consume { println("Valamit csinálok Kotlinból") }

        // Példa, ahol nullable típus szükséges lehet Kotlinban,
        // ha a Java-metódus null-t elfogad
        // fun consumeNullable(callback: (() -> Unit)?) { ... }
    }
}