Kotlin vs Java

Null Safety

Java: variables are nullable. NullPointerException is a common issue.
Kotlin: variables are non-nullable by default (to avoid NPE); use ? for nullable variables, e.g. var a: String?

Kotlin data class is similar to Java record, with some differences:

Java record does not have copy() method.
data class variables can be var or val; record variables are all final.
data class can inherit from other non-data classes; record has no inheritance.
data class can define non-constructor mutable variables; record can define only static variables.

Kotlin supports coroutines in an extension library kotlinx.coroutines. (Not at the language level or in the standard library.)
Java: Project Loom is trying to add coroutines / fibers to Java but it is not finished yet.

Kotlin: provides the ability to extend a class with new functionality without having to inherit from the class or use design patterns such as Decorator.
Java: you have to create a new class and inhrit from the parent class.

Kotlin: no checked exceptions, developers do not need to declare or catch exceptions.
Java: have both checked and unchecked exceptions.

Java: use static keyword to declare class members (used without an instance).
Kotlin: no static keyword but can use a companion object.

Java: methods can be overridden by default; a final class cannot be subclassed.
Kotlin: classes cannot be inherited by default; a open class can.

Both Kotlin and Java (since Java 17) support Sealed Class.

Before Java 17, Java has the following options for inheritance control:

Java uses switch:

switch ( ... ) {
  case X:
    ...
  case Y:
    ...
  default:
    ...
}

Kotlin uses when:

when ( ... ) {
  condition -> ...
  condition -> ...
  else -> ...
}