Cours Kotlin

Introduction au Kotlin
Ahmed Fouad El ouafdi
Université Ibn Zohr

elouafdi@gmail.com
Programmation Android par Kotlin

December 12, 2023
Ahmed Fouad El ouafdi (UIZ) Short Title December 12, 2023 1 / 89

Introduction à la Programmation Android avec
Kotlin
• Objectif: Comprendre l’essentiel de la programmation

Android avec Kotlin.
• Android et Kotlin:
• Kotlin, langage officiellement soutenu par Google pour Android.
• Modernise le développement avec sa syntaxe concise et ses
fonctionnalités avancées.
• Avantages de Kotlin pour Android:
• Interopérabilité aisée avec le code Java existant.
• Réduction significative du code boilerplate.
• Garantit la sécurité des références nulles.
• Augmente l’expressivité et accélère le développement.

Principes Fondamentaux de la Programmation
Android avec Kotlin
• Structure d’une Application Android:

• Activités, fragments, et services.
• Interaction avec l’interface utilisateur (XML et Kotlin).
• Compréhension du cycle de vie des composants Android.
• Gestion des Ressources:
• Utilisation efficace des ressources (images, chaı̂nes, etc.).
• Organisation structurée dans le dossier ”res”.
• Intégration de Kotlin dans un Projet Android:
• Configuration du projet pour Kotlin.
• Passage aux fichiers sources avec l’extension .kt.
• Exemple Pratique:
• Développement d’une application Android simple avec Kotlin.
• Illustration des concepts pour une meilleure compréhension.

Adoption de Kotlin dans le Développement Android
• Depuis Google I/O en 2019, le développement mobile Android

est orienté vers Kotlin.
• Plus de 50 % des développeurs Android professionnels
utilisent Kotlin comme langage principal.
• Seulement 30 % utilisent Java comme langage principal.
• 70 des développeurs Kotlin estiment que Kotlin accroı̂t leur
productivité.

Avantages de Kotlin pour le Développement
Android
• Moins de code avec une lisibilité accrue.

• Apps Kotlin ont 20% moins de chances de crash, selon les
données internes de Google.
• Support de Kotlin dans les bibliothèques Jetpack.
• Jetpack Compose est recommandé pour la création d’UI native
en Kotlin.
• KTX ajoute des fonctionnalités Kotlin aux bibliothèques
Android existantes.

Caractéristiques de Kotlin pour le Développement
Android
• Support du développement multiplateforme.

• Kotlin Multiplatform permet le développement pour Android,
iOS, backend, et applications web.
• Jetpack Compose Multiplatform facilite le partage d’UIs sur
plusieurs plateformes.
• Langage mature et environnement robuste depuis sa création
en 2011.
• Intégration transparente dans Android Studio.
• Interopérabilité avec Java pour une transition en douceur.
• Facilité d’apprentissage, surtout pour les développeurs Java.
• Grande communauté avec plus de 95% des meilleures
applications Android utilisant Kotlin.

Programme de base
1 package org.kotlinlang.play // 1
2
3 fun main() { // 2
4 println("Hello, World!") // 3
5 }
Output : Hello, World!

1- Package en Kotlin : Le code Kotlin est généralement organisé
dans des packages. Spécifier un package est facultatif ; si aucun
n’est spécifié, le contenu va dans le package par défaut.
2- Point d’entrée de l’application Kotlin : Le point d’entrée d’une
application Kotlin est la fonction main. Depuis Kotlin 1.3, elle peut
être déclarée sans paramètres et sans spécifier le type de retour.
3-Utilisation de println : La fonction println écrit une ligne sur
la sortie standard. Elle est implicitement importée, et l’utilisation de
points-virgules est facultative.

Fonctions :Paramètres et arguments
1 fun printMessage(message: String): Unit {

// 1
2 println(message)
3 }
4
5 fun printMessageWithPrefix(message: String,
prefix: String = "Info") { // 2
6 println("[$prefix] $message")
7 }
1 Les fonctions Kotlin sont déclarées à l’aide du mot-clé fun

2 Fonction simple prenant un paramètre de type String et
renvoyant Unit (pas de valeur de retour explicite).
3 Fonction avec un deuxième paramètre optionnel ayant une
valeur par défaut ”Info”. Le type de retour est omis (Unit est
implicite).

Fonctions :Paramètres et arguments
1 fun sum(x: Int, y: Int): Int {

//
3
2 return x + y
3 }
4
5 fun multiply(x: Int, y: Int) = x * y
// 4
3 Fonction renvoyant un entier.

4 Fonction à expression unique renvoyant un entier (inféré).

Appel au fonctions

Fonction Infixe en Kotlin
1 // Définition d’une fonction infix

2 infix fun Int.ajouterAvec(autre: Int): Int {
3 return this + autre
4 }
5
6 // Utilisation de la fonction infix
7 val résultat = 5 ajouterAvec 3 // Équivalent à
5.ajouterAvec(3)
• Une fonction infix est une fonction membre ou une fonction

d’extension avec un seul paramètre.


4 }
5
5.ajouterAvec(3)

• Elle peut être appelée en utilisant la notation infix, qui élimine
le point et les parenthèses pour une syntaxe plus propre.


4 }
5
5.ajouterAvec(3)

• Elle peut être appelée en utilisant la notation infix, qui élimine
le point et les parenthèses pour une syntaxe plus propre.
• Dans l’exemple, ‘ajouterAvec‘ est une fonction infix permettant
‘5 ajouterAvec 3‘ au lieu de ‘5.ajouterAvec(3)‘.

Variables en Kotlin
Kotlin dispose d’une puissante déduction de type. Bien que vous

puissiez déclarer explicitement le type d’une variable, vous
laisserez généralement le compilateur faire le travail en l’inférant.
Kotlin n’impose pas l’immutabilité, bien que cela soit recommandé.
En essence, utilisez ‘val‘ plutôt que ‘var‘.
1 var a: String = "initial" // 1
2 println(a)
3 val b: Int = 1 // 2
4 val c = 3 // 3
• Déclare une variable mutable et l’initialise.

Variables en Kotlin

2 println(a)
3 val b: Int = 1 // 2
4 val c = 3 // 3

• Déclare une variable immuable et l’initialise.

Variables en Kotlin

2 println(a)
3 val b: Int = 1 // 2
4 val c = 3 // 3

• Déclare une variable immuable et l’initialise.
• Déclare une variable immuable et l’initialise sans spécifier le
type. Le compilateur infère le type Int.

Variables en Kotlin (Suite)
1 var e: Int // 1
2 println(e) // 2
• Déclare une variable sans initialisation.

1 var e: Int // 1
2 println(e) // 2

• Une tentative d’utiliser la variable provoque une erreur de
compilation : ”Variable ’e’ doit être initialisée.”

1 val d: Int // 1
2
3 if (someCondition()) {
4 d = 1 // 2
5 } else {
6 d = 2 // 2
7 }
8
9 println(d) // 3

1 val d: Int // 1
2
4 d = 1 // 2
5 } else {
6 d = 2 // 2
7 }
8
9 println(d) // 3

• Initialise la variable avec différentes valeurs en fonction d’une
condition.

1 val d: Int // 1
2
4 d = 1 // 2
5 } else {
6 d = 2 // 2
7 }
8
9 println(d) // 3

• Initialise la variable avec différentes valeurs en fonction d’une
condition.
• La lecture de la variable est possible car elle a déjà été
initialisée.

Null Safety en Kotlin (Partie 1)
Dans un effort pour éliminer les ‘NullPointerException‘, les types de
variables en Kotlin n’autorisent pas l’assignation de null. Si vous
avez besoin d’une variable qui peut être null, déclarez-la nullable
en ajoutant ? à la fin de son type.
1 var neverNull: String = "This can’t be null"
// 1
2
3 neverNull = null
// 2
4
5 var nullable: String? = "You can keep a null
here" // 3
• Déclare une variable String non-null.

// 1
2
3 neverNull = null
// 2
4
here" // 3

• Lors d’une tentative d’assignation de null à une variable
non-nullable, une erreur de compilation est produite.

// 1
2
3 neverNull = null
// 2
4
here" // 3

• Lors d’une tentative d’assignation de null à une variable
non-nullable, une erreur de compilation est produite.
• Déclare une variable String nullable.

1 var nullable: String? = "You can keep a null here" // 3

2
3 nullable = null // 4
4
5 var inferredNonNull = "The compiler assumes non-null" // 5
6
7 inferredNonNull = null // 6
• Affecte la valeur null à la variable nullable. C’est autorisé.


2
4
6

• Lors de l’inférence de types, le compilateur suppose non-null
pour les variables initialisées avec une valeur.


2
4
6

• Lors de l’inférence de types, le compilateur suppose non-null
pour les variables initialisées avec une valeur.
• Lors d’une tentative d’assignation de null à une variable avec
un type inféré, une erreur de compilation est produite.

Null Safety en Kotli
1 fun strLength(notNull: String): Int {

// 7
2 return notNull.length
3 }
4
5 strLength(neverNull)
// 8
6 strLength(nullable)
// 9
• Déclare une fonction avec un paramètre de type String

non-null.


// 7
3 }
4
// 8
// 9

non-null.
• Appelle la fonction avec un argument String (non-nullable).
C’est autorisé.


// 7
3 }
4
// 8
// 9

non-null.
• Appelle la fonction avec un argument String (non-nullable).
C’est autorisé.
• Lors de l’appel de la fonction avec un argument String?
(nullable), une erreur de compilation est produite.

Null Safety en Kotlin (Suite)
En Kotlin, l’opérateur ! ! (double point d’exclamation) est utilisé
pour forcer le déballage d’une valeur nullable, indiquant au
compilateur que vous êtes certain que la valeur n’est pas nulle.
1 val nullableValue: String? = getNullableValue()
2 val nonNullableValue: String = nullableValue!!
// 1
3
4 // Exemple concret
5 fun getLength(value: String?): Int {
6 return value!!.length // 2
7 }
• L’opérateur ! ! force le déballage d’une valeur nullable en une

valeur non-nullable.

Null Safety en Kotlin (Suite)
En Kotlin, l’opérateur ! ! (double point d’exclamation) est utilisé
pour forcer le déballage d’une valeur nullable, indiquant au
compilateur que vous êtes certain que la valeur n’est pas nulle.
1 val nullableValue: String? = getNullableValue()
2 val nonNullableValue: String = nullableValue!!
// 1
3
4 // Exemple concret
5 fun getLength(value: String?): Int {
6 return value!!.length // 2
7 }
• L’opérateur ! ! force le déballage d’une valeur nullable en une

valeur non-nullable.
• Exemple concret : la fonction ‘getLength‘ utilise l’opérateur ! !
pour obtenir la longueur d’une chaı̂ne nullable en toute
confiance.

Travailler avec Nulls en Kotlin
Pour travailler avec des valeurs null, Kotlin offre un suivi des nulls
pour traiter élégamment de telles situations.
1 fun describeString(maybeString: String?):
String { // 1
2 if (maybeString != null && maybeString.
length > 0) { // 2
3 return "Chaı̂ne de longueur ${
maybeString.length}"
4 } else {
5 return "Chaı̂ne vide ou null"
// 3
6 }
7 }
• Une fonction prenant une chaı̂ne nullable et renvoyant sa
description.

String { // 1
length > 0) { // 2
4 } else {
// 3
6 }
7 }
description.
• Si la chaı̂ne donnée n’est pas null et n’est pas vide, renvoie des
informations sur sa longueur.
String { // 1
length > 0) { // 2
4 } else {
// 3
6 }
7 }
description.
• Si la chaı̂ne donnée n’est pas null et n’est pas vide, renvoie des
informations sur sa longueur.
• Sinon, informe l’appelant que la chaı̂ne est vide ou null.
1 // Appel de la fonction describeString avec une

chaı̂ne non-null
2 val result1 = describeString("Hello, Kotlin!")
// 4
3
chaı̂ne nullable
5 val result2 = describeString(null)
// 5


chaı̂ne non-null
// 4
3
chaı̂ne nullable
// 5


chaı̂ne non-null
// 4
3
chaı̂ne nullable
// 5

• Exemple concret d’utilisation de la fonction ‘describeString‘ :

chaı̂ne non-null
// 4
3
chaı̂ne nullable
// 5
• Appel de la fonction ‘describeString‘ avec une chaı̂ne non-null.


chaı̂ne non-null
// 4
3
chaı̂ne nullable
// 5

• Appel de la fonction ‘describeString‘ avec une chaı̂ne nullable.


chaı̂ne non-null
// 4
3
chaı̂ne nullable
// 5


chaı̂ne non-null
// 4
3
chaı̂ne nullable
// 5


chaı̂ne non-null
// 4
3
chaı̂ne nullable
// 5


chaı̂ne non-null
// 4
3
chaı̂ne nullable
// 5


chaı̂ne non-null
// 4
3
chaı̂ne nullable
// 5

• Appel de la fonction ‘describeString‘ avec une chaı̂ne nullable.

Les classes
1 class Customer // 1
2
3 class Contact(val id: Int, var email: String) // 2
4 fun main() {
5 val customer = Customer() // 3
6 val contact = Contact(1, "marygmail.com") //
4println(contact.id) // 5contact.email = "janegmail.com"
7
8 // 6
9 }
1 Nom de la classe : La déclaration commence par spécifier le

nom de la classe.

Les classes
2
4 fun main() {
7
8 // 6
9 }

nom de la classe.
2 En-tête de la classe : Inclut les paramètres de type et le
constructeur principal.

Les classes
2
4 fun main() {
7
8 // 6
9 }

nom de la classe.
3 Corps de la classe : Contient les détails et les fonctionnalités de
la classe.

Les classes
2
4 fun main() {
7
8 // 6
9 }

nom de la classe.
3 Corps de la classe : Contient les détails et les fonctionnalités de
la classe.
4 Accolades : Le corps de la classe est entouré d’accolades.
Les classes: optionnalités
2
3 class Contact(val id: Int, var email: String)
// 2
4 fun main() {
6 val contact = Contact(1, "mary
gmail.com") // 4println(contact.id)
// 5contact.email = "janegmail.com"
7
8 // 6
9 }
1 Optionnalité de l’en-tête L’en-tête de la classe n’est pas

obligatoire.

2
// 2
4 fun main() {
7
8 // 6
9 }

obligatoire.
2 Optionnalité du corps : Le corps de la classe n’est pas
obligatoire.

2
// 2
4 fun main() {
7
8 // 6
9 }

obligatoire.
2 Optionnalité du corps : Le corps de la classe n’est pas
obligatoire.
3 Omission des accolades : Si la classe n’a pas de corps, les
accolades peuvent être omises.
Type de Données Générique
Un type de données générique est fourni lors de l’instanciation

d’une classe. Il doit donc être défini dans la signature de la classe.
Le nom de la classe est suivi d’un chevron ouvrant (>), puis d’un
nom d’espace réservé pour le type de données, et enfin d’un
chevron fermant (<).

Type de Données Générique:exemple
1 class Question<T>(
2 val questionText: String,
3 val answer: T,
4 val difficulty: String
5 )
Pour voir comment cela fonctionne avec plusieurs types de

questions (questions à trous, vrai ou faux, etc.), créez trois
instances de la classe Question dans main(), comme ci-dessous.

Heritage en Kotlin
L’héritage en Kotlin permet à une classe (appelée classe dérivée ou
sous-classe) d’hériter des caractéristiques d’une autre classe
(appelée classe de base ou superclasse). Voici un exemple simple
pour illustrer l’héritage en Kotlin :

Classe Abstraite en Kotlin
Définition :
• Une classe abstraite ne peut pas être instanciée directement.
• Elle sert de modèle pour d’autres classes, fournissant des
méthodes abstraites et des implémentations concrètes.
Caractéristiques :
• Contient des méthodes abstraites (non implémentées).
• Peut également contenir des méthodes concrètes
(implémentées).
• Nécessite une sous-classe pour fournir des implémentations
concrètes des méthodes abstraites.

Exemple - Formes Géométriques
Le mot-clé override en Kotlin est utilisé pour indiquer qu’une

fonction dans une classe dérive d’une fonction définie dans une
classe parente (ou dans une interface, dans le cas des méthodes
d’interface).
Classe Interface en Kotlin
Définition :
• Une interface est une structure Kotlin qui définit un ensemble
de méthodes (abstraites) et de propriétés.
• Une classe peut implémenter une ou plusieurs interfaces,
fournissant ainsi des implémentations concrètes de ces
méthodes.
Caractéristiques :
• Ne peut pas être instanciée directement.
• Une classe interface ne peut pas contenir de fonctions
implémentées (méthodes avec un corps) comme c’est le cas
pour les classes abstraites.
• Permet à une classe de déclarer qu’elle fournira une
implémentation pour un ensemble de méthodes spécifiées.

Exemple d’une Interface: Vehicule

Les instructions de contrôle : when
Kotlin propose la construction when, plus souple que switch case.
Elle peut être utilisée soit comme une instruction, soit comme une
expression.

Les instructions de contrôle : la boucle for
La boucle for dans Kotlin fonctionne de la même manière que dans

la plupart des langues.

Les instructions de contrôle : la boucle while et
do-while
while et do-whileles constructions fonctionnent également de la
même manière que la plupart des langages.

Les instructions de contrôle : la boucle for
La boucle for dans Kotlin fonctionne de la même manière que dans

la plupart des langues.

Les itérateurs
1 Un itérateur est un objet qui permet de parcourir tous les

éléments contenus dans un autre objet, le plus souvent un
conteneur (liste, arbre, etc).

Les itérateurs
1 Un itérateur est un objet qui permet de parcourir tous les

éléments contenus dans un autre objet, le plus souvent un
conteneur (liste, arbre, etc).
2 En Kotlin, la création d’un itérateur personnalisé se fait en
implémentant l’interface Iterator. L’interface Iterator définit
deux méthodes : next() pour obtenir l’élément suivant de la
séquence et hasNext() pour vérifier s’il y a un élément suivant.
Les itérateurs: Exemple

Les itérateurs: Exemple

Les propriétés de classe
Les propriétés (attribus) des classes Kotlin peuvent être déclarées
soit comme mutables, à l’aide du mot-clé var, soit en lecture seule,
à l’aide du mot-clé val.
Pour utiliser une propriété, il suffit de la référencer par son nom :

Syntaxe de Getters et Setters
• Syntaxe complète : var <propertyName>[:

<PropertyType>] [= <propertyInitializer>]
[<getter>] [<setter>]
• Exemple : var initialized = 1
Exemple de Déclaration avec Getters et Setters Personnalisés :
Dans cet exemple, le mot-clé field fait référence à la variable

sous-jacente stockant la valeur de la propriété.

Champs de sauvegarde
• Champ field utilisé dans les accesseurs.

• Exemple : var counter = 0
set(value) { if (value >= 0) field = value }

Propriétés en lecture seule
• Syntaxe : val simple: Int?

• Pas de setter autorisé.
• Accesseurs personnalisés possibles.

Late-Initialized Properties
• Propriétés non-nullable initialisées ultérieurement.

• lateinit var subject: TestSubject

Propriétés en lecture seule
• Syntaxe : val simple: Int?

• Pas de setter autorisé.
• Accesseurs personnalisés possibles.

Différences entre val et var
• Utilisez val pour déclarer une propriété en lecture seule

(immutable).
• Utilisez var pour déclarer une propriété mutable avec un
getter et un setter.
class Exemple {
val proprieteVal: Int = 42 // Lecture seule
var proprieteVar: String = "Mutable" // Mutable
}

En resumé
• Les getters et setters offrent un moyen de contrôler l’accès aux

propriétés d’une classe.
• Choisissez entre val et var en fonction de la mutabilité de la
propriété.
• Utilisez field pour accéder à la variable sous-jacente dans les
accesseurs personnalisés.
• Exploitez let pour effectuer des opérations sur la valeur d’une
propriété.

Classes spéciales : Data classes
• Les Data classes sont utilisées pour stocker des valeurs.

• Génèrent automatiquement des méthodes pour la copie,
l’obtention d’une représentation sous forme de chaı̂ne, et
l’utilisation d’instances dans des collections.
• Possibilité d’implémentations de ses méthodes dans la
déclaration de classe.
1 Définit une classe de données avec le modificateur data.

2 Remplace la méthode d’égalité par défaut en déclarant que
deux utilisateurs sont égaux s’ils ont le même identifiant.

Exemple: data classe

Enum Classes
Les classes énumérées (enum classes) sont utilisées pour
modéliser des types qui représentent un ensemble fini de valeurs
distinctes, telles que des directions, des états, des modes, etc.

Enum Classes
• Définit une simple classe énumérée avec trois constantes

énumérées. Le nombre de constantes est toujours fini et elles
sont toutes distinctes.
• Accède à une constante énumérée via le nom de la classe.

mot clé d’objet
Les classes et les objets dans Kotlin fonctionnent de la même
manière que dans la plupart des langages orientés objet : une
classe est un modèle et un objet est une instance d’une classe.
Habituellement, vous définissez une classe, puis créez plusieurs
instances de cette classe :

object Expression
• Une utilisation typique de base d’une expression d’objet : une
structure simple objet/propriétés.
• Il n’est pas nécessaire de le faire dans la déclaration de classe :
vous créez un seul objet, déclarez ses membres et y accédez
au sein d’une seule fonction.
• Des objets comme celui-ci sont souvent créés en Java en tant
qu’instances de classe anonymes.

object Declaration
• La déclaration d’objet est utilisée pour accéder directement à

ses membres
• La déclaration d’objet n’est pas une expression
• La déclaration d’objet ne peut pas être utilisé dans une
affectation de variable.

Companion object
• Il arrive parfois que nous devions utiliser un objet compagnon

(companion object) pour définir des membres de classe qui
seront utilisés indépendamment de toute instance de cette
classe. ( membres statiques en Java)

Companion object
• Il arrive parfois que nous devions utiliser un objet compagnon

(companion object) pour définir des membres de classe qui
seront utilisés indépendamment de toute instance de cette
classe. ( membres statiques en Java)
• Le compilateur Kotlin garantit que nous aurons une et une
seule instance de l’objet compagnon. Pour ceux d’entre nous
ayant une expérience en Java, un objet compagnon est
similaire aux déclarations statiques.

Companion object
• companion object est une déclaration d’objet à l’intérieur d’une
classe l’objet compagnon. Syntaxiquement
• companion object ressemble aux méthodes statiques de Java
• vous appelez les membres d’un objet en utilisant son nom de
classe comme qualificatif.

Companion object et héritage
1 Un objet compagnon
n’est pas héritable. Mais il
peut hériter d’une autre
classe ou implémenter
des interfaces.
2 Dans cet exemple,
MyClass a un objet
compagnon (companion
object) qui hérite de
BaseClass et implémente
ExampleInterface.
3 L’objet compagnon a sa
propre méthode
companionFunction.

Companion object et héritage
1 Un objet compagnon
n’est pas héritable. Mais il
peut hériter d’une autre
classe ou implémenter
des interfaces.
2 Dans cet exemple,
MyClass a un objet
compagnon (companion
object) qui hérite de
BaseClass et implémente
ExampleInterface.
3 L’objet compagnon a sa
propre méthode
companionFunction.

Classes imbriquées
• Kotlin permet de définir des classes imbriquées. Une classe

imbriquée est statique par défaut. Autrement dit, ne
contiennent pas de référence à la classe englobante.

Classes imbriquées
1 Une classe imbriquée Engine

à l’intérieur d’une classe Car.
On peut instancier
séparément Car et Engine.
En particulier, nous créons
une instance de Engine sans
fournir de référence à un
objet de type Car. Le seul
indice indiquant que Engine
est défini à l’intérieur de Car
est son nom qualifié,
Car.Engine. L’exemple
ci-dessus affiche ”Gasoline”
et ”SomeModel”.

Classes imbriquées internes
1 Une classe imbriquée

marquée comme
interne peut accéder
aux membres de sa
classe externe. Les
classes internes
portent une référence
à un objet d’une
classe externe :

Classes de valeur en ligne (Inline Class)
1 Parfois, nous créons des wrappers pour fournir une certaine
logique métier.
2 Cependant, ces classes supplémentaires entraı̂nent une perte
de performances en créant des charges supplémentaires lors
de l’exécution.
3 Si le type que vous emballez est un type primitif, cela peut
entraı̂ner des problèmes de performance. Les classes Kotlin
introduisent une solution à ce problème sous la forme de la
classe Inline.

Pourquoi y a-t-il une perte de performance
supplémentaire ?
1 Lors de la création d’une variable de type primitif, celle-ci est
stockée dans la pile de la mémoire JVM.
2 En revanche, lors de la création d’un nouvel objet, il est stocké
dans une région appelée la heap.
3 Les opérations liées au stockage et à l’utilisation des objets
sont plus coûteuses. Choix crucial entre l’efficacité des types
primitifs et la flexibilité des objets.

Classes Inline en Kotlin: usage et limitations
• Le mot-clé value est suffisant pour définir une classe inline.

• Si vous écrivez du code Kotlin pour la JVM, l’annotation
@JvmInline est nécessaire.
• Utilisation d’un seul constructeur principal.
• Il est obligatoire de définir une propriété, similaire à une classe
de données (data class).
• Seule une propriété en lecture seule est autorisée dans le
constructeur principal (pas de var, seulement val).
Figure: Comparaison
Ahmed Fouad El ouafdi (UIZ) des performances
Short Title en terme de temps d’accès
December 12, 2023 entre
62 / 89
Classes Inline en Kotlin: Héritage et limitations
• Les classes en ligne sont autorisées à hériter des interfaces

• Il est interdit aux classes en ligne de participer à une hiérarchie
de classes. Cela signifie que les classes en ligne ne peuvent pas
étendre d’autres classes et sont toujours finales.

Introduction au Modèle de Conception par
Délégation
• Le modèle de conception par délégation est une approche où
un objet confie une partie de son comportement à un autre
objet.
• À la différence de l’héritage, la délégation favorise la
composition sur l’extension.
• Une classe Derived peut implémenter une interface Base en
déléguant tous ses membres publics à un objet spécifié

Surcharge d’un membre d’une interface
implémentée par délégation
• Les surcharges fonctionnent comme prévu : le compilateur

utilisera vos implémentations de surcharge au lieu de celles
dans l’objet délégué.
• Si vous souhaitez ajouter override fun printMessage() {
print("abc") } à Derived, le programme affichera ”abc” au
lieu de 10 lors de l’appel de printMessage.

Classes imbriquées internes
• Le compilateur utilisera vos

implémentations de
surcharge au lieu de celles
dans l’objet délégué.
• L’ajout de override fun
printMessage() {
print("abc") } à Derived
fera afficher ”abc” au lieu de
10 lors de l’appel de
printMessage.

Avantages et Considérations de la Délégation
Avantages:
• Flexibilité: Permet de changer dynamiquement le
comportement.
• Réutilisation du Code: Encourage la réutilisation des
fonctionnalités.
• Séparation des Responsabilités: Clarifie les responsabilités
de chaque objet.
Considérations:
• Surcoût: Peut entraı̂ner une surcharge avec une utilisation
excessive.
• Complexité Structurelle: La structure peut devenir complexe
avec plusieurs objets de délégation.
• Choix Prudent: Utilisez la délégation avec discernement,
privilégiant la flexibilité et la réutilisation.

Les expression lambda
• Les lambdas sont largement intégrées dans Kotlin,

omniprésentes dans le code et fréquemment abordées dans la
documentation et les blogs
• Leur compréhension est essentielle pour écrire, lire et
maı̂triser Kotlin. ginitemize
• Les lambdas sont une forme de littéral de fonction, ce qui
signifie qu’elles sont définies sans utiliser le mot-clé fun et sont
utilisées immédiatement en tant que partie d’une expression.
• Comme les lambdas ne sont pas nommées ni déclarées avec le
mot-clé fun, nous sommes libres de les assigner facilement à
des variables ou de les passer en tant que paramètres de
fonction.

Expression Lambda en Kotlin
• Les lambdas sont des littéraux de fonction, définis sans le

mot-clé fun, et utilisés immédiatement comme partie d’une
expression.
Dans ce cas, simpleLambda est une fonction qui ne prend aucun

argument et renvoie Unit.
• Exemple d’uns lambda qui prend deux arguments String et
renvoie une String.

Expression Lambda en Kotlin
• Deux manières différentes dont les informations de type pour
le lambda peuvent être rendues moins explicites en
s’appuyant sur l’inférence de type:
• Dans l’exemple lambda2, les informations de type sont
déduites du lambda lui-même. Les valeurs des paramètres
sont explicitement annotées avec le type String tandis que
l’expression finale peut être déduite pour renvoyer une chaı̂ne.
• Pour lambda3, la variable inclut les informations de type. Pour
cette raison, les déclarations de paramètres du lambda
peuvent omettre les annotations de type explicites ; first et last
seront tous deux déduits comme types String.

Invoquer une expression lambda

Alias de Types - Introduction
Les alias de types fournissent des noms alternatifs pour les types
existants, permettant de raccourcir les noms de types trop longs.
Exemple pour raccourcir les types génériques:
• typealias NodeSet = Set<Network.Node>
• typealias FileTable<K> = MutableMap<K,
MutableList<File>>
Les alias de types ne créent pas de nouveaux types; ils sont

équivalents aux types sous-jacents correspondants.

Alias de Types - Exemples
Alias pour les types de fonction:

• typealias MyHandler = (Int, String, Any) -> Unit
• typealias Predicate<T> = (T) -> Boolean
Nouveaux noms pour les classes internes et imbriquées:
• typealias AInner = A.Inner
• typealias BInner = B.Inner

————————————————————————————–

Cours Kotlin

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Cours Kotlin

Transféré par

Droits d'auteur :

Formats disponibles

Introduction au Kotlin

Ahmed Fouad El ouafdi

Université Ibn Zohr

Programmation Android par Kotlin

Ahmed Fouad El ouafdi (UIZ) Short Title December 12, 2023 1 / 89

• Objectif: Comprendre l’essentiel de la programmation

Ahmed Fouad El ouafdi (UIZ) Short Title December 12, 2023 2 / 89

• Structure d’une Application Android:

Ahmed Fouad El ouafdi (UIZ) Short Title December 12, 2023 3 / 89

• Depuis Google I/O en 2019, le développement mobile Android

Ahmed Fouad El ouafdi (UIZ) Short Title December 12, 2023 4 / 89

• Moins de code avec une lisibilité accrue.

Ahmed Fouad El ouafdi (UIZ) Short Title December 12, 2023 5 / 89

• Support du développement multiplateforme.

Ahmed Fouad El ouafdi (UIZ) Short Title December 12, 2023 6 / 89

Output : Hello, World!

Ahmed Fouad El ouafdi (UIZ) Short Title December 12, 2023 7 / 89

1 fun printMessage(message: String): Unit {

1 Les fonctions Kotlin sont déclarées à l’aide du mot-clé fun

Ahmed Fouad El ouafdi (UIZ) Short Title December 12, 2023 8 / 89

1 fun sum(x: Int, y: Int): Int {

3 Fonction renvoyant un entier.

Ahmed Fouad El ouafdi (UIZ) Short Title December 12, 2023 9 / 89

Ahmed Fouad El ouafdi (UIZ) Short Title December 12, 2023 10 / 89

1 // Définition d’une fonction infix

• Une fonction inﬁx est une fonction membre ou une fonction

Ahmed Fouad El ouafdi (UIZ) Short Title December 12, 2023 11 / 89

1 // Définition d’une fonction infix

• Une fonction inﬁx est une fonction membre ou une fonction

Ahmed Fouad El ouafdi (UIZ) Short Title December 12, 2023 11 / 89

1 // Définition d’une fonction infix

• Une fonction inﬁx est une fonction membre ou une fonction

Ahmed Fouad El ouafdi (UIZ) Short Title December 12, 2023 11 / 89

Kotlin dispose d’une puissante déduction de type. Bien que vous

• Déclare une variable mutable et l’initialise.

Ahmed Fouad El ouafdi (UIZ) Short Title December 12, 2023 12 / 89

Kotlin dispose d’une puissante déduction de type. Bien que vous

• Déclare une variable mutable et l’initialise.

Ahmed Fouad El ouafdi (UIZ) Short Title December 12, 2023 12 / 89

Kotlin dispose d’une puissante déduction de type. Bien que vous

• Déclare une variable mutable et l’initialise.

Ahmed Fouad El ouafdi (UIZ) Short Title December 12, 2023 12 / 89

• Déclare une variable sans initialisation.

Ahmed Fouad El ouafdi (UIZ) Short Title December 12, 2023 13 / 89

• Déclare une variable sans initialisation.

Ahmed Fouad El ouafdi (UIZ) Short Title December 12, 2023 13 / 89

• Déclare une variable sans initialisation.

Ahmed Fouad El ouafdi (UIZ) Short Title December 12, 2023 14 / 89

• Déclare une variable sans initialisation.

Ahmed Fouad El ouafdi (UIZ) Short Title December 12, 2023 14 / 89

• Déclare une variable sans initialisation.

Ahmed Fouad El ouafdi (UIZ) Short Title December 12, 2023 14 / 89

• Déclare une variable String non-null.

Ahmed Fouad El ouafdi (UIZ) Short Title December 12, 2023 15 / 89

• Déclare une variable String non-null.

Ahmed Fouad El ouafdi (UIZ) Short Title December 12, 2023 15 / 89

• Déclare une variable String non-null.

Ahmed Fouad El ouafdi (UIZ) Short Title December 12, 2023 15 / 89

1 var nullable: String? = "You can keep a null here" // 3

• Affecte la valeur null à la variable nullable. C’est autorisé.

Ahmed Fouad El ouafdi (UIZ) Short Title December 12, 2023 16 / 89

1 var nullable: String? = "You can keep a null here" // 3

• Affecte la valeur null à la variable nullable. C’est autorisé.