Java Interop

Java has no default arguments, so the function compiles to one method with every parameter — Java must pass them all. @JvmOverloads makes the compiler generate the overload chain, one per dropped trailing parameter, so Java can omit them.

A value from unannotated Java has unknown nullability, so the compiler gives it platform type T! and lets you use it as T or T?; it enforces nothing. Assign it to a non-null T and the inserted check throws when the value is null.

A companion object is a real singleton, not a static section, so Java goes through it: Foo.Companion.bar(). @JvmStatic makes the compiler also emit a static method on Foo, so Java writes Foo.bar(); the companion call still works.

A property compiles to a private backing field plus accessors: val name gives Java getName(), and a var adds setName(); Java calls the methods, never the field. A Boolean named isDone keeps that name: isDone() and setDone().

Kotlin reads Java declarations directly, so that direction is nearly free; the catch is platform types, with unknown nullability. The other way hits what Java lacks: no default arguments, companion object members are not static.

@JvmName renames only what Java sees: a function, accessor, or file class. Its classic job is an erasure clash — two functions differing only in a generic argument get one JVM signature, so one must be renamed. Kotlin keeps the old name.

Annotate the Java side with nullability annotations Kotlin honours (JSpecify, JetBrains) and T! becomes a real T or T?. If it is not your library, wrap it in a thin Kotlin boundary of honest types, checking once, not !! everywhere.

An object compiles to a class holding its one instance in a static INSTANCE field, so Java calls Foo.INSTANCE.bar(). Mark the member @JvmStatic and the compiler adds a static forwarder, so Java writes Foo.bar(); INSTANCE stays.

A suspend fun compiles to a method with an extra trailing Continuation, returning Object — the result or a suspended marker. Java cannot build one, so wrap it in a CoroutineScope and give Java a CompletableFuture or callback.

Kotlin has no checked exceptions and emits no throws clause, so javac sees a method declaring nothing and rejects catch (IOException e). @Throws(IOException::class) on the declaration writes the clause into the signature.

Java cannot call it at all. reified exists only because the function is inline: the compiler substitutes the real T at each Kotlin call site, so no method with a usable T is left. Give Java a non-inline overload taking Class<T>.

Kotlin calls Java seamlessly, bar platform types erasing null safety. The reverse leaks: default arguments need @JvmOverloads, a reified inline fun is uncallable, suspend fun gains a Continuation, and internal is public, mangled.