En este artículo, aprenderá sobre los constructores en Kotlin (tanto constructores primarios como secundarios), así como los bloques inicializadores con la ayuda de ejemplos.
Un constructor es una forma concisa de inicializar propiedades de clase.
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 constructores:
- Constructor primario : forma concisa de inicializar una clase
- Constructor secundario : le permite poner lógica de inicialización adicional
Constructor principal
El constructor principal es parte del encabezado de la clase. He aquí un ejemplo:
class Person (val firstName: String, var age: Int) (// cuerpo de la clase)
El bloque de código rodeada de paréntesis es el constructor principal: (val firstName: String, var age: Int).
El constructor declaró dos propiedades: firstName(propiedad de solo lectura como se declara usando una palabra clave val) y age(propiedad de lectura y escritura como se declara con una palabra clave var).
Ejemplo: constructor principal
fun main(args: Array) ( val person1 = Person("Joe", 25) println("First Name = $(person1.firstName)") println("Age = $(person1.age)") ) class Person(val firstName: String, var age: Int) ( )
Cuando ejecute el programa, la salida será:
Nombre = Joe Edad = 25
Cuando el objeto de Personque se crea la clase, "Joe"y 25los valores se pasan como si Persones una función.
Esto inicializa firstNamey las agepropiedades del objeto person1 "Joe"y 25respectivamente.
Hay otras formas de utilizar constructores primarios.
Bloques de inicializador y constructor primario
El constructor principal tiene una sintaxis restringida y no puede contener ningún código.
Para poner el código de inicialización (no solo el código para inicializar propiedades), se usa el bloque inicializador. Tiene el prefijo de initpalabra clave. Modifiquemos el ejemplo anterior con el bloque inicializador:
fun main(args: Array) ( val person1 = Person("joe", 25) ) class Person(fName: String, personAge: Int) ( val firstName: String var age: Int // initializer block init ( firstName = fName.capitalize() age = personAge println("First Name = $firstName") println("Age = $age") ) )
Cuando ejecute el programa, la salida será:
First Name = Joe Age = 25
Aquí, los parámetros fName y personAge dentro del paréntesis aceptan valores "Joe"y 25respectivamente cuando se crea el objeto person1. Sin embargo, fName y personAge se usan sin usar varo val, y no son propiedades de la Personclase.
La Personclase tiene dos propiedades firstName y age se declaran.
Cuando person1se crea el objeto, se ejecuta el código dentro del bloque inicializador. El bloque inicializador no solo inicializa sus propiedades, sino que también las imprime.
Aquí hay otra forma de realizar la misma tarea:
fun main(args: Array) ( val person1 = Person("joe", 25) ) class Person(fName: String, personAge: Int) ( val firstName = fName.capitalize() var age = personAge // initializer block init ( println("First Name = $firstName") println("Age = $age") ) )
Para distinguir el parámetro constructor y la propiedad, se utilizan diferentes nombres (fName y firstName, y personAge y age). Es más común usar _firstName y _age en lugar de un nombre completamente diferente para los parámetros del constructor. Por ejemplo:
class Person (_firstName: String, _age: Int) (val firstName = _firstName.capitalize () var age = _age // bloque inicializador init (…))
Valor predeterminado en el constructor principal
Puede proporcionar un valor predeterminado a los parámetros del constructor (similar a proporcionar argumentos predeterminados a las funciones). Por ejemplo:
fun main(args: Array) ( println("person1 is instantiated") val person1 = Person("joe", 25) println("person2 is instantiated") val person2 = Person("Jack") println("person3 is instantiated") val person3 = Person() ) class Person(_firstName: String = "UNKNOWN", _age: Int = 0) ( val firstName = _firstName.capitalize() var age = _age // initializer block init ( println("First Name = $firstName") println("Age = $age") ) )
Cuando ejecute el programa, la salida será:
Nombre = Joe Edad = 25 person2 es instanciado Nombre = Jack Edad = 0 person3 es instanciado Nombre = DESCONOCIDO Edad = 0
Constructor secundario de Kotlin
En Kotlin, una clase también puede contener uno o más constructores secundarios. Se crean mediante constructorpalabras clave.
Los constructores secundarios no son tan comunes en Kotlin. El uso más común del constructor secundario surge cuando necesita extender una clase que proporciona múltiples constructores que inicializan la clase de diferentes maneras. Asegúrese de verificar la herencia de Kotlin antes de aprenderlo.
Así es como puede crear un constructor secundario en Kotlin:
class Log (constructor (data: String) (// algún código) constructor (data: String, numberOfData: Int) (// algún código))
Aquí, la Logclase tiene dos constructores secundarios, pero ningún constructor principal.
Puede extender la clase como:
class Log (constructor (data: String) (// código) constructor (data: String, numberOfData: Int) (// code)) class AuthLog: Log (constructor (data: String): super (data) (// code ) constructor (data: String, numberOfData: Int): super (data, numberOfData) (// código))
Aquí, los constructores de la clase derivada AuthLogllaman al constructor correspondiente de la clase base Log. Para eso, super()se utiliza.
En Kotlin, también puede llamar a un constructor desde otro constructor de la misma clase (como en Java) usando this().
class AuthLog: Log (constructor (data: String): this (data, 10) (// código) constructor (data: String, numberOfData: Int): super (data, numberOfData) (// código))
Ejemplo: constructor secundario de Kotlin
fun main(args: Array) ( val p1 = AuthLog("Bad Password") ) open class Log ( var data: String = "" var numberOfData = 0 constructor(_data: String) ( ) constructor(_data: String, _numberOfData: Int) ( data = _data numberOfData = _numberOfData println("$data: $numberOfData times") ) ) class AuthLog: Log ( constructor(_data: String): this("From AuthLog -> " + _data, 10) ( ) constructor(_data: String, _numberOfData: Int): super(_data, _numberOfData) ( ) )
Cuando ejecute el programa, la salida será:
Desde AuthLog -> Contraseña incorrecta: 10 veces
Nota: El constructor secundario debe inicializar la clase base o delegarla en otro constructor (como en el ejemplo anterior) si la clase no tiene un constructor primario.
