Constructor en Kotlin (Constructor)

En este artículo, aprenderás sobre los constructores en Kotlin (constructor principal y constructor secundario) y los bloques de inicialización, con la ayuda de ejemplos.

El constructor es un método conciso para inicializar propiedades de la clase.

Es una función miembro especial que se llama al instanciar (crear) un objeto. Pero, su funcionamiento en Kotlin es ligeramente diferente.

En Kotlin, hay dos constructores:

• Constructor principal - Método conciso de inicialización de la clase

• Constructor secundario - permite que coloques otra lógica de inicialización

Constructor principal

El constructor principal es parte de la cabecera de la clase. Aquí hay un ejemplo:

class Person(val firstName: String, var age: Int) {
　　　　//　cuerpo de clase
}

El código entre paréntesis es el constructor principal: (val firstName: String, var age: Int).

El constructor declara dos propiedades: firstName (propiedad de solo lectura, ya que se declara con el keyword val) y age (propiedad de lectura y escritura, ya que se declara con el keyword var).

Ejemplo: Constructor principal

fun main(args: Array<String>) {
　　　　val persona1　= Person("Joe",　25)
　　　　println("First Name = ${person1.firstName}")
　　　　println("Age = ${person1.age")
}
class Person(val firstName: String, var age: Int) {
}

La salida del programa es la siguiente cuando se ejecuta:

First Name = Joe
Age =　25

Al crear un objeto de la clase Person, se pasarán los valores Joe y 25como si Person fuera una función.

Esto será person1 Las propiedades firstName y age del objeto se inicializan respectivamente con "Joe" y 25.

Hay otros métodos para usar el constructor principal.

Constructor principal y bloque de inicialización

La sintaxis del constructor principal está restringida y no puede contener ningún código.

Para colocar el código de inicialización (no solo el código de inicialización de propiedades), se utiliza un bloque de inicialización. Se antepone el prefijo init. Vamos a modificar el ejemplo anterior con un bloque de instrucciones de inicialización:

fun main(args: Array<String>) {
　　　　val persona1　= Persona("joe",　25)
}
class Persona(fName: String, personAge: Int) {
　　　　val firstName: String
　　　　var age: Int
　　　　//Bloque de inicialización
　　　　init {
　　　　　　　　firstName = fName.capitalize()
　　　　　　　　age = personAge
　　　　　　　　println("Nombre = $firstName")
　　　　　　　　println("Edad = $age")
　　　　}
}

La salida del programa es la siguiente cuando se ejecuta:

First Name = Joe
Age =　25

Aquí, al crear el objeto person1y se pasan los valores "Joe" y 25。Pero, al usar fName y personAge, no se utiliza var o val, y no son propiedades de la clase Persona.

La clase Persona declara dos propiedades firstName y age.

cuando se crea el objeto person1El objeto se crea, se ejecuta el código del bloque de inicialización. El bloque de inicialización no solo inicializa sus propiedades, sino que también las imprime.

Esta es otra manera de hacer lo mismo:

fun main(args: Array<String>) {
　　　　val persona1　= Persona("joe",　25)
}
class Persona(fName: String, personAge: Int) {
　　　　val firstName = fName.capitalize()
　　　　var age = personAge
　　　　//Bloque de inicialización
　　　　init {
　　　　　　　　println("Nombre = $firstName")
　　　　　　　　println("Edad = $age")
　　　　}
}

Para distinguir los parámetros del constructor de las propiedades, se utilizan nombres diferentes (fName y FirstName, así como Personage y age). Para los parámetros del constructor, es más común usar _firstName y _age en lugar de nombres completamente diferentes. Por ejemplo:

class Persona(_firstName: String, _age: Int) {
　　　　val firstName = _firstName.capitalize()
　　　　var age = _age
　　　　//　Bloque de inicialización
　　　　init {
　　　　　　　　...　..　...
　　　　}
}

Valores predeterminados en el constructor principal

Puede proporcionar valores predeterminados para los parámetros del constructor (al igual que para las funciones)Parámetros por defecto）。Por ejemplo：

fun main(args: Array<String>) {
　　　　println("persona = Person("1　se instancia")
　　　　val persona1　= Persona("joe",　25)
　　　　println("persona = Person("2　se instancia")
　　　　val persona2　= Persona("Jack")
　　　　println("persona = Person("3　se instancia")
　　　　val persona3　= Persona()
}
class Persona(_firstName: String = "UNKNOWN", _age: Int = 0) {
　　　　val firstName = _firstName.capitalize()
　　　　var age = _age
　　　　//Bloque de inicialización
　　　　init {
　　　　　　　　println("Nombre = $firstName")
　　　　　　　　println("Edad = $age\n")
　　　　}
}

La salida del programa es la siguiente cuando se ejecuta:

First Name = Joe
Age =　25
person2　Se instancia
First Name = Jack
Age = 0
person3　Se instancia
First Name = UNKNOWN
Age = 0

Segundo constructor en Kotlin

En Kotlin, una clase también puede tener uno o más segundos constructores. Se crean usando la palabra clave constructor.

Los segundos constructores en Kotlin no son comunes. La aplicación más común de los segundos constructores ocurre cuando necesitas expandir una clase que proporciona múltiples constructores de inicialización de diferentes maneras. Antes de aprender, asegúrate de entenderHerencia en Kotlin.

Puedes crear métodos de segundo constructor en Kotlin de la siguiente manera:

class Log {
　　　　constructor(data: String) {
　　　　　　　　//　Algunos códigos
　　　　}
　　　　constructor(data: String, numberOfData: Int) {
　　　　　　　　//　Algunos códigos
　　　　}
}

Aquí, la clase Log tiene dos segundos constructores, pero no un constructor principal.

Puedes extender la clase como:

class Log {
　　　　constructor(data: String) {
　　　　　　　　//　Código
　　　　}
　　　　constructor(data: String, numberOfData: Int) {
　　　　　　　　//　Código
　　　　}
}
class AuthLog: Log {
　　　　constructor(data: String): super(data) {
　　　　　　　　//　Código
　　　　}
　　　　constructor(data: String, numberOfData: Int): super(data, numberOfData) {
　　　　　　　　//　Código
　　　　}
}

Aquí, el constructor del subclase AuthLog llama al constructor correspondiente de la clase base Log. Para esto, se usa super().

En Kotlin, también puedes usar this() para llamar a otro constructor de la misma clase (como en Java).

class AuthLog: Log {
　　　　constructor(data: String): this(data,　10) {
　　　　　　　　//　Código
　　　　}
　　　　constructor(data: String, numberOfData: Int): super(data, numberOfData) {
　　　　　　　　//　Código
　　　　}
}

Ejemplo: Segundo constructor en Kotlin

fun main(args: Array<String>) {
　　　　val p1　= AuthLog("Contraseña Incorrecta")
}
open class Log {
　　　　var data: String = ""
　　　　var numberOfData = 0
　　　　constructor(_data: String) {
　　　　}
　　　　constructor(_data: String, _numberOfData: Int) {
　　　　　　　　data = _data
　　　　　　　　numberOfData = _numberOfData
　　　　　　　　println("$data: $numberOfData veces")
　　　　}
}
class AuthLog: Log {
　　　　constructor(_data: String): this("From AuthLog　-> "　+　_data,　10) {
　　　　}
　　　　constructor(_data: String, _numberOfData: Int): super(_data, _numberOfData) {
　　　　}
}

La salida del programa es la siguiente cuando se ejecuta:

From AuthLog　-Bad Password:　10　times

Nota:Si la clase no tiene constructor principal, el constructor secundario debe inicializar la clase base o delegar a otro constructor (como se muestra en el ejemplo anterior).