Votre premier programme Kotlin ('Hello World!')

Le rituel initiatique : pourquoi "Hello, World!" ?

Entamer l'apprentissage d'un nouveau langage de programmation passe presque invariablement par une étape symbolique : écrire un programme qui affiche "Hello, World!". Cette tradition, bien qu'élémentaire, remplit plusieurs objectifs pédagogiques cruciaux. Elle permet de vérifier que votre environnement de développement (JDK et IDE) est correctement configuré et fonctionnel. Elle vous familiarise avec le processus de création, de compilation et d'exécution d'un programme dans ce nouveau langage. Enfin, elle introduit la syntaxe la plus minimale nécessaire pour obtenir un résultat visible, offrant une première victoire rapide et encourageante.

Pour Kotlin, ce premier pas est particulièrement simple et illustre d'emblée la concision du langage. Nous allons maintenant vous guider à travers la création et l'exécution de ce programme fondamental, en supposant que vous avez déjà installé un JDK et l'IDE IntelliJ IDEA (comme vu dans la section précédente).

Création du projet et du fichier dans IntelliJ IDEA

Ouvrez IntelliJ IDEA. Si vous n'avez pas encore de projet, créez-en un nouveau en choisissant "New Project". Dans l'assistant de création, sélectionnez "Kotlin" dans la liste des langages à gauche. Pour le type de projet, choisissez "Console Application". Cela configure un projet simple destiné à s'exécuter dans la console, idéal pour nos débuts. Donnez un nom à votre projet (par exemple, `HelloKotlin`) et vérifiez que le bon JDK est sélectionné. Cliquez sur "Create".

IntelliJ IDEA va générer une structure de projet basique. Dans l'explorateur de projet (généralement à gauche), naviguez jusqu'au dossier `src/main/kotlin`. Vous y trouverez un fichier Kotlin, souvent nommé `Main.kt` par défaut. Double-cliquez dessus pour l'ouvrir dans l'éditeur.

Il est possible que l'IDE ait déjà généré un squelette de code contenant la fonction `main`. Si c'est le cas, vous pouvez le modifier. Sinon, vous allez écrire le code vous-même dans ce fichier vide.

Le code source : écrire notre "Hello, World!"

Dans le fichier `Main.kt` ouvert, tapez ou collez le code suivant. C'est l'intégralité du code nécessaire pour notre premier programme :

fun main() {
    println("Hello, Kotlin World!")
}

Ce bloc de code constitue un programme Kotlin complet et exécutable. Même si vous ne comprenez pas encore chaque symbole, remarquez sa compacité. Nous allons maintenant décortiquer chaque élément pour que tout devienne clair.

Anatomie du code "Hello, World!" en Kotlin

Décortiquons ligne par ligne, mot par mot, ce que fait notre programme :

• `fun` : C'est le mot-clé utilisé en Kotlin pour déclarer une fonction. Les fonctions sont des blocs de code nommés qui effectuent une tâche spécifique.
• `main` : C'est un nom spécial pour une fonction. Quand vous exécutez un programme Kotlin (sur la JVM ou en natif), le système cherche une fonction nommée `main` pour savoir où commencer l'exécution. C'est le point d'entrée de notre application.
• `()` : Les parenthèses après le nom de la fonction (`main`) servent à déclarer les paramètres que la fonction peut recevoir. Dans notre cas, elles sont vides, indiquant que notre fonction `main` ne prend aucun argument pour l'instant.
• `{}` : Les accolades définissent le début et la fin du corps de la fonction. Tout le code qui se trouve entre ces accolades appartient à la fonction `main` et sera exécuté lorsque cette fonction sera appelée.
• `println("Hello, Kotlin World!")` : C'est l'instruction unique à l'intérieur de notre fonction `main`.
  • `println` est une autre fonction, fournie par la bibliothèque standard de Kotlin. Son rôle est d'afficher du texte sur la sortie standard (généralement la console).
  • Le `ln` à la fin de `println` signifie "line" (ligne) : après avoir affiché le texte, elle ajoute un saut de ligne, déplaçant le curseur à la ligne suivante dans la console.
  • `"Hello, Kotlin World!"` est le texte (une chaîne de caractères, ou `String` en Kotlin) que nous demandons à `println` d'afficher. Le texte doit être entouré de guillemets doubles.

En résumé, nous avons défini une fonction `main` (le point de départ) qui contient une seule instruction : afficher le message "Hello, Kotlin World!" suivi d'un saut de ligne.

Exécution du programme et observation du résultat

Maintenant que le code est écrit, il est temps de l'exécuter. IntelliJ IDEA rend cela très facile. Repérez la petite icône en forme de flèche verte (ou triangle) dans la marge gauche de l'éditeur, juste à côté de la ligne `fun main() {`.

Cliquez sur cette flèche verte. Un petit menu apparaîtra. Choisissez la première option, qui sera quelque chose comme "Run 'MainKt'" (le nom peut varier légèrement selon le nom de votre fichier).

IntelliJ IDEA va alors compiler votre code Kotlin en bytecode Java (si vous ciblez la JVM), puis lancer la JVM pour exécuter ce bytecode. En bas de la fenêtre de l'IDE, un panneau appelé "Run" ou "Console" s'ouvrira (ou deviendra actif). Vous devriez y voir apparaître le texte suivant :

Hello, Kotlin World!

Si vous voyez ce message, félicitations ! Votre environnement est fonctionnel et vous avez réussi à exécuter votre premier programme Kotlin. Si vous rencontrez une erreur, vérifiez attentivement que le code a été copié exactement et que votre JDK est correctement configuré dans l'IDE.

Ce que nous apprend ce premier programme

Bien que simple, ce "Hello, World!" nous enseigne déjà quelques fondamentaux sur Kotlin :

• Structure de base : Le code Kotlin est organisé en fonctions (déclarées avec `fun`).
• Point d'entrée : L'exécution d'une application console commence par la fonction `main()`.
• Syntaxe des fonctions : La structure `fun nom() { ... }` est la base pour définir une fonction.
• Sortie standard : La fonction `println()` est le moyen simple d'afficher des informations.
• Fichiers Kotlin : Le code source Kotlin est enregistré dans des fichiers avec l'extension `.kt`.

Vous avez franchi la première étape. Ce succès initial, même modeste, est la base sur laquelle nous allons construire notre compréhension de Kotlin dans les chapitres suivants, en explorant des concepts plus élaborés comme les variables, les types de données et les structures de contrôle.