1.
## **Cours détaillé
sur la maîtrise du
langage Kotlin pour
débutant**
2. ### **Introduction
à Kotlin**
3. Kotlin est un
langage de
programmation
moderne, concis et
expressif, conçu
principalement pour
la JVM (Java Virtual
Machine). Il est utilisé
pour le
développement
d’applications
Android, mais aussi
pour le backend, le
développement web
et même le
développement
multiplateforme avec
Kotlin Multiplatform.
4. ---
5. ## **1. Installation
et configuration de
Kotlin**
6. ### **1.1
Prérequis**
7. Avant de
commencer avec
Kotlin, vous devez
installer un
environnement de
développement :
8. - **Java
Development Kit
(JDK)** (Kotlin
fonctionne sur la
JVM)
9. - **Un IDE
compatible**,
comme **IntelliJ
IDEA
(recommandé)**,
**Android Studio**
(pour Android), ou
**VS Code** avec
l’extension Kotlin.
10. ### **1.2
Installation de
Kotlin**
11. #### **Avec
IntelliJ IDEA**
12. 1. Téléchargez et
installez IntelliJ IDEA
Community Edition.
13. 2. Créez un
nouveau projet Kotlin
en sélectionnant
**Kotlin/JVM**.
14. 3. Ajoutez un
fichier `.kt` et
commencez à coder.
15. #### **Avec la
ligne de commande**
16. 1. Installez Kotlin
via le SDK :
17. ```sh
18. sdk install kotlin
19. ```
20. 2. Exécutez un
fichier Kotlin :
21. ```sh
22. kotlinc [Link] -
include-runtime -d
[Link]
23. java -jar [Link]
24. ```
25. ---
26. ## **2. Syntaxe
de base en Kotlin**
27. ### **2.1 Hello
World en Kotlin**
28. ```kotlin
29. fun main() {
30. println("Hello,
World!")
31. }
32. ```
33. Explication :
34. - `fun main() {}` :
Déclare une fonction
principale qui sert de
point d’entrée au
programme.
35. - `println("Hello,
World!")` : Affiche du
texte dans la console.
36. ### **2.2
Variables et
constantes**
37. ####
**Déclaration de
variables**
38. ```kotlin
39. var age: Int =
25 // Variable
modifiable
40. val nom: String =
"Jean" // Constante
(non modifiable)
41. ```
42. - `var` : Déclare
une variable mutable
(modifiable).
43. - `val` : Déclare
une variable
immuable
(constante).
44. #### **Inférence
de type**
45. ```kotlin
46. var ville =
"Paris" // Kotlin
déduit que c'est une
String
47. val pi =
3.14159 // Kotlin
déduit que c'est un
Double
48. ```
49. ---
50. ## **3. Structures
de contrôle**
51. ### **3.1
Conditions (`if`,
`when`)**
52. #### **Utilisation
de `if`**
53. ```kotlin
54. val age = 20
55. if (age >= 18) {
56.
println("Majeur")
57. } else {
58.
println("Mineur")
59. }
60. ```
61. #### **Utilisation
de `when` (équivalent
de `switch` en Java)**
62. ```kotlin
63. val jour = 3
64. val nomJour =
when (jour) {
65. 1 -> "Lundi"
66. 2 -> "Mardi"
67. 3 -> "Mercredi"
68. else ->
"Inconnu"
69. }
70. println(nomJour)
71. ```
72. ---
73. ### **3.2 Boucles
(`for`, `while`, `do-
while`)**
74. #### **Boucle
`for`**
75. ```kotlin
76. for (i in 1..5) {
77.
println("Nombre: $i")
78. }
79. ```
80. - `1..5` : Plage de
nombres de 1 à 5
inclus.
81. #### **Boucle
`while`**
82. ```kotlin
83. var x = 5
84. while (x > 0) {
85.
println("Compte à
rebours: $x")
86. x--
87. }
88. ```
89. #### **Boucle
`do-while`**
90. ```kotlin
91. var y = 0
92. do {
93. println("Valeur:
$y")
94. y++
95. } while (y < 3)
96. ```
97. ---
98. ## **4. Fonctions
en Kotlin**
99. ### **4.1
Déclaration et appel
de fonction**
100. ```kotlin
101. fun addition(a:
Int, b: Int): Int {
102. return a + b
103. }
104. val resultat =
addition(5, 10)
105. println(resultat) /
/ Affiche 15
106. ```
107. - `fun` : Mot-clé
pour déclarer une
fonction.
108. - `(a: Int, b: Int):
Int` : Paramètres avec
leur type et le type de
retour.
109. ### **4.2
Fonction avec une
valeur par défaut**
110. ```kotlin
111. fun saluer(nom:
String = "Utilisateur")
{
112.
println("Bonjour,
$nom!")
113. }
114. saluer() // Affiche
"Bonjour,
Utilisateur!"
115. saluer("Alice") //
Affiche "Bonjour,
Alice!"
116. ```
117. ### **4.3
Fonction lambda
(fonction
anonyme)**
118. ```kotlin
119. val carre: (Int) ->
Int = { x -> x * x }
120. println(carre(4)) /
/ Affiche 16
121. ```
122. ---
123. ## **5.
Programmation
orientée objet (POO)
en Kotlin**
124. ### **5.1
Définition d’une
classe et d’un objet**
125. ```kotlin
126. class Voiture(val
marque: String, val
modele: String) {
127. fun
afficherDetails() {
128.
println("Voiture:
$marque $modele")
129. }
130. }
131. val maVoiture =
Voiture("Toyota",
"Corolla")
132. [Link]
rDetails() // Affiche
"Voiture: Toyota
Corolla"
133. ```
134. ### **5.2
Constructeur primaire
et secondaire**
135. ```kotlin
136. class Personne(val
nom: String, val age:
Int) {
137. init {
138.
println("Personne
créée: $nom, $age
ans")
139. }
140. }
141. val p1 =
Personne("Alice", 30)
142. ```
143. ### **5.3
Héritage**
144. ```kotlin
145. open class
Animal(val nom:
String) {
146. open fun
faireDuBruit() {
147.
println("$nom fait du
bruit")
148. }
149. }
150. class Chien(nom:
String) : Animal(nom)
{
151. override fun
faireDuBruit() {
152.
println("$nom aboie")
153. }
154. }
155. val chien =
Chien("Rex")
156. [Link]
() // Affiche "Rex
aboie"
157. ```
158. ---
159. ## **6.
Collections en
Kotlin**
160. ### **6.1 Listes
(`List`)**
161. ```kotlin
162. val liste =
listOf("Pomme",
"Banane",
"Cerise") // Liste
immuable
163. val listeMutable =
mutableListOf("Pom
me", "Banane") //
Liste modifiable
164. [Link](
"Cerise")
165. println(listeMutab
le) // ["Pomme",
"Banane", "Cerise"]
166. ```
167. ### **6.2 Maps
(`Map`)**
168. ```kotlin
169. val capitales =
mapOf("France" to
"Paris", "Italie" to
"Rome")
170. println(capitales["
France"]) // Affiche
"Paris"
171. ```
172. ---
173. ## **7.
Programmation
asynchrone avec
Kotlin Coroutines**
174. ```kotlin
175. import
[Link].*
176. fun main() =
runBlocking {
177. launch {
178. delay(1000L)
179.
println("Coroutine
terminée")
180. }
181.
println("Programme
principal continue...")
182. }
183. ```
184. - `launch` : Lance
une coroutine.
185. - `delay(1000L)` :
Pause de 1 seconde.
186. - `runBlocking` :
Bloque le thread
principal jusqu’à la fin
des coroutines.
187. ---
188. ## **8. Utilisation
de Kotlin pour
Android**
189. Avec Kotlin, vous
pouvez développer
des applications
Android plus
efficacement.
Exemple d’une
**Activity** :
190. ```kotlin
191. class
MainActivity :
AppCompatActivity()
{
192. override fun
onCreate(savedInstan
ceState: Bundle?) {
193.
[Link](saved
InstanceState)
194.
setContentView([Link]
out.activity_main)
195. }
196. }
197. ```
198. -
`AppCompatActivity()
` : Classe de base
pour une activité
Android.
199. - `onCreate()` :
Fonction exécutée
lors du démarrage de
l’activité.
200. ---
201. ###
**Conclusion**
202. Kotlin est un
langage puissant et
flexible, idéal pour les
débutants comme
pour les
développeurs
expérimentés. Avec
sa syntaxe concise et
ses nombreuses
fonctionnalités
modernes, il est
aujourd’hui un choix
privilégié pour le
développement
Android et au-delà.
