Constructeurs en Kotlin (Constructor)

Dans cet article, vous découvrirez les constructeurs en Kotlin (constructeur principal et constructeur secondaire) et les blocs d'initialisation, à l'aide d'exemples.

Les constructeurs sont une méthode concise pour initialiser les propriétés de la classe.

C'est une fonction membre spéciale qui est appelée lors de l'instanciation (création) d'un objet. Mais, ils fonctionnent légèrement différemment en Kotlin.

Dans Kotlin, il y a deux constructeurs :

• constructeur principal - méthode concise d'initialisation de la classe

• constructeur secondaire - permet de placer d'autres logiques d'initialisation

constructeur principal

Le constructeur principal fait partie de l'en-tête de la classe. Voici un exemple :

class Person(val firstName: String, var age: Int) {
　　　　//　corps de la classe
}

Le code entre crochets est le constructeur principal : (val firstName: String, var age: Int).

Le constructeur principal déclare deux propriétés : firstName (propriété lecture seule, car elle est déclarée avec le mot-clé val) et age (propriété lecture-écriture, car elle est déclarée avec le mot-clé var).

Exemple : constructeur principal

fun　main(args:　Array<String>)　{
　　　　val person1　= Person("Joe",　25)
　　　　println("First Name = ${person1.firstName})
　　　　println("Age = ${person1.age})
}
class Person(val firstName: String, var age: Int) {
}

Lors de l'exécution du programme, la sortie est :

First　Name　=　Joe
Age　=　25

Lors de la création d'un objet de la classe Person, les valeurs Joe et 25，comme si Person était une fonction.

Ce qui rendra person1 Les propriétés firstName et age de l'objet sont initialisées respectivement à "Joe" et 25。

Il existe d'autres méthodes pour utiliser le constructeur principal.

Constructeur principal et bloc d'initialisation

La syntaxe du constructeur principal est limitée et ne peut pas contenir de code.

Pour placer le code d'initialisation (non seulement le code des propriétés d'initialisation), on utilise un bloc d'initialisation. Il commence par le mot-clé init. Permettons de modifier l'exemple précédent avec un bloc de déclaration d'initialisation :

fun　main(args:　Array<String>)　{
　　　　val person1　= Person("joe",　25)
}
class Person(fName: String, personAge: Int) {
　　　　val firstName: String
　　　　var age: Int
　　　　//Bloc d'initialisation
　　　　init {
　　　　　　　　firstName: fName.capitalize()
　　　　　　　　age: personAge
　　　　　　　　println("First Name = $firstName")
　　　　　　　　println("Age = $age")
　　　　}
}

Lors de l'exécution du programme, la sortie est :

First　Name　=　Joe
Age　=　25

ici, lors de la création de person1est créé, les paramètres fName et personAge dans les parenthèses acceptent respectivement les valeurs "Joe" et 25。Cependant, lorsque vous utilisez fName et personAge, il ne faut pas utiliser var ou val, et elles ne sont pas des propriétés de la classe Person.

La classe Person déclare deux propriétés firstName et age.

lorsque person1L'objet est créé, le code du bloc d'initialisation est exécuté. Le bloc d'initialisation n'initialise pas seulement ses propriétés, mais les affiche également.

Voici une autre méthode pour accomplir la même tâche :

fun　main(args:　Array<String>)　{
　　　　val person1　= Person("joe",　25)
}
class Person(fName: String, personAge: Int) {
　　　　val firstName: fName.capitalize()
　　　　var age: personAge
　　　　//Bloc d'initialisation
　　　　init {
　　　　　　　　println("First Name = $firstName")
　　　　　　　　println("Age = $age")
　　　　}
}

Pour distinguer les paramètres du constructeur et les propriétés, des noms différents ont été utilisés (fName et FirstName, ainsi que Personage et age). Pour les paramètres du constructeur, il est plus courant d'utiliser _firstName et _age plutôt que des noms complètement différents. Par exemple :

class Person(_firstName: String, _age: Int) {
　　　　val firstName: _firstName.capitalize()
　　　　var age: _age
　　　　//　Bloc d'initialisation
　　　　init {
　　　　　　　　...　..　...
　　　　}
}

Les valeurs par défaut dans le constructeur principal

Vous pouvez fournir des valeurs par défaut pour les paramètres du constructeur (similaire à fournirParamètres par défaut）。Par exemple :

fun　main(args:　Array<String>)　{
　　　　println("person1　est实例isée
　　　　val person1　= Person("joe",　25)
　　　　println("person2　est实例isée
　　　　val person2　= Person("Jack")
　　　　println("person3　est实例isée
　　　　val person3　= Person()
}
class Person(_firstName: String = "UNKNOWN", _age: Int = 0) {
　　　　val firstName: _firstName.capitalize()
　　　　var age: _age
　　　　//Bloc d'initialisation
　　　　init {
　　　　　　　　println("First Name = $firstName")
　　　　　　　　println("Age = $age\n")
　　　　}
}

Lors de l'exécution du programme, la sortie est :

First　Name　=　Joe
Age　=　25
person2　est实例化
First　Name　=　Jack
Age　=　0
person3　est实例化
First　Name　=　UNKNOWN
Age　=　0

Constructeurs secondaires en Kotlin

En Kotlin, une classe peut également inclure un ou plusieurs constructeurs secondaires. Ils sont créés en utilisant le mot-clé constructor.

Les constructeurs secondaires ne sont pas courants en Kotlin. Ils apparaissent le plus souvent lorsque vous avez besoin d'étendre une classe qui fournit plusieurs constructeurs d'initialisation différents. Avant d'apprendre cela, assurez-vous de comprendreHéritage en Kotlin。

Vous pouvez créer des constructeurs secondaires en Kotlin de la manière suivante :

class　Log　{
　　　　constructor(data:　String)　{
　　　　　　　　//　Quelques lignes de code
　　　　}
　　　　constructor(data:　String,　numberOfData:　Int)　{
　　　　　　　　//　Quelques lignes de code
　　　　}
}

Ici, la classe Log possède deux constructeurs secondaires, mais pas de constructeur principal.

Vous pouvez étendre la classe comme suit :

class　Log　{
　　　　constructor(data:　String)　{
　　　　　　　　//　Code
　　　　}
　　　　constructor(data:　String,　numberOfData:　Int)　{
　　　　　　　　//　Code
　　　　}
}
class AuthLog: Log {
　　　　constructor(data:　String):　super(data)　{
　　　　　　　　//　Code
　　　　}
　　　　constructor(data:　String,　numberOfData:　Int):　super(data,　numberOfData)　{
　　　　　　　　//　Code
　　　　}
}

Ici, le constructeur du sous-classe AuthLog appelle le constructeur correspondant de la classe mère Log. Pour cela, utilisez super().

En Kotlin, vous pouvez également utiliser this() pour appeler un autre constructeur de la même classe (comme en Java).

class AuthLog: Log {
　　　　constructor(data:　String):　this(data,　10) {
　　　　　　　　//　Code
　　　　}
　　　　constructor(data:　String,　numberOfData:　Int):　super(data,　numberOfData)　{
　　　　　　　　//　Code
　　　　}
}

Exemple: Constructeur secondaire en Kotlin

fun　main(args:　Array<String>)　{
　　　　val　p1　=　AuthLog("Mauvais　Mot　de　Passe")
}
open　class　Log　{
　　　　var　data:　String　=　""
　　　　var　numberOfData　=　0
　　　　constructor(_data:　String)　{
　　　　}
　　　　constructor(_data:　String,　_numberOfData:　Int)　{
　　　　　　　　data　=　_data
　　　　　　　　numberOfData　=　_numberOfData
　　　　　　　　println("$data:　$numberOfData　fois")
　　　　}
}
class AuthLog: Log {
　　　　constructor(_data: String): this("From AuthLog　-> "　+　_data,　10) {
　　　　}
　　　　constructor(_data: String, _numberOfData: Int): super(_data, _numberOfData) {
　　　　}
}

Lors de l'exécution du programme, la sortie est :

From AuthLog　->　Mauvais mot de passe :　10　times

Remarque :Si une classe n'a pas de constructeur principal, le constructeur secondaire doit initialiser la classe mère ou le délégué avec un autre constructeur (comme dans l'exemple ci-dessus).