Kotlin LateInit
¿Qué hace la palabra clave "tardía" en Kotlin??
Con la ayuda de la introducción, sabrá que la palabra clave "LateInit" se usa con una variable en Kotlin solo cuando desea inicializar esa variable en algún lugar más adelante en su script. Sin embargo, podría considerar hacer que esa variable sea "nula" si no desea inicializarla en primer lugar. Sin embargo, todavía puede haber algunas situaciones en las que ni siquiera quieres hacer que estas variables sean nulas. Puede usar la palabra clave "LateInit" mientras declara una variable para situaciones similares. La ventaja más significativa de usar esta palabra clave es que no asigna ninguna memoria a la variable antes de que se inicialice. Sin embargo, debe asegurarse de inicializar esa variable más adelante en su código antes de que se acceda. Si no lo hace, su compilador generará algunos errores. Por lo tanto, no se le permitirá ejecutar su script kotlin.
Precauciones con el uso de la palabra clave "LateInit" en Kotlin:
Después de conocer el propósito básico de la palabra clave "LateInit" del lenguaje de programación de Kotlin, también debe conocer las precauciones que debe tomar antes de comenzar a usar la palabra clave "LateInit" en Kotlin. Estas precauciones se resumen a continuación:
- La palabra clave "LateInit" siempre debe usarse con la palabra clave "var" y no con la palabra clave "val".
- Las variables "LateInit" no pueden ser del tipo "nulo".
- Antes de acceder a él, debe inicializar una variable "LateInit" porque no hacerlo conducirá a excepciones y errores.
Ejemplos de uso de la palabra clave "LateInit" en Kotlin:
Para resaltar el uso de palabras clave "LateInit" en el lenguaje de programación de Kotlin en Ubuntu 20.04, hemos implementado los siguientes dos ejemplos para usted:
Ejemplo # 1: Declarar y usar una variable Kotlin como "LateInit":
Este ejemplo le enseñará el método más simple para declarar una variable Kotlin como "LateInit" y luego, usarlo para lograr una funcionalidad deseada. Puede echar un vistazo al programa Kotlin que se muestra en la imagen a continuación para comprender esto:
En este programa Kotlin, primero hemos utilizado la palabra clave "LateInit" para declarar un objeto "EMP" de la clase "Empleado" como "LateInit". Puede obtener que aún no haya implementado esta clase. Por lo tanto, tendremos que hacerlo más tarde en nuestro script para que nuestro compilador no produzca errores. Hemos creado una instancia de "EMP" de la clase "Empleado" en nuestra función "Main ()". A continuación, le hemos transmitido el nombre del empleado como una cadena y su experiencia en años como entero. Luego, utilizamos las dos declaraciones "println" para imprimir ambos parámetros en el terminal. Finalmente, hemos declarado una clase de datos llamada "Empleado" que es capaz de aceptar dos parámetros, "nombre" y "experiencia" de tipos de cadenas e enteros, respectivamente. Aquí es donde nuestro objeto "LateInit" finalmente se inicializará.
Después de implementar este script de Kotlin, lo compilamos con el siguiente comando:
$ Kotlinc LateInit.ktLuego, utilizamos el comando que se muestra a continuación para ejecutar este script:
$ kotlin lateInitktLa siguiente imagen representa la salida de este programa Kotlin. Puede ver cómo hemos logrado usar con éxito la palabra clave "LateInit" en Kotlin para imprimir el nombre y la experiencia de un empleado.
Ejemplo # 2: Descubrir si se ha inicializado una variable "LateInit" o no:
Ya hemos mencionado que si olvida inicializar la variable "LateInit" dentro de su script Kotlin, entonces conduce a errores en tiempo de compilación. Por lo tanto, debe haber una forma a través de la cual puede descubrir si se ha inicializado o no una variable "LateInit". Le guiaremos a través de este método en el script Kotlin que se muestra en la imagen a continuación:
En este script de Kotlin, primero hemos definido una clase llamada "curso". Dentro de esta clase, hemos declarado una variable llamada "Coursename" del tipo de cadena como "LateInit". Luego, hemos creado una función de esta clase llamada "InitializeName ()". Dentro de esta función, primero queríamos verificar si nuestra variable "LateInit" ha sido inicializada o no. Para eso, hemos usado el "this :: Coursename.ISINICIALIZADO "Notación.
Aquí, la palabra clave "esta" corresponde al estado actual de nuestra variable "LateInit", que en este momento no está inicializada. Luego, hemos utilizado el operador de resolución de alcance para acceder al valor actual de la variable "Coursename" seguida de la función "Isinitialized". A continuación, hemos inicializado la variable "Coursename" con el nombre de un curso. Después de eso, utilizamos la función "isinitializada" nuevamente para verificar el estado actual de la variable "LateInit". Dentro de nuestra función "Main ()", hemos creado una instancia de la clase "Curso" "C1". Con la ayuda de esta instancia, hemos llamado a la función "Initializename ()".
La imagen posterior muestra la salida de este script Kotlin. Inicialmente, cuando nuestra variable "LateInit" no estaba inicializada, la salida devuelta por la función "isinitializada" era "falsa". Mientras que cuando inicializamos la variable "LateInit", la salida de la misma función resultó ser "verdadera".
Conclusión:
En esta guía, primero le presentamos el concepto de inicialización tardía, seguido del propósito de su existencia en Kotlin. Después de darle una breve descripción general de su trabajo y las medidas que deben tomarse para usarlo de manera efectiva, compartimos dos ejemplos que aclararon aún más este concepto. Al pasar por esta guía, tendría una idea justa del concepto de inicialización tardía en Kotlin en Ubuntu 20.04. Esperamos que hayas encontrado este artículo útil. Consulte los otros artículos de Sugerencia de Linux para obtener más consejos y tutoriales.