Debuter avec Kotlin

Pourquoi Kotlin ?

Kotlin est un langage de programmation moderne, concurrent et orienté objet qui a été créé par JetBrains en 2011. Son but principal est d'offrir une alternative à Java pour le développement Android, tout en maintenant la compatibilité avec le code Java existant.

Un cas d'usage concret : Kotlin permet de développer des applications mobiles Android plus rapidement et efficacement grâce à sa syntaxe concise et à ses fonctionnalités avancées.

Prerequis

Pour suivre ce tutoriel, vous aurez besoin des éléments suivants :

• Java JDK : La version minimale requise est Java 8. Vous pouvez la télécharger ici.

• IntelliJ IDEA ou Android Studio : JetBrains propose une version Community Edition gratuite qui convient parfaitement pour développer en Kotlin. Vous pouvez la télécharger ici.

Concepts fondamentaux

Variables et types de données

Kotlin est un langage statiquement typé, ce qui signifie que vous devez déclarer le type des variables à l'avance.

// Déclaration d'une variable mutable (qui peut être modifiée)
var nombre: Int = 10

// Déclaration d'une variable immutable (qui ne peut pas être modifiée)
val message: String = "Bonjour, Kotlin"

Fonctions

Les fonctions en Kotlin sont définies avec le mot-clé fun. Elles peuvent retourner une valeur ou non.

// Fonction qui retourne une valeur
fun add(a: Int, b: Int): Int {
    return a + b
}

// Fonction qui ne retourne pas de valeur (unit)
fun afficherMessage(message: String) {
    println(message)
}

Structures de contrôle

Kotlin offre des structures de contrôle similaires à Java.

val age = 18

if (age >= 18) {
    println("Vous êtes majeur")
} else {
    println("Vous êtes mineur")
}

for (i in 1..5) {
    println(i)
}

Mise en pratique : projet fil rouge

Nous allons construire un gestionnaire de tâches simple en Kotlin. Ce projet comprendra les fonctionnalités suivantes :

• Ajouter une tâche
• Supprimer une tâche
• Afficher la liste des tâches

Étape 1 : Création du projet

Ouvrez IntelliJ IDEA et créez un nouveau projet Kotlin.

## Nécessite d'avoir l'interface de ligne de commande de Kotlin installée
kotlinc -init

Cela créera une structure de projet de base avec un fichier Main.kt.

Étape 2 : Définition des données

Créez un fichier Task.kt pour définir la classe de tâche.

// Task.kt
data class Task(val id: Int, var description: String)

Étape 3 : Gestionnaire de tâches

Créez un fichier TaskManager.kt pour gérer les opérations sur les tâches.

// TaskManager.kt
class TaskManager {
    private val tasks = mutableListOf<Task>()

    fun addTask(description: String) {
        val id = if (tasks.isNotEmpty()) tasks.last().id + 1 else 1
        tasks.add(Task(id, description))
    }

    fun removeTask(id: Int) {
        tasks.removeIf { it.id == id }
    }

    fun getTasks(): List<Task> {
        return tasks.toList()
    }
}

Étape 4 : Interface utilisateur

Créez un fichier Main.kt pour l'interface utilisateur.

// Main.kt
fun main() {
    val taskManager = TaskManager()

    while (true) {
        println("1. Ajouter une tâche")
        println("2. Supprimer une tâche")
        println("3. Afficher les tâches")
        println("4. Quitter")

        print("Choisissez une option : ")
        val choice = readLine()?.toIntOrNull()

        when (choice) {
            1 -> {
                print("Description de la tâche : ")
                val description = readLine() ?: ""
                taskManager.addTask(description)
                println("Tâche ajoutée avec succès.")
            }
            2 -> {
                print("ID de la tâche à supprimer : ")
                val id = readLine()?.toIntOrNull()
                if (id != null) {
                    taskManager.removeTask(id)
                    println("Tâche supprimée avec succès.")
                } else {
                    println("ID invalide.")
                }
            }
            3 -> {
                val tasks = taskManager.getTasks()
                if (tasks.isEmpty()) {
                    println("Aucune tâche enregistrée.")
                } else {
                    for (task in tasks) {
                        println("${task.id}: ${task.description}")
                    }
                }
            }
            4 -> return
            else -> println("Option invalide.")
        }
    }
}

Étape 5 : Exécution du programme

Exécutez le fichier Main.kt en cliquant sur le bouton "Run" dans IntelliJ IDEA.

## Si vous utilisez l'interface de ligne de commande Kotlin
kotlinc Main.kt -include-runtime -d TaskManager.jar
java -jar TaskManager.jar

Erreurs frequentes et debugging

Erreur 1 : NonNull assertions

// ❌ Mauvais
val name = getString()!!

// ✅ Correct
val name: String? = getString()
if (name != null) {
    println(name)
} else {
    println("Nom non défini")
}

Erreur 2 : Invocation de méthodes sur des objets nullables

// ❌ Mauvais
val user = getUserById(1)
user?.name?.length

// ✅ Correct
val user = getUserById(1) ?: return
println(user.name.length)

Erreur 3 : Utilisation de l'opérateur Elvis

// ❌ Mauvais
val username: String? = null
val displayName = username ?: "Utilisateur anonyme"

// ✅ Correct
val username: String? = null
val displayName = if (username != null) username else "Utilisateur anonyme"

Pour aller plus loin

1. Fonctions lambda et fonctions de haut niveau : Découvrez comment utiliser des fonctions lambda pour simplifier le code.

2. Extensions : Apprenez à étendre les classes existantes avec des méthodes personnalisées sans modifier leur source.

3. Data classes : Utilisez les data classes pour simplifier la création de classes qui contiennent principalement des données.

Défi pratique : Créez un mini-projet d'API REST en utilisant le framework Spring Boot et Kotlin. Cette API devrait permettre de gérer des utilisateurs (ajouter, supprimer, afficher).