¿Cómo inicializar el constructor en Kotlin?

Constructor es una forma concisa de inicializar propiedades de clase. o podemos decir que es una función miembro especial que se invoca cuando se crea un objeto de la clase principalmente para inicializar variables o propiedades. Una clase debe tener un constructor y, si no declaramos un constructor, el compilador genera un constructor predeterminado. Es una función miembro especial que se llama cuando se crea una instancia de un objeto. Sin embargo, la forma en que funcionan en Kotlin es ligeramente diferente. En Kotlin, hay dos tipos de constructores:

• Constructor principal: forma concisa de inicializar una clase
• Constructor secundario: le permite poner lógica de inicialización adicional

En el mundo de Java, solíamos inicializar campos de la clase en el constructor, como se muestra en este código:

class Student {
  int roll_number;
  String name;
  Student(int roll_number,String name) {
    this.roll_number = roll_number;
    this.name = name;
  }
}

Por lo tanto, si el nombre del argumento era similar al de la propiedad (que solía ser el caso para hacer que el código fuera más legible), necesitábamos usar esta palabra clave. En esta receta, veremos cómo implementar lo mismo en Kotlin (obviamente con mucho menos código).

Implementación paso a paso

Veamos los pasos mencionados para inicializar un constructor:

Paso 1: Kotlin proporciona una sintaxis que puede inicializar las propiedades con mucho menos código. Así es como se ve la inicialización de clases en Kotlin:

class Student (var roll_number: Int, var name:String) 

Paso 2: ni siquiera necesita definir el cuerpo de la clase, y la inicialización de las propiedades se lleva a cabo solo en el constructor principal (el constructor principal es parte del encabezado de la clase). Obviamente, puede elegir var o val, en función de si necesita mantener sus propiedades mutables o no. Ahora, si intenta crear un objeto, puede hacerlo con esto:

var student_A=Student (1, "Rashi Karanpuria" )

Paso 3: Solo para confirmar, intentemos imprimir sus propiedades para ver si pudimos inicializarlo o no:

printin ("Roll number: $(student_A. roll_number} Name: ${student_A. name}" )

Aquí está la salida: 

Roll number: 1 Name: Rashi Karanpuria

Paso 4: Sin embargo, si lo desea, también puede poner valores predeterminados en el constructor:

class Student constructor (var roll_number: Int, var name : String="Sheldon")

Paso 5: Luego, puedes crear objetos como este:

var student_sheldon= Student (25) //object with name Sheldon and
age 25
var student_amy=Student (25, "Amy" )  // Object with name Amy and
age 25

Paso 6: si la clase tiene un constructor principal, cada constructor secundario debe delegarse en el constructor principal, ya sea directa o indirectamente a través de otro(s) constructor(es) secundario(s).

Paso 7: Usamos esta palabra clave para delegar a otro constructor de la misma clase:

class Person (val name: String) {
    constructor (name: String, lastName: String) : this(name) {
    // Do something maybe
    }
}

Paso 8: También podemos tener una situación en la que tenemos que inicializar otras cosas en la clase, no necesariamente solo las propiedades de la clase. Esa situación podría estar abriendo conexiones de base de datos, por ejemplo. En Java, eso se hizo en el propio constructor, pero en Kotlin, tenemos un bloque de inicio . El código de inicialización se puede poner en un bloque de inicio

class Student (var roll_number: Int, var name: String) { 
init {
        logger. info( "Student initialized")
    }
}

Paso 9: A veces, también inicializamos las propiedades de una clase por inyección de dependencia. Si ha trabajado con Dagger2, debe estar familiarizado con los objetos que se inyectan directamente en los constructores de una clase. Para hacerlo, agregamos la anotación @Inject antes de la palabra clave del constructor. Cada vez que un constructor tiene una anotación o un modificador de visibilidad, necesitamos tener la palabra clave constructor. A continuación se muestra un ejemplo de la palabra clave constructor:

class Student #Inject constructor (compositeDisposable:
CompositeDisposable) { . . . }

Paso 10: aquí estamos inyectando un objeto del tipo CompositeDisposable en el constructor y, dado que estamos usando una anotación (@Inject) para hacerlo, necesitamos aplicar la palabra clave constructor.

Paso 11: cuando extiende una clase, debe inicializar la superclase. Esto también es muy simple en Kotlin. Si su clase tiene un constructor principal, el tipo base debe inicializarse allí, usando los parámetros del constructor principal. Aquí hay un ejemplo de lo mismo:

class Student constructor
(var roll_number: Int, var name : String) : Person (name)