TOC

Constructeurs Kotlin

Kotlin Constructeurs

1. Vue d'ensemble

Dans ce didacticiel, nous allons examiner en détail les constructeurs dans Kotlin.

Commençons par un bref récapitulatif du concept: nous utilisons des constructeurs pour créer des objets. Celles-ci ressemblent à des déclarations de méthode, mais ont toujours le même nom que la classe et ne renvoient rien.

Pour la configuration d'un projet Kotlin, jetez un œil à nosintroductory tutorial.

Dans Kotlin, une classe peut avoir un constructeur principal et un ou plusieurs constructeurs secondaires supplémentaires.

Dans les sections suivantes, nous passerons en revue chaque type et les concepts associés.

2. Constructeur Primaire

La première façon de créer un objet dans Kotlin consiste à utiliser un constructeur principal.

Les paramètresThis is a part of the class header. peuvent également être des champs de classe, que nous plaçons après la déclaration de classe.

Examinons une déclaration de classe de base, avec deux propriétés et un constructeur principal: 

class Person constructor(val name: String, val age: Int? = null)

Dans cet exemple, nous avons déclaré des propriétés via le mot cléval . Cela se comporte de la même manière que les variables régulières, avec la mention que les propriétés deval sont en lecture seule (contrepartie Javafinal keyword).

Si nous voulons changer la référence plus tard, nous devons utiliser le mot clévar à la place. Cependant, nous ne pouvons pas omettre le type de champ dans le constructeur principal, car il doit être explicite.

In some cases, we can omit the constructor keyword. Ceci n'est obligatoire que dans deux cas: lorsque nous utilisons des annotations, comme@Autowired ou des modificateurs d'accès, commeprivate ouprotected.

Nous pouvons également utiliser les paramètres par défaut de Kotlin dans les constructeurs.

Voyons ensuite comment nous pouvons utiliser notre constructeur principal: 

val person = Person("John")
val personWithAge = Person("Mark", 22)

On peut voir quea class name is a constructor invocation. There’s no need to use the new keyword.

Pour référence, examinons également l'équivalent Java d'une déclaration de constructeur: 

class PersonJava {
    final String name;
    final Integer age;

    public PersonJava(String name) {
        this.name = name;
        this.age = null;
    }

    public PersonJava(String name, Integer age) {
        this.name = name;
        this.age = age;
    }
}

Comme vous pouvez le constater, Java aurait besoin de beaucoup plus de code pour obtenir le même résultat.

2.1. Constructeurs primaires sur la machine virtuelle Java

Veuillez noter que le compilateur générera un constructeur supplémentaire sans paramètres sur la machine virtuelle Java. À cette fin, il instanciera un objet avec des valeurs par défaut.

De cette façon, Kotlin peut fonctionner avec des bibliothèques telles que Jackson ou JPA, qui utilisent le constructeur no-args pour créer des instances de classe: 

class Person(val name: String = "")

3. Initialisation des propriétés à partir des paramètres du constructeur

Les initialiseurs de propriété du corps de la classe peuvent utiliser les paramètres du constructeur principal.

Transformonsname en propriétéupperCaseName: 

class Person(val name: String, val age: Int? = null) {
    val upperCaseName: String = name.toUpperCase()
}

Nous pouvons voir la sortie dans la console en ajoutant le deuxième blocinit: 

init {
    println("Upper case name is $upperCaseName")
}

4. Blocs d'initialisation

Nous ne pouvons mettre aucun code dans le constructeur principal.

Cependant, nous devons parfois exécuter du code d'initialisation. Un bon endroit pour cela est un bloc d'initialisation, qui est préfixé avec le mot-cléinit.

The initializer block is called after the primary constructor. Nous pouvons également accéder aux champs de classe à cet endroit.

Une classe peut avoir un ou plusieurs blocsinit.

Ajoutons le bloc d'initialisation à notre classePerson: 

init {
    println("Hello, I'm $name")
    if (surname.isEmpty()) {
        throw IllegalArgumentException("Surname cannot be empty!")
    }
}

Ensuite, lorsque nous créons un objet de classePerson, nous verrons dans la console: 

Hello, I'm John

Nous lancerionsIllegalArgumentException pour lessurname. vides

Quand nous avons de nombreux blocsinit , ils seront exécutés dans le même ordre qu'ils apparaissent dans le corps de la classe.

5. Constructeur Secondaire

Dans une classe Kotlin, nous pouvons également déclarer un ou plusieurs constructeurs secondaires.Secondary constructors are prefixed with the constructor keyword: 

class Car {
    val id: String
    val type: String

    constructor(id: String, type: String) {
        this.id = id
        this.type = type
    }
}

Et l'utilisation de base: 

fun main(args: Array) {
    val car = Car("1", "sport")
    val suvCar = Car("2", "suvCar")
}

Each secondary constructor has to delegate to the primary constructor. Nous allons le faire parthis keyword.

Déplaçons nos propriétés vers lesprimary constructor et modifions lessecondary constructor: 

class Car(val id: String, val type: String) {
    constructor(id: String): this(id, "unknown")
}

6. Constructeurs et héritage

Nous pouvons utiliser un constructeur primaire de la super-classe.

Notez que toutes les classes de Kotlin sontfinal par défaut. Cela signifie que nous devrons ajouter le mot-cléopen pour pouvoir hériter de notre classePerson.

Ajoutons une classeEmployee qui hérite de la classePerson . Ils utilisent tous deux des constructeurs primaires: 

class Employee(name: String, val salary: Int): Person(name)

En faisant cela, nous passons unname au constructeur principal dePerson class. De plus, nous ajoutons un nouveau champ appelésalary dans la classeEmployee.

7. Conclusion

Dans cet article rapide, nous avons discuté des différentes manières de créer des constructeurs en kotlin. Nous pouvons instancier nos champs de différentes manières, selon nos souhaits.

L'implémentation de tous nos exemples peut être trouvée dansthe Github project.

Pour plus d'informations sur les fonctionnalités de Kotlin, veuillez consulter nosintroduction to Kotlin.

Related