Java vs Kotlin: A JVM and Android Migration Decision
Kotlin is usually the practical default for new Android code and a strong option for new JVM services; Java remains the lower-change choice for stable Java estates, broad library compatibility, and teams that do not need Kotlin-specific features. Because both interoperate on the JVM, migrate incrementally by module and measured benefit rather than rewriting a working system.
Interoperability makes migration possible, not effortless
Kotlin can call Java and Java can call most Kotlin declarations, but nullability, checked exceptions, default parameters, companion objects, properties, and generated names cross the boundary differently. The official Java interoperability guide documents annotations and bytecode-facing behavior. Treat the public Java API as a contract and add Java-side compilation tests before converting an exported class.
Start with tests, build tooling, or leaf modules that have few callers. Keep the existing build green, prevent circular Java-Kotlin dependencies between modules, and measure compilation and IDE indexing. Avoid a mechanical syntax conversion of domain code: it preserves old design weaknesses while adding unfamiliar idioms.
Null safety and coroutines have boundaries
Kotlin's type system distinguishes nullable and non-null references, but it does not eliminate null
failures. Java platform types, the !! operator, initialization order, reflection, and
foreign code can still produce exceptions. Kotlin's
null-safety documentation
lists these escape paths. Add boundary validation instead of scattering assertions.
Suspending functions are a language feature; structured concurrency, dispatchers, scopes, and most
coroutine primitives come from the kotlinx.coroutines library. Its
official guide
explains cancellation and context. Coroutines and Java virtual threads overlap for high-concurrency I/O
but have different APIs and ecosystem integration. Do not mix them without an ownership and cancellation
model.
Choose by platform and rollout risk
Android's Kotlin-first guidance makes Kotlin the natural choice for most new Android UI and Jetpack work. On a server, run a pilot through framework startup, serialization, ORM mappings, proxies, annotation processing, reflection, tests, and production monitoring. Check that Java callers receive a deliberate API.
Adopt Kotlin when concise domain models, safer nullable types, coroutines, or multiplatform sharing solve an identified problem. Keep Java where longevity, a conservative dependency surface, or generated and vendor code dominate. The failure mode is a mandate based on line count: concise code can still hide allocation, blocking, cancellation, and compatibility bugs. Record which modules may use which idioms and enforce that boundary in review.
Published · Updated