Living with Java

Calling Java from Kotlin

• Getters and setters become properties. person.getName() is written person.name, and setName(x) is person.name = x. isActive() becomes person.isActive.
• Functional interfaces take lambdas. Any Java interface with a single abstract method (Runnable, Comparator, a listener) can be passed a Kotlin lambda; this is SAM conversion.
• Collections are mapped, not converted. A Java List<String> appears as (Mutable)List<String!>!: Kotlin doesn't know if you may change it or if it or its elements may be null.
• Nullability comes from annotations. Without them you get platform types (String!). With @Nullable/@NonNull from JSpecify, JetBrains, AndroidX and several others, Kotlin uses real String? and String types. JSpecify annotations are enforced as errors by default; most others give warnings unless you configure them as strict.
• Checked exceptions are not checked. Kotlin has no throws clause and never forces a try.

Calling Kotlin from Java

Java callers see the bytecode shapes, so a few Kotlin features need hints:

1// File: Money.kt2@file:JvmName("MoneyUtils")                  // Java sees MoneyUtils, not MoneyKt3 4import java.io.IOException5 6class Rates {7    companion object {8        @JvmStatic fun eur(): Rates = Rates()  // Rates.eur() in Java, not Rates.Companion.eur()9        @JvmField val DEFAULT_SCALE = 2         // a public static field, no getter10    }11}12 13@JvmOverloads                                 // generates format(Long) and format(Long, String)14fun format(cents: Long, currency: String = "EUR"): String = "%.2f %s".format(cents / 100.0, currency)15 16@Throws(IOException::class)                   // lets Java catch IOException around the call17fun loadRates(path: String): String = java.io.File(path).readText()18 19fun main() {20    println(format(1999))                     // 19.99 EUR21    println(Rates.DEFAULT_SCALE)              // 222}

• Properties appear as getX()/setX(); boolean isX stays isX().
• internal declarations are public in bytecode but get a mangled name so Java can't call them by accident.
• Default arguments don't exist in Java: use @JvmOverloads, or Java must pass every argument.
• Kotlin lambdas passed to Java are kotlin.jvm.functions.Function1 and so on. For an API meant to be called from Java, declare a fun interface instead, so Java can use its own lambdas.

The fun interface

1fun interface PriceRule { fun apply(cents: Long): Long }2 3val tenPercentOff = PriceRule { it * 90 / 100 }   // SAM conversion for a Kotlin interface

A fun interface gets SAM conversion in Kotlin and is a normal functional interface for Java.

Mixed projects

Java and Kotlin can live in the same module: the Kotlin compiler runs first (reading the Java sources only to resolve references to them), then javac compiles the Java against Kotlin's output. Converting a file at a time works well, starting with leaf classes and tests. Java annotation processors run through kapt, which generates Java stubs for them to read; processors written for KSP (Room and Moshi, for example) read Kotlin declarations directly, without the stub step.