Constructeurs à Kotlin

Question

J'apprends Kotlin de documents officiels, j'ai créé un class comme ci-dessous, où j'ai créé un constructor qui a deux parameters . Le corps de constructor est en bloc init .

 class Person(name: String, surname: String) {
    init {
        Log.d("App", "Hello");
    }
}
 

Eh bien, je veux créer encore un constructor qui prendra un parameter dans un constructor . Quel est le chemin à faire en Kotlin

Answer 1

Bien init n'est pas le corps du constructeur. Il est appelé après que le principal constructeur avec le contexte de la primaire constructeur.

Comme indiqué dans la documentation Officielle:

Le principal constructeur ne peut pas contenir n'importe quel code. Code d'initialisation peut être placé dans l'initialiseur de blocs, qui sont préfixés avec l'init mot-clé:

class Customer(name: String) {
    init {
        logger.info("Customer initialized with value ${name}")
    }
}

Notez que les paramètres de la primaire constructeur peut être utilisé dans l'initialiseur de blocs. Ils peuvent également être utilisés dans bien des initialiseurs déclarée dans le corps de la classe:

class Customer(name: String) {
    val customerKey = name.toUpperCase()
}

En fait, pour la déclaration des propriétés et de l'initialisation de la première constructeur, Kotlin a une syntaxe concise:

class Person(val firstName: String, val lastName: String, var age: Int) {
    // ...
}

---

Que par votre question, vous pouvez ajouter un constructeur à accepter un paramètre comme suit:

class Person(name: String, surname: String) {

    constructor(name: String) : this(name, "") {
        // constructor body
    }

    init {
        Log.d("App", "Hello");
    }
}

Mais il n'est pas bon que nous sommes inutiles en passant deuxième argument une chaîne vide. Donc, nous pouvons commander constructeur comme suit:

class Person(name: String) {

    constructor(name: String, surname: String) : this(name) {
        // constructor body
    }

    init {
        Log.d("App", "Hello");
    }
}

Espérons que cela aide.

Answer 2

Première façon de le faire avec des valeurs vides

// (name: String, surname: String)  default constructor signature
class Person(name: String, surname: String) {

    // init block , represents the body of default constructor 
    init {
        Log.d("primary", "Hello");
    }

    // secondary constructor 
    // this(name,"") call to default constructor
    constructor(name : String):this(name,""){
        Log.d("secondary", "Hello");
    }
}

pourquoi this(name,"")

Si la classe possède un constructeur, chaque deuxième constructeur doit déléguer à la primaire constructeur, soit directement, soit indirectement par l'intermédiaire d'un autre secondaire constructeur(s). Délégation à un autre constructeur de la même classe se fait en utilisant le mot-clé this:

ou

kotlin, ne permettra pas d'utiliser null comme this(name,null) donc utiliser ? pour représenter null des valeurs de type, surname: String?

class Person(name: String, surname: String?) {

    init {
        Log.d("primary", "Hello");
    }

    constructor(name : String):this(name,null){
        Log.d("secondary", "Hello");
    }
}

Answer 3

À l'intérieur de la classe constructor mot-clé pour créer secondaire constructeur. Comme :

class Person(name: String, surname: String) {
    init {
        Log.d("App", "Hello");
    }
    constructor(id: Int) {

    }
}

Pour plus d'informations, consultez Secondaire Constructeurs

EDIT:
La règle : Si la classe possède un constructeur, chaque constructeur doit déléguer à la primaire constructeur, soit directement, soit indirectement par l'intermédiaire d'un autre secondaire constructeur(s). La délégation à un autre constructeur de la même classe se fait en utilisant le mot-clé this.

class Person(val name: String) {
    constructor(name: String, parent: Person) : this(name) {
        parent.children.add(this)
    }
}

Ainsi, lorsque vous appelez secondaire constructeur, il appelle principal constructeur pour initialiser nom et après que vous faites vos trucs dans le secondaire constructeur. Dans l'exemple ci-dessus le nom est initialisé par l'appel principal constructeur.

Answer 4

Secondaire Constructeurs

La classe peut également déclarer secondaire constructeurs, qui sont préfixés par le constructeur:

class Person {
    constructor(parent: Person) {
        parent.children.add(this)
    } } 

Si la classe possède un constructeur, chaque constructeur doit déléguer à la primaire constructeur, soit directement, soit indirectement par l'intermédiaire d'un autre secondaire constructeur(s). La délégation à un autre constructeur de la même classe se fait en utilisant le mot-clé this:

class Person(val name: String) {
    constructor(name: String, parent: Person) : this(name) {
        parent.children.add(this)
    } }

voir https://kotlinlang.org/docs/reference/classes.html Secondaire Constructeurs partie

Answer 5

Voici comment créer un autre constructeur.

 class Person(name: String, surname: String) {
    init {
        Log.d("App", "Hello");
    }
 constructor(id: Int) : this("example name", "example surname") {

}
}
 

Rappelez-vous toujours que le constructeur secondaire devra référencer le constructeur principal et ses paramètres à l'aide du mot-clé this.