Uso de los Constructores Secundarios en Kotlin

1. La historia de los constructores secundarios en Kotlin
2. Constructores secundarios de Kotlin
3. Crear múltiples constructores secundarios en Kotlin
4. Llamar a un constructor secundario desde otro constructor secundario existente
5. Llamar a un constructor secundario de la clase principal Desde un constructor secundario en la clase secundaria

Los constructores son funciones miembro llamadas automáticamente cuando se crea un objeto en un lenguaje de programación orientado a objetos.

Dado que Kotlin es un lenguaje OOPS, también utiliza constructores para la inicialización de objetos. En Kotlin, hay dos constructores: constructores primarios y constructores secundarios.

Este artículo presenta el concepto de constructores secundarios en Kotlin y cómo usarlos.

La historia de los constructores secundarios en Kotlin

Los constructores secundarios no fueron compatibles con Kotlin hasta 2015. Hasta entonces, los desarrolladores usaban una de las técnicas de soplado para resolver la mayoría de los casos de uso de constructores secundarios.

1. Definición de un método de fábrica junto a la clase.
2. Definición de valores predeterminados para los parámetros.
3. Usando un método de fábrica definido en otro objeto.

Si bien estas técnicas eran lo suficientemente buenas, había una necesidad de constructores secundarios. Kotlin comenzó a apoyar a los constructores secundarios con el lanzamiento de M11 en 2015.

Constructores secundarios de Kotlin

Mientras que los constructores primarios brindan una forma concisa de inicializar una clase, los constructores secundarios se vuelven necesarios al extenderlos. Además, el constructor secundario también permite agregar lógica de inicialización.

Si bien solo podemos tener un constructor principal en un programa, Kotlin permite la creación de múltiples constructores secundarios.

Podemos crear y usar constructores secundarios en Kotlin con la palabra clave constructor. Un programa de Kotlin puede tener uno o varios constructores secundarios.

Generalmente se evitan los constructores secundarios, pero se usan para extender una clase. La razón es que ayudan a inicializar una sola clase de varias maneras a través de múltiples constructores.

Sintaxis:

class ABC {
    constructor(data: String) {
        // code
}

Para comprender mejor los constructores secundarios, veamos el siguiente ejemplo. Crearemos un constructor secundario para la clase Producto que generará el producto de dos enteros.

Código de ejemplo:

fun main(args: Array<String>) {
    Product(3, 7)
}

class Product {
    //Creating a secondary constructor
    constructor(x: Int, y:Int){
        var i = x * y
            println("The product of integers 3 and 7 is: ${i}")
    }
}

Producción:

Crear múltiples constructores secundarios en Kotlin

También podemos tener múltiples constructores en Kotlin. A cuál de los muchos constructores llama el compilador se decide en función de los argumentos pasados.

Código de ejemplo:

fun main(args: Array<String>) {
    Student(11035, "David")
    Student(11047,"Steve","New York")
}

class Student {

    constructor (std_id : Int, std_name: String ) {
        var id: Int = std_id
        var name: String = std_name
        print("Student's ID is: $id, ")
        println("Student's Name is: $name")
        println()
    }

    constructor (std_id : Int, std_name: String, std_city: String) {
        var id: Int = std_id
        var name: String = std_name
        var city: String = std_city
        print("Student's ID is: $id, ")
        print("Student's Name is: $name, ")
        println("Student's City is: $city")
    }
}

Producción:

Llamar a un constructor secundario desde otro constructor secundario existente

Podemos llamar a un constructor secundario en Kotlin utilizando un constructor secundario existente. Necesitamos usar la función this().

Código de ejemplo:

fun main(args: Array<String>){
    Product(3,7)
}

class Product {
    // using this to call another secondary constructor
    constructor(x: Int,y:Int) : this(x,y,5) {
        var ProductOfTwo = x * y
        println("The product of the two integers is: $ProductOfTwo")
    }

    constructor(x: Int, y: Int,z: Int) {
        var ProductOfThree = x * y * z
        println("The product of the three integers is is: $ProductOfThree")
    }
}

Producción:

Llamar a un constructor secundario de la clase principal Desde un constructor secundario en la clase secundaria

Además de llamar a un constructor secundario desde otro, también podemos llamar al constructor secundario de una clase principal desde el constructor de la clase secundaria. Es similar a la herencia.

Necesitamos usar la palabra clave super para heredar el constructor.

Código de ejemplo:

fun main(args: Array<String>) {
    childClass(11035, "David")
}

open class parentClass {

    constructor (std_id : Int, std_name: String, std_city: String) {
        var id: Int = std_id
        var name: String = std_name
        var city: String = std_city
        print("Student's ID is: $id, ")
        print("Student's Name is: $name, ")
        println("Student's City is: $city")
        println()
    }
}

class childClass : parentClass {

    constructor (std_id : Int, std_name: String):super(std_id,std_name,"New York"){
        var id: Int = std_id
        var name: String = std_name
        print("Student's ID is: $id, ")
        println("Student's Name is: $name")
    }
}

Producción: