Kotlin (langage)

Kotlin
Date de première version	22 juillet 2011
Paradigme	Objet, fonctionnel
Auteur	JetBrains
Dernière version	2.0.20 (22 août 2024)
Version en développement	2.0.0-Beta3 (18 janvier 2024)
Typage	statique, inféré
Influencé par	C# Groovy Java Python Scala
Système d'exploitation	Machine virtuelle Java, JavaScript, LLVM
Licence	Licence Apache 2.0
Site web	kotlinlang.org
Extension de fichier	kt et kts

Kotlin est un langage de programmation orienté objet et fonctionnel, avec un typage statique qui permet de compiler pour la machine virtuelle Java, JavaScript, et vers plusieurs plateformes en natif (grâce à LLVM). Son développement provient principalement d'une équipe de programmeurs chez JetBrains basée à Saint-Pétersbourg en Russie (son nom vient de l'île de Kotline, près de St. Pétersbourg).

Google annonce pendant la conférence Google I/O 2017 que Kotlin devient le second langage de programmation officiellement pris en charge par Android après Java. Le 8 mai 2019, toujours lors de la conférence Google I/O, Kotlin devient officiellement le langage de programmation voulu et recommandé par le géant américain Google pour le développement des applications Android.

Pivotal Software annonce le 4 janvier 2017 le support officiel de Kotlin sur la cinquième version du Framework Spring.

Exemple

Hello World

fun main() {
    println("Bonjour le Monde !")
}

When

fun main() {
    cases("Bonjour")
    cases(1)
    cases(3)
    cases(System.currentTimeMillis())
    cases(MaClasse())
    cases("bonjour")
}

fun cases(obj: Any) {
    when (obj) {
        1 -> println("Un")
        in 2..4 -> println("Entre deux et quatre")
        "Bonjour" -> println("Bienvenue")
        is Long -> println("Long")
        !is String -> println("Pas une chaîne de caractères")
        else -> println("Inconnu")
    }
}

class MaClasse() {
}

Les variables

En Kotlin, il existe deux sortes de variables :

1. Les variables immuables : Ce sont des variables dont la valeur ne peut pas être modifiée après l'initialisation (première affectation) ; elles sont semblables aux variables déclarées final en Java.
2. Les variables modifiables : Ce sont des variables dont la valeur peut changer lors de l'exécution du programme.

Syntaxe Variable immuable : Pour déclarer une variable immuable, on utilise le mot clé val suivi du nom de la variable, qui peut à son tour être suivi de deux points, puis du type, de l'opérateur d'affectation, et enfin de la valeur :

val nomVariable :Type = valeur

Exemple de code qui affiche en console les informations d'un utilisateur enregistré dans une application :

val nomUtilisateur :String = "Monsieur X"
val telUtilisateur :String = "+24206696xxxx"
val paysUtilisateur :String ="Congo-Brazzaville"
val age :Int = 25
    
println(nomUtilisateur)
println(telUtilisateur)
println(paysUtilisateur)
println("$age  ans ")

Syntaxe Variable modifiable : Pour déclarer une variable modifiable, on utilise le mot clé var suivi du nom de la variable, qui peut à son tour être suivi de deux points, du type, de l'opérateur d'affectation, et enfin de la valeur.

var nombre1:Int = 5
var nombre2: Int = 20
var somme:Int = nombre1 + nombre2

println("${nombre1} + ${nombre2} = ${somme}")

somme = somme + 1

println("nouvelle valeur : ${somme}")

Dans cet exemple de code, nous avons créé deux variables de type Int et nous avons additionné leurs valeurs ; Le résultat ainsi obtenu a été mis dans la variable somme de type Int également.

Dans l'instruction d'affichage (println) nous avons utilisé l'interpolation "${variable} " qui permet de concaténer les valeurs avec les chaines de caractères à afficher en console.

Les Types de données en Kotlin

Kotlin est un langage de programmation statiquement typé, ce qui signifie que chaque variable doit avoir un type connu au moment de la compilation. Voici les principaux types de données de base que vous rencontrerez en Kotlin :

Types de base

1. Entiers
   • Int : Représente un entier signé de 32 bits. Plage : -2,147,483,648 à 2,147,483,647
   • Long : Représente un entier signé de 64 bits. Plage : -9,223,372,036,854,775,808 à 9,223,372,036,854,775,807.
2. Flottants
   • Float : Représente un nombre à virgule flottante de 32 bits. Utilisé pour des valeurs avec moins de précision.

Les conditions

If

Le if en Kotlin fonctionne de la même manière que celui en Java.

if (condition) {
    // instructions à exécuter si la condition est vraie
} else {
    // instructions à exécuter si la condition est fausse
}

Exemple :

val entier1:Int = 5
val entier2:Int = 7
val plusPetit :Int
if (entier1<entier2){
    plusPetit = entier1
}else{
    plusPetit = entier2
}
println(plusPetit)

Notes :

1. Ici, nous avons déclaré les variables entier1 et entier2 de type Int.
2. Nous avons également déclaré une variable de type Int nommée plusPetit dans laquelle on affectera la valeur de la variable entier1 ou entier2 qui sera la plus petite.
3. L'instruction if permet de vérifier laquelle des deux variables est la plus petite, puis affecte sa valeur à la variable plusPetit. L'initialisation peut également être faite en une seule expression :

   val plusPetit :Int = if (entier1<entier2) entier1 else entier2
   

When

L'exemple plus haut présente la forme de when similaire à l'instruction switch d'autres langages. En l'occurrence elle peut aussi être utilisée comme une expression :

fun cases(obj: Any) {
    println(when (obj) {
        1 -> "Un"
        in 2..4 -> "Entre deux et quatre"
        "Bonjour" -> "Bienvenue"
        is Long -> "Long"
        !is String -> "Pas une chaîne de caractères"
        else -> "Inconnu"
    })
}

Les boucles

While

La boucle while en Kotlin fonctionne comme celle en Java. Le while sert à répéter une instruction tant qu'une condition est vraie.

while (condition) {
    // instruction à répéter
}

Exemple de code :

var entier:Int = 5
while (entier>0) {
    println("$entier fois 3 font ${entier * 3}")
    entier--
}

Note : Nous déclarons la variable entier de type Int à laquelle on affecte la valeur 5, puis on entre dans la boucle qui sera exécutée jusqu'à ce que la variable entier soit inférieur ou égal à 0.

Do-While

Pour comprendre le fonctionnement de cette boucle en Kotlin, il suffit de penser qu'elle exécute une instruction avant de vérifier la condition et c'est cette instruction qui se répète aussi longtemps que la condition est vraie :

do {
    // instruction à répéter
} while (condition)

Exemple de code :

var entier:Int = 1
do {
    println("$entier fois 3 font ${entier * 3}")
    entier++
}while (entier<=5)

Repeat

La fonction repeat() permet de répéter une instruction un certain nombre de fois :

repeat(nombre) {
    // instruction à répéter
}

Exemple de code :

var entier:Int = 0
repeat(5) {
    entier++
    println("$entier fois 3 font ${entier * 3}")
}

ou (avec indice automatique) :

repeat(5) { i ->
    val entier = i + 1
    println("$entier fois 3 font ${entier * 3}")
}

For

Pour comprendre le fonctionnement de cette boucle en Kotlin, il suffit de se rappeler que la boucle for est une boucle qui a un index ou un itérateur et qui s'exécute autant de fois que l'on a spécifié de répétition.

for (variable in plage) {
    // instruction à répéter
}

Exemple de code :

val nombre :Int = 5
for (entier in 1..nombre) {
    println("$entier fois 3 font ${entier * 3}")
}

Note : Il est important de noter que la boucle for dans Kotlin ne doit pas être confondue avec la boucle for dans Java ou C#, mais doit être plutôt assimilée à la boucle foreach.

Annexes

Liens externes

• (en) Site officiel