17/06/2021 Classes | Kotlin

Regardez l'enregistrement de l'événement Kotlin 1.5 !

v1.5.10 Solutions Documents Communauté Apprendre Jouer

Des classes
Modifier la page Dernière modification : 11 mai 2021

Les classes en Kotlin sont déclarées à l'aide du mot-clé class :

class Person { /*...*/ }

La déclaration de classe se compose du nom de la classe, de l'en-tête de la classe (spécifiant ses

paramètres de type, le constructeur principal, etc.) et le corps de la classe, entourés d'accolades. L'en-
tête et le corps sont facultatifs ; si la classe n'a pas de corps, les accolades peuvent être omises.

class Empty

Constructeurs
Une classe dans Kotlin peut avoir un constructeur principal et un ou plusieurs constructeurs secondaires .
Le constructeur principal fait partie de l'en-tête de classe : il va après le nom de la classe (et les
paramètres de type facultatifs).

class Person constructor(firstName: String) { /*...*/ }

Si le constructeur principal n'a pas d'annotations ou de modificateurs de visibilité, le constructor

mot - clé peut être omis :

https://kotlinlang.org/docs/classes.html#constructors 1/7
17/06/2021 Classes | Kotlin

class Person(firstName: String) { /*...*/ }

Le constructeur principal ne peut contenir aucun code. Le code d'initialisation peut être placé dans des
blocs d'initialisation , qui sont préfixés par le init mot - clé.

Lors d'une initialisation d'instance, les blocs d'initialisation sont exécutés dans le même ordre qu'ils
apparaissent dans le corps de la classe, entrelacés avec les initialiseurs de propriété :

class InitOrderDemo ( nom : String ) {

val firstProperty = "Première propriété : $name" . aussi (:: println )

init {
println ( "Premier bloc d'initialisation qui imprime ${name}" )
}

val secondProperty = "Deuxième propriété : ${name.length}" . aussi (::

init {
println ( "Deuxième bloc d'initialisation qui imprime ${name.length}"
}
}

Première propriété : bonjour Premier bloc d'initialisation qui imprime bonjour Deux

Plateforme cible : JVM s'exécutant sur kotlin v. 1.5.0

Les paramètres du constructeur principal peuvent être utilisés dans les blocs d'initialisation. Ils peuvent
également être utilisés dans les initialiseurs de propriétés déclarés dans le corps de la classe :

class Customer(name: String) {

val customerKey = name.uppercase()
}

Kotlin a une syntaxe concise pour déclarer les propriétés et les initialiser à partir du constructeur
principal :

https://kotlinlang.org/docs/classes.html#constructors 2/7
17/06/2021 Classes | Kotlin

class Person(val firstName: String, val lastName: String, var age: Int)

De telles déclarations peuvent également inclure des valeurs par défaut des propriétés de classe :

class Person(val firstName: String, val lastName: String, var isEmployed:

Vous pouvez utiliser une virgule de fin lorsque vous déclarez des propriétés de classe :

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

De la même manière que les propriétés normales, les propriétés déclarées dans le constructeur
principal peuvent être modifiables ( var ) ou en lecture seule ( val ).

Si le constructeur a des annotations ou des modificateurs de visibilité, le constructor mot-clé est

obligatoire et les modificateurs le précèdent :

class Customer public @Inject constructor(name: String) { /*...*/ }

En savoir plus sur les modificateurs de visibilité .

Constructeurs secondaires
La classe peut également déclarer des constructeurs secondaires , qui sont préfixés par constructor :

class Person(val pets: MutableList<Pet> = mutableListOf())

class Pet {

https://kotlinlang.org/docs/classes.html#constructors 3/7
17/06/2021 Classes | Kotlin

constructor(owner: Person) {
owner.pets.add(this) // adds this pet to the list of its owner's
}
}

Si la classe a un constructeur principal, chaque constructeur secondaire doit déléguer au constructeur

principal, directement ou indirectement via un ou plusieurs autres constructeurs secondaires. La
délégation à un autre constructeur de la même classe se fait à l'aide du this mot clé :

class Person(val name: String) {

var children: MutableList<Person> = mutableListOf()
constructor(name: String, parent: Person) : this(name) {
parent.children.add(this)
}
}

Le code dans les blocs d'initialisation devient effectivement une partie du constructeur principal. La
délégation au constructeur principal se produit comme la première instruction d'un constructeur
secondaire, de sorte que le code dans tous les blocs d'initialisation et les initialiseurs de propriété est
exécuté avant le corps du constructeur secondaire.

Même si la classe n'a pas de constructeur principal, la délégation se produit toujours implicitement et
les blocs d'initialisation sont toujours exécutés :

Constructeurs de classe {
init {
println ( "Bloc d'initialisation" )
}

constructeur ( i : Int ) {
println ( "Constructeur $i" )
}
}

Bloc d'initialisation Constructeur 1

https://kotlinlang.org/docs/classes.html#constructors 4/7
17/06/2021 Classes | Kotlin

Plateforme cible : JVM s'exécutant sur kotlin v. 1.5.0

Si une classe non abstraite ne déclare aucun constructeur (primaire ou secondaire), elle aura un
constructeur primaire généré sans arguments. La visibilité du constructeur sera publique.

Si vous ne voulez pas que votre classe ait un constructeur public, déclarez un constructeur primaire vide
avec une visibilité autre que celle par défaut :

class DontCreateMe private constructor () { /*...*/ }

Sur la JVM, si tous les paramètres du constructeur principal ont des valeurs par défaut, le
compilateur générera un constructeur supplémentaire sans paramètre qui utilisera les
valeurs par défaut. Cela facilite l'utilisation de Kotlin avec des bibliothèques telles que
Jackson ou JPA qui créent des instances de classe via des constructeurs sans paramètre.

class Customer(val customerName: String = "")

Création d'instances de classes

Pour créer une instance d'une classe, appelez le constructeur comme s'il s'agissait d'une fonction
normale :

val invoice = Invoice()

val customer = Customer("Joe Smith")

Kotlin n'a pas de new mot - clé.

La création d'instances de classes internes imbriquées, internes et anonymes est décrite dans Classes
imbriquées .

https://kotlinlang.org/docs/classes.html#constructors 5/7
17/06/2021 Classes | Kotlin

Membres de la classe
Les cours peuvent contenir :

• Constructeurs et blocs d'initialisation

• Les fonctions

• Propriétés

• Classes imbriquées et internes

• Déclarations d'objets

Héritage
Les classes peuvent être dérivées les unes des autres et former des hiérarchies d'héritage. En savoir plus
sur l'héritage dans Kotlin .

Cours abstraits
Une classe et certains de ses membres peuvent être déclarés abstract . Un membre abstrait n'a pas
d'implémentation dans sa classe. Vous n'avez pas besoin d'annoter une classe ou une fonction abstraite
avec open .

Vous pouvez remplacer un open membre non abstrait par un membre abstrait.

open class Polygon {

open fun draw() {}
}

abstract class Rectangle : Polygon() {

https://kotlinlang.org/docs/classes.html#constructors 6/7
17/06/2021 Classes | Kotlin

abstract override fun draw()

}

Objets compagnons
Si vous devez écrire une fonction qui peut être appelée sans avoir d'instance de classe mais a besoin
d'accéder aux éléments internes d'une classe (par exemple, une méthode de fabrique), vous pouvez
l'écrire en tant que membre d'une déclaration d'objet à l' intérieur de cette classe.

Plus précisément encore, si vous déclarez un objet compagnon à l' intérieur de votre classe, vous
pouvez accéder à ses membres en utilisant uniquement le nom de la classe comme qualificatif.

https://kotlinlang.org/docs/classes.html#constructors 7/7