lateinit en Kotlin está ahí para que pueda tener tipos que no aceptan valores NULL en variables que no puede inicializar en el momento en que se crea la clase que los contiene.

Usando su ejemplo, si no usó lateinit , tendría que hacer que el subject sea anulable, ya que debe inicializarse con un valor.

 public class MyTest { var subject: TestSubject? = null }

Esto lo obligaría a realizar verificaciones nulas cada vez que lo use, lo cual es feo, por lo que puede marcarlo como lateinit en su lugar.

En Java, realmente no tiene este problema, ya que todo es anulable, y declarar un campo no inicializado no es nada especial:

 public class JavaTest { TestSubject subject; }

Esto inicializa subject a null , por lo que es prácticamente equivalente al ejemplo de Kotlin no lateinit .

La única diferencia real entre la versión lateinit en Kotlin y la versión de Java es que obtienes una excepción más específica cuando intentas acceder a una propiedad no inicializada en Kotlin, a saber, UninitializedPropertyAccessException , que hará que la depuración sea más fácil que tener que buscar la causa. de una NullPointerException genérica.

Si realmente quisiera este comportamiento ligeramente diferente, podría envolver sus propiedades de Java en algún tipo de envoltorio, pero no creo que valga la pena la sobrecarga sintáctica para hacerlo. Una forma muy básica (no segura para subprocesos, por ejemplo) de hacer esto sería:

Tener una clase contenedora genérica para las propiedades:

 public class Property<T> { private T value = null; public T get() { if (value == null) throw new UninitializedPropertyAccessException("Property has not been initialized"); return value; } public void set(T value) { if (value == null) throw new IllegalArgumentException("Value can't be null"); this.value = value; } }

Usa este contenedor en tus clases:

 public class JavaTest { Property<TestSubject> subject = new Property<>(); }

Y luego este uso le daría la excepción no inicializada:

 JavaTest test = new JavaTest(); test.subject.get();

Y este andaría bien:

 JavaTest test = new JavaTest(); test.subject.set(new TestSubject()); test.subject.get();

Editar: esto es muy similar a cómo funciona lateinit en Kotlin, si descompila el código de bytes de su ejemplo en Java, esto es lo que obtiene:

 public final class MyTest { @NotNull public TestSubject subject; @NotNull public final TestSubject getSubject() { TestSubject var10000 = this.subject; if(this.subject == null) { Intrinsics.throwUninitializedPropertyAccessException("subject"); } return var10000; } public final void setSubject(@NotNull TestSubject var1) { Intrinsics.checkParameterIsNotNull(var1, "<set-?>"); this.subject = var1; } }

Básicamente, el compilador coloca el código para verificar el acceso a la propiedad dentro de la propia clase (+ usa algunos métodos auxiliares) en lugar de usar un contenedor, que es más eficiente.

No existe tal propiedad en Java que retrase la inicialización de la propiedad. Pero creo que el comportamiento en Kotlin y Java es bastante similar.

Aquí están mis dos centavos :

En Kotlin, acceder a una propiedad lateinit antes de que se haya inicializado arroja una excepción especial que identifica claramente la propiedad a la que se accede y el hecho de que no se ha inicializado. (Referencia: https://kotlinlang.org/docs/reference/properties.html ).

En Java también, se lanza NullPointerException (NPE) que indica que la propiedad a la que se accede es nula.

La única diferencia podría ser que NPE es una excepción de tiempo de ejecución.

Hay muchos ejemplos aquí . En tu caso:

 public class MyTest { lateinit var subject: TestSubject }

Se compila con el siguiente código Java:

 import kotlin.jvm.internal.Intrinsics; import org.jetbrains.annotations.NotNull; public final class MyTest { @NotNull public TestSubject subject; @NotNull public final TestSubject getSubject() { TestSubject testSubject = this.subject; if (testSubject == null) { Intrinsics.throwUninitializedPropertyAccessException((String) "subject"); } return testSubject; } public final void setSubject(@NotNull TestSubject testSubject) { Intrinsics.checkParameterIsNotNull((Object) testSubject, (String) "<set-?>"); this.subject = testSubject; } }