Dans cet article, vous découvrirez les constructeurs dans Kotlin (à la fois les constructeurs principaux et secondaires) ainsi que les blocs d'initialisation à l'aide d'exemples.
Un constructeur est un moyen concis d'initialiser les propriétés de classe.
Il s'agit d'une fonction membre spéciale qui est appelée lorsqu'un objet est instancié (créé). Cependant, leur fonctionnement à Kotlin est légèrement différent.
Dans Kotlin, il existe deux constructeurs:
- Constructeur principal - moyen concis d'initialiser une classe
- Constructeur secondaire - vous permet de mettre une logique d'initialisation supplémentaire
Constructeur principal
Le constructeur principal fait partie de l'en-tête de classe. Voici un exemple:
class Person (val firstName: String, var age: Int) (// corps de la classe)
Le bloc de code entouré par des parenthèses est le constructeur principal: (val firstName: String, var age: Int).
Le constructeur a déclaré deux propriétés: firstName( propriété en lecture seule telle qu'elle est déclarée à l'aide d'un mot-clé val) et age(propriété en lecture-écriture telle qu'elle est déclarée avec un mot-clé var).
Exemple: constructeur principal
fun main(args: Array) ( val person1 = Person("Joe", 25) println("First Name = $(person1.firstName)") println("Age = $(person1.age)") ) class Person(val firstName: String, var age: Int) ( )
Lorsque vous exécutez le programme, la sortie sera:
Prénom = Joe Age = 25
Lorsque l'objet de la Personclasse est créé "Joe"et que les 25valeurs sont transmises comme s'il Persons'agissait d'une fonction.
Cela initialise firstNameet les agepropriétés de l'objet person1 à "Joe"et 25respectivement.
Il existe d'autres façons d'utiliser les constructeurs primaires.
Blocs de constructeur principal et d'initialisation
Le constructeur principal a une syntaxe contrainte et ne peut contenir aucun code.
Pour mettre le code d'initialisation (pas seulement le code pour initialiser les propriétés), un bloc d'initialisation est utilisé. Il est précédé d'un initmot-clé. Modifions l'exemple ci-dessus avec le bloc d'initialisation:
fun main(args: Array) ( val person1 = Person("joe", 25) ) class Person(fName: String, personAge: Int) ( val firstName: String var age: Int // initializer block init ( firstName = fName.capitalize() age = personAge println("First Name = $firstName") println("Age = $age") ) )
Lorsque vous exécutez le programme, la sortie sera:
First Name = Joe Age = 25
Ici, les paramètres fName et personAge à l'intérieur de la parenthèse acceptent les valeurs "Joe"et 25respectivement lorsque l'objet person1 est créé. Cependant, fName et personAge sont utilisés sans utiliser varou val, et ne sont pas des propriétés de la Personclasse.
La Personclasse a deux propriétés firstName et age sont déclarés.
Lorsque l' person1objet est créé, le code à l'intérieur du bloc d'initialisation est exécuté. Le bloc d'initialisation initialise non seulement ses propriétés, mais les imprime également.
Voici une autre façon d'effectuer la même tâche:
fun main(args: Array) ( val person1 = Person("joe", 25) ) class Person(fName: String, personAge: Int) ( val firstName = fName.capitalize() var age = personAge // initializer block init ( println("First Name = $firstName") println("Age = $age") ) )
Pour distinguer le paramètre et la propriété du constructeur, différents noms sont utilisés (fName et firstName, et personAge et age). Il est plus courant d'utiliser _firstName et _age au lieu d'un nom complètement différent pour les paramètres du constructeur. Par exemple:
class Person (_firstName: String, _age: Int) (val firstName = _firstName.capitalize () var age = _age // bloc d'initialisation init (…))
Valeur par défaut dans le constructeur principal
Vous pouvez fournir une valeur par défaut aux paramètres du constructeur (comme pour fournir des arguments par défaut aux fonctions). Par exemple:
fun main(args: Array) ( println("person1 is instantiated") val person1 = Person("joe", 25) println("person2 is instantiated") val person2 = Person("Jack") println("person3 is instantiated") val person3 = Person() ) class Person(_firstName: String = "UNKNOWN", _age: Int = 0) ( val firstName = _firstName.capitalize() var age = _age // initializer block init ( println("First Name = $firstName") println("Age = $age") ) )
Lorsque vous exécutez le programme, la sortie sera:
Prénom = Joe Âge = 25 personne2 est instanciée Prénom = Jack Âge = 0 personne3 est instanciée Prénom = INCONNU Âge = 0
Constructeur secondaire Kotlin
Dans Kotlin, une classe peut également contenir un ou plusieurs constructeurs secondaires. Ils sont créés à l'aide de constructormots-clés.
Les constructeurs secondaires ne sont pas si courants à Kotlin. L'utilisation la plus courante du constructeur secondaire survient lorsque vous devez étendre une classe qui fournit plusieurs constructeurs qui initialisent la classe de différentes manières. Assurez-vous de vérifier l'héritage de Kotlin avant de l'apprendre.
Voici comment vous pouvez créer un constructeur secondaire dans Kotlin:
class Log (constructeur (data: String) (// un certain code) constructeur (data: String, numberOfData: Int) (// un certain code))
Ici, la Logclasse a deux constructeurs secondaires, mais aucun constructeur principal.
Vous pouvez étendre la classe comme:
class Log (constructeur (data: String) (// code) constructeur (data: String, numberOfData: Int) (// code)) class AuthLog: Log (constructeur (data: String): super (data) (// code ) constructeur (data: String, numberOfData: Int): super (data, numberOfData) (// code))
Ici, les constructeurs de la classe dérivée AuthLogappellent le constructeur correspondant de la classe de base Log. Pour cela, super()est utilisé.
Dans Kotlin, vous pouvez également appeler un constructeur à partir d'un autre constructeur de la même classe (comme en Java) en utilisant this().
class AuthLog: Log (constructeur (data: String): this (data, 10) (// code) constructeur (data: String, numberOfData: Int): super (data, numberOfData) (// code))
Exemple: constructeur secondaire Kotlin
fun main(args: Array) ( val p1 = AuthLog("Bad Password") ) open class Log ( var data: String = "" var numberOfData = 0 constructor(_data: String) ( ) constructor(_data: String, _numberOfData: Int) ( data = _data numberOfData = _numberOfData println("$data: $numberOfData times") ) ) class AuthLog: Log ( constructor(_data: String): this("From AuthLog -> " + _data, 10) ( ) constructor(_data: String, _numberOfData: Int): super(_data, _numberOfData) ( ) )
Lorsque vous exécutez le programme, la sortie sera:
Depuis AuthLog -> Mot de passe incorrect: 10 fois
Remarque: le constructeur secondaire doit initialiser la classe de base ou déléguer à un autre constructeur (comme dans l'exemple ci-dessus) si la classe n'a pas de constructeur principal.
