Les bases de Kotlin

Avant de commencer

• Nous avons déjà vu ce qu’était notre langage Kotlin

• Nous allons apprendre les bases de Kotlin
• Les Sections Kotlin sont partagées entre les di érentes formations Kotlin. Car
les bases sont les mêmes.

• Pas besoin d’Android Studio pour ces sections. Nous irons directement sur la
playground Kotlin à l’adresse: https://play.kotlinlang.org/

• Rappel: Vous pouvez à tout moment retrouver la documentation du langage

sur leur site: https://kotlinlang.org/
ff
Toutes les diapos suivantes seront vues en détail
et en vidéo. Asseyez-vous confortablement et
c’est parti pour l’apprentissage de Kotlin.
Les Basiques
Premiere ouverture de la playground
Voila ce que l’on obtient lorsque l’on lance la playground:

• Un texte sur plusieurs lignes entouré de /** …*/ C’est un commentaire

• Une fonction main()
• Du code entre les accolades {}
• Une fonction pour imprimer un résultat /**
• Nous reviendrons la dessus * You can edit, run, and share this code.
* play.kotlinlang.org
Ce qu’il faut retenir ici: */
Le code que nous allons e ectuer sera situé à l’intérieur fun main() {
println("Hello, world!!!")
de la fonction main, la principale }
ff
Les Commentaires
Nous avons déjà rapidement vu un commentaire dès l’ouverture de notre aire
de jeu. C’est un morceau de code qui ne sera pas exécuté lors de la
compilation de votre app. Il est utilisé principalement pour annoter et
commenter le code. Nous dire ce qu’il faut implémenter, à quoi sert le code qui
suit, ce qu’il faut changer… Bref, tout ce qui peut aider à la compréhension
pour soi ou pour les autres développeurs qui travailleront sur le projet.

Il existe 2 types de commentaires:

1. Sur une seule ligne dans la limite de 100 caractères. Il sera précédé de //

2.Sur plusieurs lignes. Commence par /**, nit par */ et prend une * à chaque
ligne. fi
Les Commentaires
/**
* Salut les codeurs !
* Vous êtes bien sur play.kotlinlang.org
* Pour apprendre le développement d'applications avec Kotlin !
*/

//Ici se trouve la fonction main. Le point d'entrée de notre code

fun main() {
//Ici nous pouvons voir une fonction println pour voir une donnée dans la console
println("Hello, world!!!")

}
Le print
A certains moments du développement, nous devrons utiliser le print ou le println
pour véri er si la donnée que vous voulons est bien présente au moment voulu.

Il se composera du nom de fonction suivi entre parenthèses de la variable ou de

la valeur à imprimer dans la console.

Il peut permettre de faire un débug ou tout simplement tester si nous avons ce

qu’il faut. Le Log peut aussi être utilisé dans Android Studio, nous le verrons plus
tard.

Il en existe 2:

1.println() avec saut à la ligne

2.print() sans saut à la ligne

fi
Le print

fun main() {
//Création d'une variable avec un nom
var name = "Matthieu"
//véri cation de la variable
println(name)
//Ou
print("Salut, moi c'est $name")
//PS: Cette histoire de $name s'appelle la String interpolation et sera vue un peu plus tard

}
fi
Variables et Constantes
Un des principes de base en programmation est la notion de variable. C’est un espace de stockage alloué par le
programme pour stocker une donnée unique.

Imaginez plutôt un chier contenant une seule valeur. Ce chier peut être retrouvé par son nom.

Une fois cette valeur stockée, le programme pourra l’utiliser en l’appelant par son nom. Nous pouvons stocker avec
Kotlin plusieurs types de variables. Voici quelques exemples des DataTypes les plus courants et que l’on va nommer
primaires:

• String: Une chaîne de caractères (un texte pour simpli er)

•Int: Un nombre entier

•Double: Un nombre décimal

•Float: Un autre nombre décimal moins précis que le Double

• Boolean: une valeur interrupteur vraie ou fausse

A noter qu’il existe aussi les array et dictionnaires , ce sont des Listes ordonnées ou non de classes ou types. Ce ne
sont pas des DataType primaires mais seront aussi stockés en variables.
fi
fi
fi
Instancier une variable
Une variable ou une constante se dé nissent et se créent avec 4 paramètres:

1. var pour variable ou val pour constante

2. Le nom de la variable ou constante

3. Son Type précédé de « : »

4. Sa valeur initiale instanciée par le signe =

Ensuite, pour récupérer la variable, nous n’aurons qu’a appeler le nom de celle-
ci
fi
Instancier une variable
fun main() {
Voici un exemple. Vous pouvez voir les 4 var name: String = "Matthieu"
étapes pour créer des variables et val age: Int = 27
constantes di érentes avec di érents val currentBankAccount: Double = 0.45
types. val isKotlinCool: Boolean = true

A noter qu’il existe en Kotlin et dans }

d’autres langages récents le typeInference.
C’est à dire que le langage reconnait lui
même le type. Il devient donc optionnel de fun main() {
l’ajouter var name = "Matthieu"
val age = 27
val currentBankAccount = 0.45
val isKotlinCool = true

}
ff
ff
Modifier une variable
Les données dans vos applications seront amenées à changer avec le
temps. Exemple, le nombre de likes sur un post Instagram, un numéro de fun main() {
téléphone, un score de match, une variable dé nissant si nous sommes en var cats = 3
dark ou light mode… println(cats)
cats = 4
Nous avons donc dé ni lors de sa création un valeur initiale, nous pouvons println(cats)
la changer en appelant le nom de cette variable et en lui attribuant une }
valeur de meme type obligatoirement. Sinon nous obtiendrons une erreur.

fun main() {
var cats = 3
Type mismatch: inferred type is String but Int was expected
println(cats)
cats = "Athena" Nous pouvons voir ici un type mismatch. Le type nouvellement
println(cats) attribué ne correspond pas à ce qui a été attendu !
}
fi
fi
Différence entre variable et constante
Quand avec une variable la valeur peut varier, avec une constante, la valeur ne
peut pas être réassignée, la valeur reste xe, constante

fun main() {
val cats = 3
println(cats)
cats = 4
println(cats)
}
Val cannot be reassigned

Si votre valeur est amenée à changer, utilisez plutôt var.

fi
Convention de nommage des variables
Pour garder une certaine consistance, une certaine lisibilité, une facilité pour que vous
ou un autre puisse relire le code, il existe une convention de nomade pour les variables
et constantes. Il en va de même pour les fonctions (sauf les fonctions @Composable
mais nous y reviendrons):

• Le nom doit être explicite ex: âge pour une variable stockant l’âge

• Commence toujours par une minuscule

• Pas d’espace

• Utilisation du CamelCase si plusieurs mots sont collés. Commence par une

minuscule et remplie les espaces par une majuscule pour chaque mot accolé. Ex:
bankAccount pour stocker le compte en banque

• Je rajoute moi-même celle la par expérience: On va préférer utiliser des noms de

variables en anglais. Ex: name plutôt que nom.
Les nombres entiers: Int
Ce sont tout simplement les nombres qui ne contiennent pas de virgule comme
par exemple 5 ou -34. Ils peuvent donc être positifs ou négatifs, tant qu’ils
n’ont pas de virgule.

Le TypeInference reconnait le type. Ajouter Int devient alors optionnel

fun main() {
val cats = 3
val age = 27
var currentTemperature: Int = -12
}
Les nombres entiers: les autres
Int est le nombre entier basique. Il est recommandé dans la plupart des cas. Cependant il est à
mon sens important de connaitre les autres types de nombres entiers même si vous les utiliserez
surement très peu:

• Byte: 8bits mini -128 max 127

• Short: 16bits mini -32768 max 32767
• Int: 32bits mini -2147483648 max 2147483647
• Long: 64bits mini -9223372036854775808 max 9223372036854775807
fun main() {
val cats: Byte = 3
val ageInMonths: Short = 345
val timeSpentInTraf c: Int = 54789
val dreamBankAccount: Long = 8767655457897
}
fi
Les nombres Décimaux: Double
Le Double est un nombre avec virgule. Dans la programmation, la virgule est
remplacée par un point.

Il est sur 64bits avec une précision de 15-16 valeurs après la virgule.

fun main() {
val averageCourseStars: Double = 4.5
}
 Les nombres Décimaux: Float
Moins précis que le Double, il a che une précision après la virgule de 6-7
digitales.

Il nit par F.

Nous utiliserons cependant le Double plus souvent, tout comme nous avons
privilégié le Int pour les entiers.

fun main() {
val averageCourseStars: Float = 4.5F
}
fi
ffi
 String: Chaine de caractères
Il s’agit certainement du type le plus répandu dans une application. Quelle
application ne possède aucun texte? Très peu. D’ailleurs, dans une application
classique, un nombre visible à l’écran est en fait intégré à un texte, comme
nous l’avons fait avec la string interpolation dans le print !

Une String est TOUJOURS entre guillemets. Cela permet au programme de

comprendre le début et la n de la String

fun main() {
val name: String = "Matthieu"
val description = "J'essaie d'enseigner au plus grand monde le développement d'applications mobiles"
val fakeNumber = "3"
}
fi
 String: Chaine de caractères
On parle de String en tant que chaîne de fun main() {
caractères et non pas de texte tout simplement. val name: String = "Matthieu"
for (character in name) {
En e et, il existe un type Character, nous println(character)
pouvons grâce aux boucles accéder à tous les }
caractères d’une String. }

Les boucles seront abordées dans une section

suivante.

La console nous montre ainsi toutes les lettres une a une.

ff
String: Modifier
Nous pouvons changer la valeur d’une String, en
lui assignant une nouvelle valeur. fun main() {
var name: String = "Matthieu"
String possède aussi des fonctions pour la println(name)
modi er. name = "Jean-Michel"
println(name)
Exemple pour la mettre intégralement en }
majuscule, ajouter une majuscule à chaque
début de mot
fun main() {
var name: String = "Salut les codeurs"
println(name.uppercase())
println(name.capitalize())
println(name.lowercase())
Ou encore tout mettre en minuscules
}
fi
String: La concaténation
Il est possible d’utiliser la concaténation, c’est à dire accoler plusieurs String
pour faire une autre String qui soit plus explicite ou qui convienne à votre
application.

Exemple, l’utilisateur possède un prénom (surname) et un nom (name). Si dans

votre application vous souhaitez en faire une seule String:

fun main() {
val name: String = "De la Tour"
val surname = "Jean Charles"
Ne pas oublier l’espace pour ne pas avoir
val fullName = surname + " " + name
print(fullName)
les 2 valeurs accolées

}
 String: Interpolation ou templates
Interpolation ou template permet d’ajouter des valeurs non String à une String. Nous pouvons bien
sur aussi ajouter des Strings en interpolation

Si la valeur est simple, elle sera précédée de $

Si la valeur est plus complexe, elle sera précédée de $ puis entre {}

fun main() {
val name: String = "Marseille"
val arr: Int = 16
println("$name possède $arr arronndissements")
println("Il y a ${name.length} lettres dans $name")

J’ai intégré le .lenght pour mesurer le nombre de caractères dans la String. C’est un
concept à apprendre que l’on verra surtout dans les Listes.
String: Caractères spéciaux
Dans une String, vous pourrez aisément faire un saut de ligne avec \n.
fun main() {
val jump: String = "Salut, je vais sauter à la ligne\nHopla"
println(jump)
}

Vous avez compris que les guillemets ouvrent et ferment une String. Et si il y
avait des guillemets dans le texte que vous ajoutez ? \ avant le guillemet
dans le texte vous permettra d’échapper à la n de la String et de pouvoir
continuer sereinement
fun main() {
val quote: String = "Socrate a dit: \"Tout ce que je sais, c'est que je ne sais rien\""
println(quote)
}
fi
 Boolean: Vrai ou Faux?
Passons désormais aux Booleans. C’est simplement une valeur qui est vraie ou
fausse. Les 2 seules valeurs sont true ou false.

Elle servira à:

• Véri er si des conditions sont remplies

• Véri er le nullable (valeur optionnelle)

•Utiliser les interrupteurs dans le UI

fun main() {
val isSunny = true
}
fi
fi
Pair et Triple
Dans certains langages de programmation, on peut parler de Tuple. C’est une
variable qui contient plusieurs valeurs génériques.

Avec Kotlin nous avons Pair pour une paire de valeurs et Triple pour 3 valeurs.

Cela ressemble à une fonction qui retournerait plusieurs valeurs.

Voyons cela en détail:

fun main() {
val error = Pair(404,"Page not found")
println(error)
println(error. rst)
println(error.second)
}
fi
Pair et Triple
Lorsque nous assignons une seule variable, rst sera la première valeur et
second la seconde. Nous pouvons séparer ces valeurs

fun main() {
val (code, description) = Pair(404,"Page not found")
println(code)
println(description)
}

fi
Pair et Triple
Pour le Triple, cela fonctionne de la meme façon mais avec 3 valeurs. A noter
que pour le Pair comme le Triple, nous pouvons ajouter des Types à chaque
valeur entre <>

fun main() {
val (red, green, blue) = Triple<Int, Int, Int>(123, 45, 35)
print(red)
}
Array
L’array est la façon la plus simple pour grouper un ensemble de valeurs de
même Type au sein de votre programme.

Prenez par exemple une liste d’utilisateurs, une liste de résultats, une liste de
publications. C’est extrêmement courant dans des applications même
basiques.

Pour déclarer un Array, on utilise arrayOf<Type>(valeur1, valeur2, …)

fun main() {
val students = arrayOf<String>("Jean", "Michel", "Jacques", "Myriam", "Sonia", "Marie", "John")
}
Array: Compter et ajouter
Pour compter, il su t de rajouter .size . Vous obtiendrez ensuite le nombre d’éléments dans votre array.
Pour ajouter et modi er, l’ArrayOf n’est pas le plus indiqué, car il est immuable, il faut donc à chaque ajout
recréer la valeur. C’est cependant possible:

fun main() {
var boys = arrayOf<String>("Jean", "Michel", "Jacques", "John")
var girls = arrayOf<String>("Marie", "Myriam", "Sonia", "Cindy", "Helena")

//Obtenir la taille d'un Array

println(boys.size)

//Ajouter
boys += "Georges"
println(boys.asList())

//Concatener
var fullClass = boys + girls
println(fullClass.asList())

}
ffi
fi
Array: L’index
Dans les Array, on peut accéder à un élément précis en utilisant l’index. Attention, en
programmation, l’index commence toujours à Zéro. Le premier élément est donc 0, quand au
dernier il sera… size - 1.

Si vous demandez un élément hors de l’index, vous obtiendrez une erreur

fun main() {
var girls = arrayOf<String>("Marie", "Myriam", "Sonia", "Cindy", "Helena")

//Obtenir la taille d'un Array

println(girls.size)

//obtenir un élément via l'index

val chosenStudent = girls[1]
//En choisissant l'index 1, on tombe sur Myriam, car l'index commence à 0
println(chosenStudent)

}
List
Vous l’avez vu, les Array ont certaines limitations, pour lire l’intérieur d’un array,
on l’avait mis en toList(). Voyons donc maintenant les Listes. Nous en avons 2:

1. listOf: C’est une Liste en read-only. C’est à dire qu’à l’instar de arrayOf, on
ne pourra pas ajouter ou supprimer de données sans recréer la variable
entière. Elle a cependant plus de possibilités qu’un array

2.mutableListOf: Ici, elle peut muter, nous pouvons donc ajouter et supprimer
des éléments de cette liste facilement
listOf
Voyons ce que nous pouvons faire avec un listOf:

fun main() {
var n Players = listOf<String>("Brady", "Kamara", "Kupp", "Garropolo", "Mahomes", "OBJ", "Kittle", "Kelce",
"Bosa")

//voir toute la liste

println(n Players)
//Obtenir la taille d'une liste
println(n Players.size)
//obtenir un élément via l'index
println(n Players[0])
//index Via le get
println(n Players.get(3))
//Obtenir l'index par rapport a un nom de joueur
println(n Players.indexOf("Kittle"))

}
fl
fl
fl
fl
fl
fl
 mutableListOf
fun main() {
var n Players = mutableListOf<String>("Brady", "Kamara", "Kupp", "Garropolo", "Mahomes", "OBJ", "Kittle", "Kelce", "Bosa")

//Ajouter (en n de liste)

n Players.add("Rodgers")
println(n Players)
Avec la mutable, nous pouvons faire tout ce que fait déjà
//Ajouter selon un index précis une liste, nous pouvons en plus:
n Players.add(1, "Gronkowski")
println(n Players) •Ajouter en n de liste
//supprimer selon une valeur
n Players.remove("OBJ")
•Ajouter selon un index
println(n Players) • Supprimer selon un index
//supprimer selon un index •Supprimer selon une valeur
n Players.removeAt(7)
println(n Players)
//Voir si le joueur est là (est contenu dans la liste)
println(n Players.contains("Brady"))

}
fl
fl
fl
fl
fl
fl
fl
fl
fl
fl
fi
fi
Map
Aussi appelée dictionnaires, les Maps sont des collections tout comme les listes
et les array mais qui contiennent des clés et des valeurs.

Les clés (Keys) sont uniques alors que les valeurs (values) peuvent être en
doublons.

Comme pour les listes, nous avons 2 types:

1.mapOf

2.mutableMapOf
Map
Nous allons nous focaliser sur les mutable, car la logique est exactement la même excepté l’ajout
et la suppression spéci que à la mutable. Comme pour les listes:

Comment créer une Map?:

var classroomResults = mutableMapOf(

"Johnny" to 12,
"Quentin" to 15,
"Sophie" to 11,
"Axel" to 7,
"Candice" to 17
)

Ici la key sera le prénom et la valeur la note. Notez le mot clé to pour dé nir une valeur à la clé ainsi
que la virgule séparant chaque élément. Nous aurions pu mettre tout ceci sur une seule ligne.
fi
fi
Map
Voyons ce que nous pouvons faire d’autre avec la map:

fun main() {
var classroomResults = mutableMapOf( "Johnny" to 12, "Quentin" to 15, "Sophie" to 11, "Axel" to 7, "Candice" to 17)
//Voir la map
println(classroomResults)
//Accéder à un élément selon sa clé
println(classroomResults["Axel"])
//Compter
println(classroomResults.size)
//Modi er une valeur selon la clé
classroomResults["Sophie"] = 19
println(classroomResults)
//Ajouter: Notez que c'est exactement comme modi er une valeur
//Si la clé n'existe pas elle est créée
classroomResults["Mika"] = 5
println(classroomResults)
//Supprimer
classroomResults.remove("Quentin")
println(classroomResults)

}
fi
fi
 Nullable
Il est certain que vous tomberez un jour ou l’autre sur cette valeur: null !

Cela signi e que la variable ne contient aucune valeur et que cette valeur est donc nulle. Dans les
langages de programmation récents, le concept de null-safety est souvent utilisé. Cela signi e
que si le programme obtient une valeur nulle sur une variable devant posséder une valeur le
programme va crasher. Problématique…

C’est pourquoi nous pouvons dé nir nos types comme nullable, pouvant avoir une valeur nulle et
ainsi éviter le crash.

Ici par exemple, nous avons assigné null à la variable, la playground s’est arrêtée avec une erreur

fun main() {
var name: String = "Geoffrey"
println(name)
name = null
println(name)
}
fi
fi
fi
Nullable
Dans ce cas, nous allons ajouter le ? Derrière le type. Cela dira au
programme, attention il est possible qu’il n’y ait aucune valeur ici.

fun main() {
var name: String? = "Geoffrey"
println(name)
name = null
println(name)
}

Nous verrons dans le chapitre sur les conditions comment « déballer un nullable »
 Les
Opérateurs
Définition
Un opérateur est un symbole spécial qui permet de véri er, modi er ou combiner des valeurs. Nous avons déjà
utilisé un opérateur: le symbole ‘=‘ pour attribuer ou modi er la valeur d’une variable.
Les opérateurs peuvent être classés en plusieurs catégories. Chaque catégorie sera vue en détail dans les
sections suivantes:

• L’opérateur d’assignation.

• Les opérateurs arithmétiques.

• Les opérateurs combinés.

• Les opérateurs de comparaison.

Les opérateurs peuvent être unaires (unary), binaires (binary)

• Les Opérateurs unaires opérent sur une cible unique. Ce sont soit des unaires pré xes si l’opérateur est
placé immédiatement avant la valeur (-valeur) ou des unaires su xes si l’opérateur est placé immédiatement
après la valeur(valeur!).

• Les opérateurs binaires opèrent sur 2 cibles. L’opérateur est donc placé entre les 2 cibles (valeur1 + valeur2)
fi
fi
ffi
fi
fi
L’opérateur d’assignation
Nous avons déjà vu à plusieurs reprises cet opérateur. C’est le signe =. Il sert à
assigner ou modi er la valeur d’une variable.

Petit rappel: On ne modi e que les variables, pas les constantes.

fun main() {
//Assignation d'une variable
var myVariable = 3

//Modi cation d'une variable

myVariable = 5
}
fi
fi
fi
 Les opérateurs unaires
Les Opérateurs unaires ne travaillent que sur une seule cible, c’est à dire une seule
variable. En Kotlin il en existe 4:

•Le Moins

• L’inversion

• L’incrémenteur

• Le décrémenteur

A noter qu’il en existe un 5eme, le +devant le nom de la variable numérique qui ne

change rien à sa valeur, je n’entrerai donc pas dans ce cas, ne le trouvant pas
su samment utile.
ffi
L’opérateur unaire: -
Son rôle est de changer une valeur numérique négative en valeur positive, ou
l’inverse:

Ici le print donnerait -3 et 45.6

fun main() {
var positive = 3
var negative = -45.6
println(-positive)
println(-negative)
}
L’opérateur unaire: !
Son rôle est de changer une valeur cette fois ci non pas d’un nombre mais d’un
Booléen.

Ici l’output passerait de true à false

fun main() {
var isKotlinCool = true
println(!isKotlinCool)
}
L’opérateur unaire: ++ & - -
On retourne sur les nombres pour incrémenter cette fois ci. Le ++ placé derrière
une variable numérique l’incréméntera de 1 unité

Et pour décrémenter on utilisera par contre - -

Ici nous faisons donc passer 3 à 4 et nous le remettons ensuite à 3

fun main() {
var number = 3
number++
println(number)
number--
println(number)
}
Les opérateurs arithmétiques
Ce sont les opérateurs qui permettent d’e ectuer des calculs. Ils sont placés
entre 2 valeurs pour donner un résultat:

• + pour l’addition fun main() {

val numberA = 3
• - pour la soustraction val numberB = 7
val sum = numberA + numberB
• * pour la multiplication println(sum)
val sub = numberA - numberB
• / pour la division println(sub)
val mul = numberA * numberB
println(mul)
val div = numberA / numberB
println(div)
}
ff
 fun main() {
Interopérabilité val numberA = 3
val numberB = 7.5F
val numberC = 35.345
Si nous utilisons plusieurs Types di érents
le résultat sera donné selon une hiérarchie: val resultInt: Int = numberA + numberC.toInt()
• Int pour un calcul entre Int println(resultInt)

• Float pour un calcul entre Int et Float val resultFloat: Float = numberB - numberC.toFloat()
println(resultFloat)
• Double pour un calcul comprenant un }
Double

Mais si on veut forcer le Type d’un résultat on obtient une erreur: Par exemple on
ne peut pas forcer un Int être le résultat entre un Int et un Double. Pour ceci, on
va devoir les convertir en utilisant toInt() ou toFloat(), ou encore toDouble()
ff
Le Remainder ou Modulo
fun main() {
Une division entre Int et Double donne un résultat val number1 = 13
en Double si le résultat implique une décimale, val number2 = 4
val divInt: Int = number1 / number2
Nous pouvons forcer ce résultat à devenir un Int.
val modulo = number1 % number2
Dans notre cas, 13 divisé par 4 donne 3. Dans ce println(divInt)
calcul, nous avons perdu 1 unité. println(modulo)

Car pour que ce résultat soit plein ce serait plutôt }

12 divisé par 4 qui serait égal à 3

C’est la qu’intervient le modulo ou remainder, il permet de récupérer les unités

pleines qui resteraient après une division en résultat Int.

Ex: nous remplissons 3 boites de 4 oeufs, il nous en reste 1

Calcul sur une même valeur
fun main() {
var number1 = 13
Ici cela va presque s’apparenter à un number1 +=3
opérateur unaire car nous modi ons la //13 + 3 = 16 => number1 devient 16
valeur dans le style de ++ et - - println(number1)

Nous avons: number1 -= 9

//16 - 9 = 7 => number1 devient 7
• += et valeur println(number1)

• -= et valeur number1 *=4

//7 + 3 = 28 => number1 devient 28
• x= et valeur println(number1)
number1 /=2
• /= et valeur //28 / 2 = 14 => number1 devient 14
println(number1)

}
fi
Opérateurs de Comparaison
fun main() {
var number1 = 13
Nous disposons aussi d’opérateur pour val number2 = 15
comparer. Ces comparaisons nous renverrons println(number1 == number2)
true ou false //false car 13 n'est pas égal à 15

Nous avons: println(number1 != number2)

//true car 13 est différent de 15

• == égal println(number1 > number2)

//false car 13 n'est pas plus grand que 15
• != di érent
println(number1 < number2)
• > supérieur //true car 13 est plus petit que 15

println(number1 >= number2)

• < inférieur //false car 13 n'est pas supérieur ou égal à 15

• >= supérieur ou égal println(number1 <= number2)

//true car 13 est inférieur ou égal à 15
•<= inférieur ou égal }
ff
&& et ||
fun main() {
Nous disposons aussi val age = 18
d’opérateurs pour comparer val isSunday = true
plus d’un opérateur. Ces val homeworkDone = false
val average = 12
comparaisons nous
renverrons true ou false //Ici nous véri ons si la personne a 18 ans ou plus ET si c'est dimanche
val canGoOut = age >= 18 && isSunday
Nous avons: println(canGoOut)

//Ici nous véri ons si les devoirs sont faits et si sa moyenne OU plus de 10
• && pour véri er si tout est val restTime = homeworkDone || average > 10
vrai println(restTime)
}
• || si au moins une condition
est remplie
A noter: isSunday est égal à isSunday == true
fi
fi
fi
Les Fonctions
Définition
Une fonction est en morceau de code encapsulé qui e ectue une tache précise et
ne sera e ectué que quand il sera appelé par son nom. Si une fonction n’est jamais
appelée, alors le code présent à l’intérieur de cette fonction ne sera jamais lancé.

Une fonction va se composer de 5 éléments:

• Le mot clé fun

• Le nom de la fonction suivi de parenthèses

• Des paramètres à l’intérieur des parenthèses (optionnel)

• Un type de valeur qui sera retourné précédé de ‘:’ (optionnel)

• Le code a e ectuer entre accolades {} si la fonction est appelée.

ff
ff
ff
Appeler une fonction
Comme expliqué dans la dé nition, la code de la fonction n’est e ectué que
lorsque la fonction est appelée.

Pour appeler une fonction, on procède de la même façon que pour une variable,
et on ajoute entre parenthèses les valeurs de paramètres si la fonction en
demande.

fun main() {
fun myFirstFunction() {
println("Youpi ! On m'a appelé")
}

myFirstFunction()

}
fi
ff
 Les fonctions basiques
Nous allons voir ici les fonctions dites basiques, c’est à dire sans aucune valeur
retournée ni aucun paramètre.

D’ailleurs, une fonction qui ne retourne aucune valeur peut retourner Unit, ce qui
signi e aucune valeur retournée.

Le : Unit est donc optionnel

fun main() {
fun sayHelloToStudents(): Unit {
println("Salut les apprenants! J'espère que votre formation se passe bien!")
}

sayHelloToStudents()

}
fi
Les fonctions avec paramètres
Nous avons déjà sans nous en rendre compte utilisé une fonction avec
paramètre, le println.

Nous ajoutons donc entre les parenthèse une valeur de type demandé. Pour
créer cette fonction, nous donnerons un nom au paramètre et un type. La valeur
entrée servira de constante au sein des accolades

fun main() {
fun sayHelloTo(name: String): Unit {
println("Salut $name")
}

sayHelloTo("Marie")
sayHelloTo("Pierre")

}
Les fonctions avec paramètres
Nous pouvons évidemment utiliser plusieurs paramètres et aussi dé nir des valeurs
par défaut si aucune valeur est entrée. Pour cela on assignera avec = une valeur.
Cette valeur ne sera utilisée que si la fonction appelée n’a pas initialisé ce paramètre.

Vous pouvez donc voir dans l’exemple que cher inconnu sera mis si aucun paramètre
n’est entré.

fun main() {
fun sayHelloTo(name: String = "Cher inconnu"): Unit {
println("Salut $name")
}

sayHelloTo("Marie")
sayHelloTo()

fi
Montrer le nom des paramètres
A certains moments, vous voudrez montrer les noms de paramètres, que ce soit
pour les utiliser dans un ordre di érent, en omettre avec valeur par défaut ou
autre… Pour ceci nous pouvons utiliser le nom du paramètre suivi de =

Vous pouvez voir que soit des paramètres ont été omis, ou que d’autres ont été
inversés
fun main() {
fun introduction(name: String = "Inconnu", age: Int = 18) {
val greetings = "Salut je m'appelle $name et j'ai $age ans."
println(greetings)
}

introduction(name = "Matthieu")
introduction(age = 34, name = "Yannis")
}
ff
Les fonctions avec retour
Et si nous voulions retourner une valeur? A la place du :Unit, nous ajoutons le type de valeur à
retourner et le code de la fonction devra donc obligatoirement retourner une valeur du type
demandé grâce au mot clé return.
A noter que apres le retour de type, le code suivant ne sera pas appelé.
Il ne reste ensuite qu’a assigner ce retour à une variable

fun main() {
fun introductionWithReturn(name: String = "Inconnu", age: Int = 18): String {
return "Salut je m'appelle $name et j'ai $age ans."
}

val intro = introductionWithReturn("Matthieu", 27)

println(intro)

val introWithParamsSeen = introductionWithReturn(name = "Athena", age = 4)

println(introWithParamsSeen)
}
Les Boucles
Définition
Au fur et à mesure du développement de nos applications, il est indispensable
d’avoir un moyen de pour passer à travers toutes les valeurs d’un array, d’une
liste, d’une Map, d’une échelle de valeurs et bien d’autres choses.

Pour cela, il existe ce que l’on appelle les boucles.

Prenons par exemple un array de prénom, il serait pratique de pouvoir énumérer
un par un ses prénoms.

Il existe plusieurs sortes de boucles, qui chacune vont nous servir à di érents
moments et pour diverses raisons:

• Les for loops

• Les While loops

ff
For in
Nous avons vu les listes, il serait intérressant de pouvoir itérer, c’est à dire passer à travers chaque valeur.

Une boucle est composée de for puis entre parenthèse le nom de la valeur crée à chaque tout de boucle.
In en tant que mot clé qui dé nit la liste dans laquelle on va itérer:

Le code entre accolades sera e ectué à chaque tour de boucle avec la valeur créée.

fun main() {
val list = mutableListOf(1, 34, 89, 567, 2, 345, 4)
val map = mutableMapOf("Jack" to 4.3, "John" to 7.8, "Simon" to 9.0)

for (item in list) {

println(item)
}

for ((key, value) in map) {

println("$key possède $value €")
}
}
fi
ff
For in
Essayez maintenant sur une String !

fun main() {
val string = "Essayez de passer à travers tous mes caractères"

for (character in string) {

println(character)
}
}
For in avec range
Ici il ne s’agit plus de passer à travers une liste mais plutôt d’avoir un index qui
va s’incrémenter à chaque tout de boucle. Nous dé nissons l’index de départ et
jusqu’ou il va aller avec un int de départ .. et un int de n:

fun main() {
for (index in 0..13) {
println("Je suis l'index $index")
}
}

Le Int de départ sera 0, la boucle s’arrêtera lorsque index sera égal à 13. A chaque fois le code
entre accolades sera effectué.

fi
fi
 For in avec indices
Maintenant nous allons mixer les 2. Nous allons passer à travers une liste via l’index. Rappel l’index
commence à zéro et nit à size -1.

fun main() {
val list = mutableListOf(1, 34, 89, 567, 2, 345, 4)
for (index in 0..list.size - 1) {
println(list[index])
}
}

En nissant par list.size, nous obtenons une erreur car nous sommes allés trop loin. Mais il y a encore plus simple: En utilisant
list.indices qui donne l’index de départ et l’index de n automatiquement

fun main() {
val list = mutableListOf(1, 34, 89, 567, 2, 345, 4)
for (index in list.indices) {
println(list[index])
}
}
fi
fi
fi
For in withIndex
Allez une dernière elle mélange les 2 façons de passer à Travers une liste en obtenant à la fois
l’index mais aussi la valeur qui correspond:

fun main() {
val list = mutableListOf(1, 34, 89, 567, 2, 345, 4)
for ((index, value) in list.withIndex()) {
println("L'$index est $value")
}
}
While
While va faire une boucle tant qu’une condition n’est pas remplie. Essayons
d’incrémente cet int jusqu’ ce qu’il arrive à 13. Il n’e ectue la boucle que
jusqu’a 12. Ensuite il en sort car la condition est remplie.

Attention si vous n’incrémentez pas, vous entrez dans une boucle in nie !
fun main() {
var int = 0
while (int < 13) {
println(int)
int++
}
println("$int C'est Marseille bébé")
}

ff
fi
Do While
Do while ressemble à sa soeur, à l’exception qu ‘elle e ectue la boucle avant de véri er la
condition. Ce qui signi e que si la condition est remplie au départ, nous auront un tour
gratuit !

fun main() {
var int = 82
do {
println(int)
int++ }
while (int < 13)
println("$int C'est Marseille bébé")
}
fi
ff
fi
 Les
Conditions
Définition
Au cours du développement de vos applications, vous serez amenés à exécuter
certaines portions de code selon certaines conditions.

Par exemple, nous pouvons exécuter du code si l’utilisateur est authenti é, si

un joueur est actif, si nous avons bien entré une valeur dans une zone de
texte….

Pour ceci, Kotlin nous propose plusieurs solutions:

• La condition if /else

• la condition when

• Comment déballer un optionnel

fi
If
If qui se traduit par si en français permet d’e ectuer une portion de code suivant les
accolades si la condition est remplie, c’est à dire si la condition renvoie true. La
condition devra se trouver entre parenthèses. A noter que nous avons déjà vu les
conditions dans un chapitre précedent:

fun main() {
val isSunny = true

if (isSunny) {
println("On est partis pour la playa")
}
}

Essayez avec isSunny = false… Rien ne se passe

ff
If …else
Si … Sinon en français. Si nous ne rentrons pas dans la condition du if, le code
du else sera exécuté, toujours entre accolades. Et comme il ne fait pas très
beau, on se fait une partie de Mario Kart?

fun main() {
val isSunny = false

if (isSunny) {
println("On est partis pour la playa")
} else {
println("Bon on reste à la maison, il y a du MarioKart")
}
}
If …else if …else
Tout n’est pas binaire dans ce monde, ce n’est pas que si sinon, mais plutôt si, sinon si, sinon. N’est-ce
pas? Nous pouvons donc intégrer de nombreux cas, comme par exemple les di érentes limites de
vitesse sur route:
fun main() {
val speedLimit = 75

if (speedLimit <= 30) {

println("Proche d'une école")
} else if (speedLimit <= 50) {
println("en ville »)
} else if (speedLimit <= 80) {
println("en campagne")
} else if (speedLimit <= 110) {
println("Voie rapide")
} else {
println("Autoroute")
}

ff
when
Plus nous avons de conditions, et plus nous rentrons dans un code complexe. When
nous permet de simpli er cela en proposant des cas précis.

Chaque cas sera énuméré avec le code à e ectuer suivant la èche. Si on entre dans
aucun cas, on tombe dans le else:
fun main() {
val language = "Grec"

when (language) {
"Francais" -> println("Bonjour")
"Espagnol" -> println("Hola")
"Italien" -> println("Buongiorno")
"Grec" -> println("Kalimera")
else -> println("Hello")
}
}
fi
ff
fl
Déballer un optionnel
Lorsque l’on utilise un nullable ou optionnel, on veut prévenir les crash au cas
ou une valeur serait nulle.

Mais quand on va utiliser cette variable, il va falloir la déballer, c’est à dire

s’assurer qu’elle ne soit pas nulle pour la rendre non nullable. Pour cela nous
allons utiliser:

• If / else
• Not null assertion
• Elvis (Oui oui Elvis)
Déballer un optionnel
Avant toute chose, nous pouvons même si une variable est optionnelle accéder
à ses propriétés grâce au ?. Cela ne les déballera pas, mais nous aurons accès
à toutes ses propriétés qui resteront optionnelles.

Ex: Le nombre de caractères d’une String

fun main() {
var name: String? = "Jean"
val count = name?.length
println(count)
}

Ici le Count devient un Int?

Déballer un optionnel: If / Else
Nous avons vu le if else pour les conditions. Ici le if … else sur un nullable le
déballera automatiquement dans le if:

fun main() {
var name: String? = "Jean"
if (name != null) {
val size = name.length
} else {
println("C'est une variable nulle")
}
}

Vous pouvez voir que name.length est délivré du ?.

Déballer un optionnel: Non null assertion
Attention, ici nous forçons le déballage avec !!. Ce qui peut causer des erreurs si
on le fait sur une valeur nulle. A utiliser uniquement si vous êtes certains à 100%
que la variable ne sera pas nulle

fun main() {
var name: String? = "Jean"
val size = name!!.length
println(size)
}

Avant de créer val size… mettez name sur null et regardez ce qu’il se passe … Un crash. Ce que
l’on souhaite éviter.
Déballer un optionnel: Elvis
Il est le King du Rock & du nullables. Je veux parler de Elvis ! Alors pourquoi Elvis?
C’est une déformation de else if !

On va utiliser 1ensemble de caractères. ?:

Apres ?: se trouvera une valeur pas défaut sur notre nullable est e ectivement null

fun main() {
var name: String? = "Jean"
val size = name?.length ?: 35
println(size)
}

Ici l’output donnera …. 4

ff
Extra: if else sur une seule ligne
Au lieu d’utiliser if/ else avec des accolades et sur plusieurs lignes vous pouvez
vous en servir sur une seule. Ne fonctionne pas avec le else if car cela
deviendrait trop complexe et peu lisible

fun main() {
//sur un Bool
val isSunny = false
val message = if (isSunny) "Tous à la plage" else "Mario Party!"
println(message)

//Sur un nullable
var name: String? = "Jean"
val size = if (name != null) name.length else 83
println(size)
}
Lambdas
Lambda ?
Une expression Lambda est ce que l’on appelle aussi dans d’autres langages une
fonction anonyme.

Elle consiste à proposer dans une syntaxe concise une fonction sans utiliser le mot clé
fun.

Elle fait partie des « Function Litterals » . Ce sont des fonctions nos déclarées mais
passées directement dans une expression

Exemple de syntaxe

fun main() {
val lambda = {
println("Je viens de créer ma première expression Lambda")
}
}
Utiliser une Lambda
Nous avons donc notre premier lambda, pour l’utiliser nous allons directement
l’appeler comme pour une fonction classique

fun main() {
val lambda = {
println("Je viens de créer ma première expression Lambda")
}

lambda()
}
Utiliser une Lambda en tant que Data Type
Honnêtement , il n’y aurait que peu d’intêret à les utiliser de cette façon. Leur utilité
principale se fait en tant que Data type. Nous y ajouterons donc des paramètres et un
type de retour.Comparé aux fonctions, on n’utilisera pas : mais -> pour évoquer le retour

fun main() {
val sayHello: (String) -> Unit = {
println("Salutations $it")
}

sayHello("Marcel")

Ici le mot clé it permet de dé nir le paramètre. « Ceci »

fi
Nommer les paramètres
Lorsque nous utilisons plusieurs paramètres, il est bon de les nommer. Apres
l’accolade de début, sur la même ligne nous nommons les paramètres dans
l’ordre précédé de ->

fun main() {
val sayHello: (String, Int) -> Unit = { name, age ->
println("Salutations $name et j'ai $age ans")
}

sayHello("Marcel", 45)

}
Passer un lambda dans une fonction
Avec Kotlin et particulièrement, le lambdas sont utilisés dans des fonctions. Ils entrent donc comme paramètre
de fonction:

fun main() {
val calculateEra: (Int, Int) -> Int = { width, height ->
width * height
}

fun mathClass(name: String, era: Int): String {

return "$name est allé au tableau, il a trouvé comme résultat : $era"
}

val result = mathClass(name = "Sandra", era = calculateEra(5,7))

println(result)
}
Voyons maintenant ou nous avons déjà utilisé des lambdas
Le Saviez-vous ?
Vous avez déjà utilisé des Lambdas à plusieurs reprises.
Pensez à toutes les fois ou vous avez ouvert des accolades pour effectuer une ligne de code…
Cela vous revient?
• For loop
• Map.forEach
• …
Allons voir maintenant dans le code
La programmation
orienté objet
Définition
En programmation, l’objet à plus ou moins la même dé nition que dans la vie de tous les
jours. Par exemple un ordinateur, un clavier, un smartphone… Un utilisateur est aussi un
objet en programmation. En fait, dans la programmation orienté objet, presque tout est un
objet, et vous aller en utiliser tout au long de votre apprentissage dans la programmation.

Pour créer un objet, nous avons d’abord besoin, à l’image d’un architecte de créer un plan,
un cahier des charges, ou un moule. Ce plan aura entre autre des propriétés, des méthodes
qui seront autant de fonctionnalités que l’on attribuera aux objets. Ce ‘plan’ est une classe.

Une fois ce plan fait, nous pouvons initialiser des objets à l’in ni. Chacun suivant son plan.

Dans une application, la classe peut être écrite dans un chier séparé ou dans un chier
joint à d’autres éléments.

Lorsqu’on parle d’objet, on peut entendre instance de classe. C’est la même chose.

fi
fi
fi
fi
Définir une classe
Nous avions vu les conventions de nomage pour les variables et les constantes. Pour
les classes nous commencerons toujours par une majuscule pour le nom.

Le mot clé ici sera class

Pour la compréhension de cette section, nous allons créer un objet, ce sera un

Utilisateur sa classe sera donc nommée User.

La classe possède un body qui est entre les accolades:

class User() {

}
Créer une instance de classe
La classe en elle même n’est qu’un plan d’architecte pour la création d’objets, un
modèle. Pour créer un objet, nous devons créer une variable et instancier cette classe en
utilisant le nom de la class suivi de parenthèses:

fun main() {

//Création de notre instance de classe

val newUser = User()
}

//Ici notre Modele

class User {

}
Ajouter des propiétés
La classe possède des propriétés (variables) et des méthodes (fonctions). Nous pouvons dé nir des propriétés communes à
tous les objets User que nous créons dans le body de la classe.

On voudra par exemple:

• Nom

• Prénom

• Age

Car évidemment ce sont les caractéristiques communes à tous les utilisateurs. Voila ce que cela donne:

class User {
val name: String = "Van Houten"
val surname: String = "Bruno"
val age: Int = 25
}

Les valeurs sont « en dur ». On verra comment les modi er plus tard
fi
fi
Accéder aux propriétés
Désormais, notre objet peut accéder aux propriétés nouvellement crées. Pour
ceci, il su t d’appeler le nom de l’instance créée, puis y ajouter un . suivi du
nom de la propriété

fun main() {

//Création de notre instance de classe

val newUser = User()
//Print du nom
println(newUser.name)
}
ffi
Les méthodes
Les méthodes sont les fonctions. Notre utilisateur pourrait par exemple avoir une méthode pour se présenter. Cela fonctionne
exactement de la même façon qu’une fonction classique. Pour ensuite appeler la méthode, nous faisons comme pour appeler la
propriété suivi de () car c’est une fonction !

fun main() {
//Création de notre instance de classe
val newUser = User()
//Print du nom
println(newUser.name)
//Appel de la méthode
newUser.sayHello()
}

//Ici notre Modele

class User {
//Propriétés
val name: String = "Van Houten"
val surname: String = "Bruno"
val age: Int = 25

//Méthodes
fun sayHello() {
println("Bonjour tout le monde, je suis $surname $name et j'ai $age ans.")
}
}
Ajouter un constructeur
Jusque la , tous nos objets avaient le même nom et le même prénom. Ce n’est pas ce que l’on voudra pour nos applications. Il est donc
temps d’ajouter un constructeur pour que chaque objet soit unique.

Pour ceci, après le nom de notre classe, des parenthèses nous permettent de construire l’objet. Les propriétés passent donc du body
vers le header.

fun main() {
//Création de notre instance de classe
val zorro = User("De la vega", "Diego", 35)
val bernardo = User(surname = "Bernardo", name = "Sin nombre", age = 47)
//Print du nom
println(zorro.name)
//Appel de la méthode
zorro.sayHello()
bernardo.sayHello()
}

//Ici notre Modele

class User(val name: String, val surname: String, val age: Int) {

//Méthodes
fun sayHello() {
println("Bonjour tout le monde, je suis $surname $name et j'ai $age ans.")
}
}
Modifier les propriétés
Dans mon constructeur, j’ai dé ni des constantes comme propriétés. Cependant, si on les change
en var, nous pouvons modi er ces valeurs comme nous avons fait avec des variables classiques.

fun main() {
val zorro = User("De la vega", "Diego", 35)
zorro.name = "De la Puente"
zorro.sayHello()
}

//Ici notre Modele

class User(var name: String, var surname: String, var age: Int) {

//Méthodes
fun sayHello() {
println("Bonjour tout le monde, je suis $surname $name et j'ai $age ans.")
}
}
fi
fi
Privatiser les propriétés
Imaginez que vous ne vouliez pas accéder à certaines propriétés ou méthodes hors de la classe. Pour ceci, il existe le modi er
private. Placé devant le mot clé val, var, class, fun… il ne permet l’accès à ces données que dans la classe dans laquelle il est
contenu.

A noter que par défaut, nous sommes en public.

Par exemple ici, nous ne voulons accéder a aucune propriété mais lire uniquement les infos avec la méthode sayHello.

En compilant l’application, nous avons une erreur car name n’est plus accessible dans le main()

fun main() {
val zorro = User("De la vega", "Diego", 35)
zorro.name = "De la Puente"
zorro.sayHello()
}

//Ici notre Modele

class User(private var name: String, private val surname: String, private val age: Int) {

//Méthodes
fun sayHello() {
println("Bonjour tout le monde, je suis $surname $name et j'ai $age ans.")
}
}

fi
 Get et Set: propriétés calculées
En privatisant, vous limitez l’accès. Vous pouvez aller un peu plus loin encore en utilisant les propriétés calculées pour que l’on puisse obtenir
et modi er sous certaines conditions:

Par exemple nous souhaitons lire uniquement le nom complet et modi er l’age que si il augmente. Car on ne rajeunit pas malheureusement.
fun main() {
val zorro = User("De la vega", "Diego", 35)
println(zorro.agePublic)
zorro.agePublic = 33
println(zorro.agePublic)
}

//Ici notre Modele

class User(private var name: String, private var surname: String, private var age: Int) {

var fullName = "$surname $name"

get() = eld

var agePublic = age

get() = eld
set(newValue) {
if (newValue >= eld) {
eld = newValue
}
} On peut noter les variables eld qui correspondent aux variables
citées ci dessus.
//Méthodes
… Ainsi que le paramètre newValue dans le set
}
fi
fi
fi
fi
fi
fi
fi
Data class
Lorsque une class est juste une représentation de données, nous allons avec
Kotlin préférer utiliser les data class.

On ne lui mettra donc pas de body mais juste le header avec ses propriétés. De
même class sera précédé de data.

Utiliser une data class pour Kotlin permet au programme de comprendre que ici
nous n’utiliserons que des données.

Par exemple une position d’utilisateur peut être une data class

data class userPosition(val city: String, val latitude: Double, val longitude:
Double)
Enum class
Enum est l’abréviation de énumération. Dans cette classe vous pourrez énumerer des
possibilités. Par ex:

• Les points cardinaux (Nord, Sud, Est, Ouest)

• Un feu tricolore (Rouge, Orange, Vert)
Ce sont des énumérations nies. Pour créer notre plan , nous allons utiliser le mot clé enum
avant class. Toutes les énumérations seront en majuscule et séparées par des virgules:

enum class PlayerStatus {

PLAY, PAUSE, STOP
}

Pour dé nir une valeur, on attribue le nom de l’enum class puis sa valeur

val status = PlayerStatus.PLAY

fi
fi
Enum class
Nous pouvons aussi ajouter des propriétés à un enum. Le constructeur devra avoir une
propriété et chaque cas créera son instance.

enum class PlayerStatus(val stringValue: String) {

PLAY("En cours"),
PAUSE("En pause"),
STOP("Stoppé")
}

val status = PlayerStatus.PLAY

println(status.stringValue)
println(PlayerStatus.values().toList())

On pourra ensuite accéder à cette propriété.

Nous pouvons aussi grâce à values() obtenir un array de tous les cas. Je l’ai converti ici en
liste pour pouvoir le convertir.