Diferencia entre Kotlin Init y Constructores

1. Constructores Kotlin
2. Kotlin inicio

Kotlin es un lenguaje de programación orientado a objetos (POO). Los constructores y los bloques init son componentes vitales de este lenguaje de programación de Android.

Este artículo analizará la diferencia entre estos dos componentes.

Constructores Kotlin

Como su nombre indica, los constructores de Kotlin ayudan en la construcción de clases. Las clases son la base de un lenguaje OOP.

En Kotlin, hay dos tipos de constructores, primarios y secundarios. Cada clase puede tener un constructor primario y cualquier número de constructores secundarios definidos usando la palabra clave constructor.

Constructores primarios de Kotlin

El constructor principal en Kotlin siempre es parte del encabezado de la clase. Puede tener parámetros opcionales.

class exampleClass public constructor(str: String, i: Int){
    //functions
}

Quizás se pregunte, si cada encabezado de clase tiene un constructor principal, ¿por qué muchas clases se declaran sin usar la palabra clave constructor?

Puede omitir la palabra clave si no desea utilizar modificadores de acceso o anotaciones con el constructor principal.

class exampleClass (str: String, i: Int){
    //functions
}

Dado que el constructor principal es parte del encabezado de la clase, no puede tener ningún código. Podemos poner el código en los bloques inicializadores usando la palabra clave init, más sobre eso más adelante en este artículo.

Si bien no se permite escribir un código, podemos declarar e inicializar las propiedades del constructor primario usando estas sintaxis:

class exampleClass (val str: String, var i: Int){
    //functions
}

O

class exampleClass (
    val str: String,
    var i: Int,
){
    //functions
}

También podemos declarar el valor predeterminado de una propiedad en el constructor principal:

class exampleClass (val str: String, var i: Int = 15){
    //functions
}

Constructores secundarios de Kotlin

Además del constructor principal, también podemos declarar uno o varios constructores secundarios utilizando la palabra clave constructor.

Todos los constructores secundarios de una clase deben delegar en el principal utilizando la palabra clave this. Aquí hay un ejemplo del uso del constructor secundario en Kotlin.

fun main(args: Array<String>){
    var Stu = Student("Zack",17, "Kotlin")
    Stu.printStudentDetails()
}

// This is the primary constructor
class Student constructor(var firstName: String, var age: Int){
    var expert: String = "Nothing"

    // Creating a secondary constructor
    constructor (firstName: String, age: Int, expert: String): this(firstName,age){
        this.expert = expert
    }

    fun printStudentDetails(){
        println("$firstName, a $age years old student, is an expert in $expert.")
    }
}

Producción:

Ejecutar código

Kotlin inicio

La palabra clave init de Kotlin se usa para escribir bloques de inicialización. Estos bloques ayudan a escribir códigos para el constructor principal.

No podemos escribir código en el constructor principal ya que es parte del encabezado de la clase. Por lo tanto, podemos usar un constructor secundario o bloques inicializadores para eso.

También podemos usar los parámetros y propiedades del constructor principal en los bloques init de Kotlin.

Veamos un ejemplo en el que verificamos si el número dado es mayor que 50 o no usando el bloque init de Kotlin.

class Numbers(firstName: String, num2: Int) {
    var res = false
    val n1 = 50

    init {
        res = num2 > n1
    }
}

fun main(){
    var numbers = Numbers("This number is greater than 50", 63)
    println(numbers.res)
}

Producción:

Ejecutar código

Dado que los códigos en los bloques init de Kotlin se escriben como parte del constructor principal, se convierten en parte de él.

Y como la delegación del constructor secundario con el constructor primario es lo primero que se hace durante la ejecución del primero, los bloques init se ejecutan antes que las funciones de los constructores secundarios.

Aquí hay un código de ejemplo. En este código, hemos escrito el código del constructor secundario arriba de Kotlin init; sin embargo, el código init se ejecutará primero.

class Person {
    constructor(i: Int) {
        println("Person $i")
    }

    init {
        println("This part will execute before the secondary constructor's code.")
    }
}

fun main() {
    Person(1)
}

Producción:

Ejecutar código