Unterschied zwischen Kotlin Init und Konstruktoren

1. Kotlin-Konstruktoren
2. Kotlin init

Kotlin ist eine objektorientierte Programmiersprache (OOP). Konstruktoren und init-Blöcke sind wichtige Bestandteile dieser Android-Programmiersprache.

Dieser Artikel befasst sich mit dem Unterschied zwischen diesen beiden Komponenten.

Kotlin-Konstruktoren

Wie der Name schon sagt, helfen Kotlin-Konstruktoren beim Erstellen von Klassen. Klassen sind die Basis einer OOP-Sprache.

In Kotlin gibt es zwei Arten von Konstruktoren, primäre und sekundäre. Jede Klasse kann einen primären und beliebig viele sekundäre Konstruktoren haben, die mit dem Schlüsselwort constructor definiert werden.

Kotlin-Primärkonstruktoren

Der primäre Konstruktor in Kotlin ist immer Teil des Klassenheaders. Es kann optionale Parameter haben.

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

Sie fragen sich vielleicht, warum viele Klassen ohne Verwendung des Schlüsselworts constructor deklariert werden, wenn jeder Klassenheader einen primären Konstruktor hat.

Sie können das Schlüsselwort weglassen, wenn Sie keine Zugriffsmodifikatoren oder Anmerkungen mit dem primären Konstruktor verwenden möchten.

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

Da der primäre Konstruktor Teil des Klassenheaders ist, kann er keinen Code enthalten. Wir können den Code mit dem Schlüsselwort init in die Initialisierungsblöcke einfügen, mehr dazu später in diesem Artikel.

Während das Schreiben von Code nicht erlaubt ist, können wir primäre Konstruktoreigenschaften mit diesen Syntaxen deklarieren und initialisieren:

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

ODER

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

Wir können auch den Standardwert einer Eigenschaft im primären Konstruktor deklarieren:

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

Kotlin-Sekundärkonstruktoren

Neben dem primären Konstruktor können wir mit dem Schlüsselwort constructor auch einen oder mehrere sekundäre Konstruktoren deklarieren.

Alle sekundären Konstruktoren einer Klasse sollten mit dem Schlüsselwort this an den primären Konstruktor delegieren. Hier ist ein Beispiel für die Verwendung des sekundären Konstruktors in 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.")
    }
}

Ausgang:

Code ausführen

Kotlin init

Das Kotlin-Schlüsselwort init wird zum Schreiben von Initialisierungsblöcken verwendet. Diese Blöcke helfen beim Schreiben von Codes für den primären Konstruktor.

Wir können keinen Code im primären Konstruktor schreiben, da er Teil des Klassenheaders ist. Daher können wir dafür einen sekundären Konstruktor oder Initialisierungsblöcke verwenden.

Wir können auch die Parameter und Eigenschaften des primären Konstruktors in den init-Blöcken von Kotlin verwenden.

Schauen wir uns ein Beispiel an, in dem wir prüfen, ob die angegebene Zahl größer als 50 ist oder den Kotlin-Block init nicht verwendet.

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)
}

Ausgang:

Code ausführen

Da die Codes in Kotlin-init-Blöcken als Teil des primären Konstruktors geschrieben werden, werden sie zu einem Teil davon.

Und da die Delegation des sekundären Konstruktors mit dem primären Konstruktor das erste ist, was während der Ausführung des ersteren getan wird, werden die init-Blöcke vor den Funktionen des sekundären Konstruktors ausgeführt.

Hier ist ein Beispielcode. In diesem Code haben wir den sekundären Konstruktorcode über Kotlin init geschrieben; Der init-Code wird jedoch zuerst ausgeführt.

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

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

fun main() {
    Person(1)
}

Ausgang:

Code ausführen