Votre premier programme en Kotlin

Restez organisé à l'aide des collections Enregistrez et classez les contenus selon vos préférences.

1. Avant de commencer

Kotlin avec le logo Android

Dans ce cours, vous allez créer des applications en écrivant du code dans le langage de programmation Kotlin, le langage recommandé par Google pour créer des applications Android.

Kotlin est un langage de programmation moderne qui aide les développeurs à gagner en productivité. Par exemple, Kotlin vous permet d'être plus concis et d'écrire moins de lignes de code pour la même fonctionnalité que les autres langages de programmation. Les applications développées en Kotlin sont également moins susceptibles de planter, ce qui se traduit par une application plus stable et plus robuste pour les utilisateurs. Globalement, Kotlin vous permet de créer de meilleures applications Android et plus rapidement. C'est pourquoi Kotlin prend de l'ampleur dans le secteur et est d'ailleurs le langage utilisé par la majorité des développeurs Android professionnels.

Pour commencer à créer des applications Android en Kotlin, il est important d'avoir des bases solides en concepts de programmation en Kotlin. Grâce à ces ateliers de programmation, vous découvrirez les bases de la programmation Kotlin avant de vous plonger dans la création d'applications.

Objectifs de l'atelier

  • Programmes courts en Kotlin qui affichent des messages lorsque vous les exécutez.

Points abordés

  • Rédiger et exécuter un programme Kotlin simple.
  • Modifier un programme simple pour changer la sortie.

Ce dont vous avez besoin

  • Un ordinateur avec accès à Internet et un navigateur Web.

2. Commencer

Dans cet atelier de programmation, vous allez explorer et modifier des programmes simples en Kotlin. Un programme est une série d'instructions qui permettent à un ordinateur ou à un appareil mobile d'effectuer une action, comme afficher un message à un utilisateur ou calculer le prix des articles d'un panier. Les instructions détaillées sur ce que doit faire l'ordinateur sont appelées code. Lorsque vous modifiez le code d'un programme, la sortie peut changer.

Vous pouvez utiliser un outil appelé éditeur de code pour rédiger et modifier votre code. Il ressemble à un éditeur de texte dans lequel vous pouvez écrire et modifier du texte, mais il permet également d'écrire du code avec plus de précision. Par exemple, un éditeur de code propose des suggestions de saisie semi-automatique lors de la frappe et affiche des messages d'erreur lorsque le code est incorrect.

Pour vous familiariser avec le langage Kotlin, vous allez utiliser un éditeur de code interactif appelé Kotlin Playground. Vous pouvez y accéder depuis un navigateur Web, ce qui vous évite d'installer un logiciel sur votre ordinateur. Vous pouvez modifier et exécuter le code Kotlin directement dans Kotlin Playground et afficher la sortie.

Notez que vous ne pouvez pas créer d'applications Android dans Kotlin Playground. Par la suite, vous installerez et utiliserez un outil appelé Android Studio pour rédiger et modifier le code de votre application Android.

Maintenant que vous savez tout sur Kotlin, découvrez votre premier programme !

3. Ouvrir Kotlin Playground

Dans un navigateur Web sur votre ordinateur, ouvrez Kotlin Playground.

Vous devriez voir une page Web semblable à celle-ci :

Cela montre une capture d'écran de Kotlin Playground. L'éditeur de code contient un programme qui affiche "Hello, world!" comme sortie.

Un code par défaut est déjà inséré dans l'éditeur de code. Ces trois lignes de code constituent un programme simple :

fun main() {
    println("Hello, world!")
}

Même si vous n'avez jamais programmé, pouvez-vous deviner ce que fait le programme ?

Vérifiez si votre hypothèse est correcte en passant à la section suivante !

4. Exécuter votre premier programme

Cliquez sur Bouton d'exécution pour exécuter le programme.

Beaucoup de choses se produisent lorsque vous cliquez sur le bouton "Exécuter". Le code en langage de programmation Kotlin est conçu pour être compris par les humains. Il permet aux utilisateurs de lire, écrire et collaborer plus facilement sur les programmes Kotlin. Cependant, votre ordinateur ne comprend pas immédiatement cette langue.

Vous avez besoin d'un outil appelé compilateur Kotlin, qui convertit le code Kotlin que vous avez écrit ligne par ligne afin de le traduire en un langage compréhensible par l'ordinateur. Ce processus est la compilation de votre code.

Si votre code se compile correctement, votre programme se lancera (c'est-à-dire s'exécutera). Lorsque l'ordinateur exécute votre programme, il effectue chacune de vos instructions. Si vous avez déjà suivi une recette de cuisine, l'exécution de chaque étape est considérée comme l'exécution de chaque étape de préparation.

Voici une capture d'écran de ce que vous devriez voir lorsque vous exécutez votre programme.

Cette capture d'écran montre une partie de la page Web de Kotlin Playground. L'éditeur de code affiche le code d'un programme Hello World. Sous l'éditeur de code, un volet de sortie affiche la phrase "Hello, world!".

En bas de l'éditeur de code, vous devriez voir un volet qui affiche la sortie, ou le résultat de votre programme :

Hello, world!

Cool ! Ce programme a pour but d'imprimer ou d'afficher le message Hello, world!.

Comment ça marche ? Un programme Kotlin doit disposer d'une fonction principale, qui correspond à l'endroit précis de votre code où commence le compilateur Kotlin. La fonction principale est le point d'entrée (ou point de départ) du programme.

Une flèche intitulée "Commencez ici" pointe vers la première ligne de la fonction principale d'un programme simple.

Vous vous demandez peut-être ce qu'est une fonction ?

5. Composantes d'une fonction

Une fonction est un segment d'un programme qui exécute une tâche spécifique. Votre programme peut avoir une seule ou plusieurs fonctions.

Définir vs appeler une fonction

Dans votre code, vous commencez par définir une fonction. Vous devez donc spécifier toutes les instructions nécessaires pour effectuer cette tâche.

Une fois la fonction définie, vous pouvez l'appeler afin que les instructions qu'elle contient soient effectuées ou exécutées.

Voici une analogie. Vous écrivez étape par étape comment préparer un gâteau au chocolat. Cet ensemble d'instructions peut avoir le nom suivant : bakeChocolateCake. Chaque fois que vous souhaitez faire un gâteau, vous pouvez exécuter les instructions bakeChocolateCake. Si vous voulez trois gâteaux, vous devez exécuter les instructions bakeChocolateCake trois fois. La première étape consiste à définir les étapes et à leur attribuer un nom, c'est ce qu'on appelle définir la fonction. Vous pouvez ensuite revenir à ces étapes à tout moment pour qu'elles soient exécutées, c'est l'appel de la fonction.

Définir une fonction

Voici les éléments clés nécessaires pour définir une fonction :

  • La fonction a besoin d'un nom pour que vous puissiez l'appeler plus tard.
  • La fonction peut également nécessiter des entrées ou des informations à fournir une fois appelée. La fonction utilise ces entrées pour remplir son objectif. Les entrées sont facultatives, et certaines fonctions ne nécessitent aucune entrée.
  • La fonction comporte également un corps, qui contient les instructions pour effectuer la tâche.

Ce schéma représente une fonction sous la forme d'un cadre noir intitulé "name" (nom), qui correspond au nom de la fonction. À l'intérieur de ce cadre se trouve une zone plus petite appelée "body" (corps), qui représente le corps de la fonction dans la fonction. Une étiquette "inputs" (entrées) accompagnée d'une flèche pointant vers le cadre noir de la fonction est aussi représentée. Cela indique que des entrées de fonction sont transmises à la fonction.

Pour traduire le schéma ci-dessus en code Kotlin, utilisez la syntaxe (ou le format) suivante pour définir une fonction. L'ordre de ces éléments est important. Le mot "fun" apparaît en premier, suivi du nom de la fonction, puis des entrées entre parenthèses, et enfin des accolades autour du corps de la fonction.

Ce schéma illustre la syntaxe (ou le format) utilisée pour déclarer une fonction en code Kotlin. La fonction commence par le mot "fun" (pour "fonction"). À droite se trouve un cadre intitulé "name" (nom). À droite du cadre du nom se trouve une zone intitulée "inputs" (entrées), entourée de parenthèses. Après les entrées se trouve une accolade ouvrante. Sur la ligne suivante, un champ intitulé "body" (corps) est affiché en retrait à droite. En bas de la fonction, après le corps, se trouve une accolade fermante.

Retenez les éléments clés d'une fonction présentés dans l'exemple d'une fonction principale que vous avez vu dans Kotlin Playground :

  • La définition de la fonction commence par le mot fun.
  • Le nom de la fonction est alors main.
  • Comme il n'existe aucune entrée pour la fonction, les parenthèses sont vides.
  • Le corps de la fonction contient une ligne de code, println("Hello, world!"), située entre les accolades d'ouverture et de fermeture de la fonction.

Le code de la fonction principale suivant est illustré dans l'image : fun main() {     println("Hello, world!") } Une étiquette "name" pointe vers le mot "main" (principal). Une étiquette "inputs" pointe vers les parenthèses.  Une étiquette "body" pointe vers la ligne de code println("Hello, world!").

Chaque partie de la fonction est expliquée plus en détail ci-dessous.

Mot clé d'une fonction

Pour indiquer que vous êtes sur le point de définir une fonction en Kotlin, utilisez le mot spécial fun (abréviation de fonction) sur une nouvelle ligne. Vous devez saisir fun exactement tel qu'il apparaît en minuscules. Vous ne pouvez pas utiliser "func", "function" ou toute autre orthographe, car le compilateur Kotlin ne reconnaîtra pas ce que vous voulez dire.

Ces mots spéciaux sont appelés mots clés en Kotlin et sont réservés à un usage spécifique, comme la création d'une fonction par exemple.

Nom d'une fonction

Les fonctions ont des noms qui permettent de les distinguer les unes des autres, de la même manière que les utilisateurs ont des noms pour s'identifier. Le nom de la fonction se trouve après le mot clé fun.

Ce schéma illustre la syntaxe (ou le format) utilisée pour déclarer une fonction en code Kotlin. La fonction commence par le mot "fun" (pour "fonction"). À droite se trouve un cadre intitulé "name" (nom). La cadre "name" possède une bordure et un arrière-plan verts pour mettre en évidence cette partie de la définition de la fonction. À droite du cadre du nom se trouve une zone intitulée "inputs" (entrées), entourée de parenthèses. Après les entrées se trouve une accolade ouvrante. Sur la ligne suivante, un champ intitulé "body" (corps) est affiché en retrait à droite. En bas de la fonction, après le corps, se trouve une accolade fermante.

Choisissez un nom adapté à votre fonction, en lien avec son rôle ou objectif. Le nom est généralement un verbe ou une expression verbale. Nous vous recommandons d'éviter d'utiliser un mot clé Kotlin comme nom de fonction.

Les noms de fonction doivent respecter la convention camel case : le premier mot du nom de la fonction s'écrit en minuscules. S'il est composé de plusieurs mots, il ne doit pas y avoir d'espace entre eux, et tous les autres mots doivent commencer par une majuscule.

Exemples de noms de fonctions :

  • calculateTip
  • displayErrorMessage
  • takePhoto

Entrées d'une fonction

Notez que le nom de la fonction est toujours suivi de parenthèses. Et que c'est entre ces parenthèses que vous listez les entrées de la fonction.

Ce schéma illustre la syntaxe (ou le format) utilisée pour déclarer une fonction en code Kotlin. La fonction commence par le mot "fun" (pour "fonction"). À droite se trouve un cadre intitulé "name" (nom). À droite du cadre du nom se trouve une zone intitulée "inputs" (entrées), entourée de parenthèses. La cadre "inputs" possède une bordure et un arrière-plan verts pour mettre en évidence cette partie de la fonction. Après les entrées se trouve une accolade ouvrante. Sur la ligne suivante, un champ intitulé "body" (corps) est affiché en retrait à droite. En bas de la fonction, après le corps, se trouve une accolade fermante.

Une entrée est une donnée nécessaire à l'exécution d'une fonction. Lorsque vous définissez une fonction, vous pouvez exiger que certaines entrées soient transmises lors de l'appel de la fonction. Si aucune entrée n'est requise pour une fonction, les parenthèses sont vides ().

Voici quelques exemples de fonctions avec un nombre d'entrées différent :

Le schéma suivant illustre une fonction appelée addOne. L'objectif de la fonction est d'ajouter 1 à un nombre donné. Il y a une entrée, qui est le nombre donné. Dans le corps de la fonction, un code ajoute 1 au nombre transmis dans la fonction.

Ce schéma représente une fonction sous la forme d'un cadre noir intitulé "addOne" (ajouter un), qui correspond au nom de la fonction. À l'intérieur de ce cadre se trouve une zone plus petite qui représente le corps de la fonction. Dans le cadre "body" de la fonction se trouve le texte "number + 1" (nombre + 1). À l'extérieur du cadre noir "function" se trouve un cadre intitulé "number" (nombre) avec une flèche pointant vers le cadre de la fonction. Le nombre est une entrée de la fonction.

Dans l'exemple suivant, la fonction s'appelle printFullName. Deux fonctions sont requises pour la fonction, l'une pour le prénom et l'autre pour le nom de famille. Le corps de la fonction affiche le prénom et le nom au niveau de la sortie, pour afficher le nom complet de la personne.

Ce schéma représente une fonction sous la forme d'un cadre noir intitulé "printFullName" (afficher le nom complet), qui correspond au nom de la fonction. À l'intérieur de ce cadre se trouve une zone plus petite qui représente le corps de la fonction. Dans le cadre "body" de la fonction se trouve le texte "Print firstName and lastName in the output" (afficher le prénom et le nom dans la sortie). À l'extérieur du cadre noir de la fonction, deux cadres sont respectivement intitulés "firstName" et "lastName". Des flèches venant de ces deux cadres pointent vers le cadre noir de la fonction. firstName et lastName sont deux entrées de la fonction.

Ce dernier exemple montre une fonction qui ne nécessite aucune entrée pour être transmise lorsque la fonction est appelée. Lorsque vous appelez la fonction displayHello(), un message "Hello" s'affiche dans le résultat.

Ce schéma représente une fonction sous la forme d'un cadre noir intitulé "displayHello" (afficher Hello), qui correspond au nom de la fonction. À l'intérieur de ce cadre se trouve une zone plus petite qui représente le corps de la fonction. Dans le cadre "body" de la fonction se trouve le texte "Print Hello in the output" (afficher Hello dans la sortie).

Corps d'une fonction

Le corps de la fonction contient les instructions nécessaires à sa réalisation. Vous pouvez le repérer en cherchant les lignes de code entre les accolades d'ouverture et de fermeture.

Ce schéma illustre la syntaxe (ou le format) utilisée pour déclarer une fonction en code Kotlin. La fonction commence par le mot "fun" (pour "fonction"). À droite se trouve un cadre intitulé "name" (nom). À droite du cadre du nom se trouve une zone intitulée "inputs" (entrées), entourée de parenthèses. Après les entrées se trouve une accolade ouvrante. Sur la ligne suivante, un champ intitulé "body" (corps) est affiché en retrait à droite. La cadre "body" possède une bordure et un arrière-plan verts pour mettre en évidence cette partie de la fonction. En bas de la fonction, après le corps, se trouve une accolade fermante.

Présentation d'un programme simple

Reprenons le programme simple que nous avons vu plus tôt dans cet atelier de programmation.

Le code de la fonction principale suivant est illustré dans l'image : fun main() {     println("Hello, world!") } Une étiquette "name" pointe vers le mot "main" (principal). Une étiquette "inputs" pointe vers les parenthèses.  Une étiquette "body" pointe vers la ligne de code println("Hello, world!").

Le programme contient une fonction : la fonction principale. "main" est un nom de fonction spécial en Kotlin. Lorsque vous écrivez votre code dans Kotlin Playground, il doit être écrit dans la fonction main() ou appelé à partir de la fonction main().

Le corps de cette fonction main() ne contient qu'une seule ligne de code :

println("Hello, world!")

Cette ligne de code est une instruction, car elle effectue une action spécifique, qui consiste à afficher le texte Hello, world! dans le volet de sortie. Plus précisément, la fonction println() est appelée sur cette ligne de code. println() est une fonction déjà définie dans le langage Kotlin. Cela signifie que l'équipe d'ingénieurs qui a créé le langage Kotlin a déjà écrit la déclaration de fonction pour la fonction println(). La fonction requiert une entrée, c'est-à-dire le message devant être affiché

Lorsque vous appelez la fonction println(), placez le texte du message entre parenthèses après le nom de la fonction. Veillez à insérer des guillemets autour du texte à afficher, par exemple "Hello, world!".

Une fois le programme exécuté, le message transmis à la fonction println() est affiché dans la sortie :

Hello, world!

Essayez

Revenons à présent au code d'origine du programme. Pouvez-vous modifier le code dans Kotlin Playground pour afficher ce message à la place ?

Hello, Android!

6. Modifier votre programme

  1. Pour modifier le message affiché au niveau de la sortie, modifiez l'appel de fonction println() sur la deuxième ligne du programme. Remplacez world par Android dans la fonction println(). Assurez-vous que "Hello, Android!" est toujours entre guillemets et entre parenthèses.
fun main() {
    println("Hello, Android!")
}
  1. Exécutez le programme.
  2. La sortie doit afficher le message suivant :
Hello, Android!

Bravo, vous avez modifié votre premier programme !

Pouvez-vous modifier votre code de sorte que le message s'affiche deux fois ? Voici ce que nous souhaitons obtenir :

Hello, Android!
Hello, Android!

Vous pouvez insérer autant de lignes d'instructions dans une fonction que nécessaire pour effectuer une tâche. Toutefois, notez qu'il ne doit y avoir qu'une seule instruction par ligne en Kotlin. Si vous souhaitez écrire une autre instruction, placez-la sur une nouvelle ligne de la fonction.

Pour modifier votre programme afin d'afficher plusieurs lignes de texte :

  1. Copiez l'instruction initiale println() et collez-la en dessous dans le corps de la fonction. Les deux instructions println() doivent être placées entre les accolades de la fonction principale. Vous avez maintenant deux instructions dans le corps de la fonction.
fun main() {
    println("Hello, Android!")
    println("Hello, Android!")
}
  1. Exécutez le programme.
  2. Lorsque vous exécutez votre programme, vous devez obtenir la sortie suivante :
Hello, Android!
Hello, Android!

Vous pouvez voir comment les modifications apportées au code affectent le résultat.

  1. Modifiez le code de sorte qu'il affiche Hello, YOUR_NAME!.

7. Guide de style Kotlin

Tout au long de ce cours, vous découvrirez les bonnes pratiques de codage à suivre en tant que développeur Android. L'une de ces bonnes pratiques consiste à suivre les normes de codage Android de Google pour le codage en Kotlin. Le guide complet, appelé "guide de style", explique comment mettre en forme le code en termes d'aspect visuel et les conventions à suivre lors de sa rédaction. Par exemple, le guide de style inclut des recommandations sur l'utilisation des espaces, des retraits, des noms, etc.

L'objectif du guide de style est de rendre votre code plus facile à lire et de l'harmoniser avec le code écrit par d'autres développeurs. Cette cohérence est importante lors d'une collaboration sur des projets volumineux, c'est pourquoi le style de code s'applique à tous les fichiers du projet.

Voici quelques recommandations du guide de style utiles pour ce que vous avez appris en Kotlin jusqu'à présent :

  • Les noms de fonctions doivent être en camel case et être des verbes ou des expressions verbales.
  • Chaque instruction doit figurer sur une ligne distincte.
  • L'accolade ouvrante doit apparaître à la fin de la ligne où la fonction commence.
  • Il doit y avoir une espace avant l'accolade ouvrante.

Le code de la fonction principale suivant est illustré dans l'image : fun main() {     println("Hello, world!") } Une étiquette appelée "space" (espace) pointe vers l'espace entre la parenthèse fermante et l'accolade ouvrante.

  • Le corps de la fonction doit être en retrait de 4 espaces. N'utilisez pas de tabulation pour mettre votre code en retrait. Saisissez quatre espaces.

Le code de la fonction principale suivant est illustré dans l'image : fun main() {     println("Hello, world!") } Une flèche pointe vers la ligne de code dans le corps de la fonction : println("Hello, world!"). La flèche indique "indent by 4 spaces" (retrait de 4 espaces).

  • L'accolade fermante se trouve sur sa propre ligne après la dernière ligne de code dans le corps de la fonction. L'accolade doit être alignée sur le mot clé fun au début de la fonction.

Le code de la fonction principale suivant est illustré dans l'image : fun main() {     println("Hello, world!") } Une ligne verticale apparaît sur le bord gauche du code de la fonction. Elle s'étend du mot "fun" jusqu'en dessous de l'accolade fermante de la fonction. La ligne verticale comporte l'inscription "aligné verticalement". Cette ligne sert à indiquer que le mot "fun" et l'accolade fermante doivent être alignés verticalement.

Vous découvrirez d'autres conventions de codage Android à mesure que vous développerez vos connaissances en Kotlin. Le guide de style complet est disponible sur cette page, mais ne vous inquiétez pas, il aborde d'autres sujets dans Kotlin que vous n'avez pas encore croisés.

8. Corriger les erreurs dans votre code

Lorsque vous apprenez une langue, vous devez respecter certaines règles de syntaxe et de grammaire pour utiliser correctement les mots et les phrases. Il en est de même pour les langages de programmation. Il existe des règles spécifiques qui définissent le code valide, c'est-à-dire le code qui se compile correctement.

Faire des erreurs et saisir par inadvertance du code incorrect font partie intégrante du processus de codage. En tant que débutant, cela peut être quelque peu déroutant et fatigant. Mais ne vous inquiétez pas, c'est parfaitement normal. Le code fonctionne rarement parfaitement dès la première saisie. Tout comme l'écriture d'un document nécessite de nombreux brouillons, l'écriture du code peut prendre de nombreuses itérations jusqu'à ce qu'elle fonctionne comme prévu.

Si la compilation du code échoue, cela signifie qu'une erreur s'est produite. Par exemple, si vous avez fait une faute de frappe, vous avez par exemple oublié un guillemet ou une parenthèse, le compilateur ne comprendra pas votre code et ne pourra pas le traduire en étapes pour que l'ordinateur fonctionne correctement. Si votre code ne fonctionne pas comme prévu ou qu'un message d'erreur s'affiche dans votre éditeur de code, vous devez revenir au code et le corriger. Le processus de résolution de ces erreurs s'appelle le dépannage.

  1. Copiez et collez l'extrait de code suivant dans Kotlin Playground, puis exécutez le programme. Que voyez-vous ?
fun main() {
    println("Today is sunny!)
}

Dans l'idéal, le message Today is sunny! doit s'afficher. À la place, des icônes en forme de point d'exclamation avec des messages d'erreur s'affichent dans le volet de sortie.

L'exécution du programme génère deux messages d'erreur : "Expecting "" et "Expecting )". Un point d'exclamation dans un cercle rouge se situe à gauche de chaque erreur.

Message d'erreur de Kotlin Playground

Les messages d'erreur commencent par le mot "Expecting" (Attente), car le compilateur Kotlin "attend" quelque chose, mais ne le trouve pas dans le code. Dans ce cas, le compilateur attend un guillemet fermant et une parenthèse fermante pour le code dans la deuxième ligne de votre programme.

Dans l'instruction println(), notez que le message à afficher comporte des guillemets ouvrants, mais pas de guillemets fermants. Bien qu'il y ait une parenthèse fermante dans le code, le compilateur pense que la parenthèse fait partie du texte à imprimer, car aucun guillemet fermant n'est placé avant.

  1. Ajoutez le guillemet fermant entre le point d'exclamation et la parenthèse fermante.
fun main() {
    println("Today is sunny!")
}

La fonction principale contient une ligne de code, qui est une instruction println(), dans laquelle le texte est placé entre guillemets et parenthèses : ​​"Today is sunny!".

  1. Exécutez de nouveau le programme.

Aucune erreur ne devrait apparaître et le volet de sortie devrait afficher le texte suivant :

Today is sunny!

Bravo, vous avez corrigé l'erreur ! Une fois que vous aurez acquis plus d'expérience dans la rédaction du code et la résolution des erreurs, vous constaterez qu'il est important de prêter attention aux majuscules, à l'orthographe, aux espaces, aux symboles et aux noms lorsque vous saisissez du code.

Dans la section suivante, vous allez mettre en pratique ce que vous avez appris. Les solutions sont disponibles à la fin de l'atelier de programmation, mais faites de votre mieux pour trouver la réponse par vous-même.

9. Exercices

  1. Pouvez-vous lire le code de ce programme et deviner la sortie (sans l'exécuter dans Kotlin Playground) ?
fun main() {
    println("1")
    println("2")
    println("3")
}

Une fois que vous avez une réponse, copiez et collez ce code dans Kotlin Playground pour vérifier votre réponse.

  1. Utilisez Kotlin Playground pour créer un programme qui génère les messages suivants :
I'm
learning
Kotlin!
  1. Copiez et collez ce programme dans Kotlin Playground.
fun main() {
    println("Tuesday")
    println("Thursday")
    println("Wednesday")
    println("Friday")
    println("Monday")
}

Corrigez le programme pour qu'il affiche la sortie suivante :

Monday
Tuesday
Wednesday
Thursday
Friday

Pour vous améliorer en matière de dépannage, corrigez les erreurs dans les exercices suivants. Pour chaque exercice, copiez le code dans Kotlin Playground depuis votre navigateur. Essayez d'exécuter le programme. Un message d'erreur s'affiche.

  1. Corrigez l'erreur dans ce programme, de sorte qu'il affiche la sortie souhaitée.
fun main() {
    println("Tomorrow is rainy")

Sortie souhaitée :

Tomorrow is rainy
  1. Corrigez l'erreur dans ce programme, de sorte qu'il affiche la sortie souhaitée.
fun main() {
    printLine("There is a chance of snow")
}

Sortie souhaitée :

There is a chance of snow
  1. Corrigez l'erreur dans ce programme, de sorte qu'il affiche la sortie souhaitée.
fun main() {
    println("Cloudy") println("Partly Cloudy") println("Windy")
}

Sortie souhaitée :

Cloudy
Partly Cloudy
Windy
  1. Corrigez l'erreur dans ce programme, de sorte qu'il affiche la sortie souhaitée.
fun main() (
    println("How's the weather today?")
)

Sortie souhaitée :

How's the weather today?

Après avoir effectué ces exercices, comparez vos réponses aux solutions proposées dans la section suivante.

10. Solutions

  1. La sortie du programme est :
1
2
3
  1. Le code de votre programme devrait ressembler à ceci :
fun main() {
    println("I'm")
    println("learning")
    println("Kotlin!")
}
  1. Voici le code attendu pour le programme :
fun main() {
    println("Monday")
    println("Tuesday")
    println("Wednesday")
    println("Thursday")
    println("Friday")
}
  1. L'accolade fermante indiquant la fin du corps de la fonction main est manquante dans la troisième ligne du programme.

Code correct :

fun main() {
    println("Tomorrow is rainy")
}

Sortie :

Tomorrow is rainy
  1. Lorsque vous exécutez le programme, une erreur Unresolved reference: printLine s'affiche. En effet, printLine() n'est pas une fonction reconnue en Kotlin. La partie du code à l'origine de l'erreur est surlignée en rouge dans Kotlin Playground. Remplacez le nom de la fonction par println pour afficher une ligne de texte dans la sortie, ce qui résout l'erreur.

Code correct :

fun main() {
    println("There is a chance of snow")
}

Sortie :

There is a chance of snow
  1. Lorsque vous exécutez le programme, une erreur Unresolved reference: println s'affiche. Ce message n'indique pas directement comment résoudre le problème. Cela peut se produire lorsque vous repérez une erreur. Vous devez examiner votre code plus en détail pour résoudre le comportement inattendu.

En observant de plus près, le deuxième appel de la fonction println() dans le code apparaît en rouge, ce qui indique l'origine du problème. Kotlin ne veut qu'une seule instruction par ligne. Dans ce cas, vous pouvez déplacer les deuxième et troisième appels de la fonction println() sur des lignes distinctes pour résoudre le problème.

Code correct :

fun main() {
    println("Cloudy")
    println("Partly Cloudy")
    println("Windy")
}

Sortie :

Cloudy
Partly Cloudy
Windy
  1. Si vous exécutez le programme, l'erreur Function 'main' must have a body s'affiche. Le corps de la fonction doit être placé entre accolades { }, et non entre parenthèses ().

Code correct :

fun main() {
    println("How's the weather today?")
}

Sortie :

How's the weather today?

11. Conclusion

Bravo ! Vous avez terminé cette introduction à Kotlin.

Vous avez travaillé avec des programmes simples en Kotlin et vous les avez exécutés pour afficher leur sortie. Vous avez modifié les programmes de différentes manières et observé l'impact de ces modifications sur la sortie. Il est normal de faire des erreurs lors de la programmation. C'est pourquoi vous avez commencé à apprendre à repérer et à corriger les erreurs dans votre code, une compétence importante qui vous sera utile à l'avenir.

Passez à l'atelier de programmation suivant pour apprendre à utiliser des variables en Kotlin afin de créer des programmes plus intéressants.

Résumé

  • Un programme Kotlin nécessite une fonction principale comme point d'entrée du programme.
  • Pour définir une fonction en langage Kotlin, utilisez le mot clé fun, suivi du nom de la fonction, puis des entrées comprises entre parenthèses, et enfin du corps de la fonction, entre accolades.
  • Le nom d'une fonction doit respecter la convention camel case, et commencer par une lettre minuscule.
  • Utilisez l'appel de fonction println() pour que la sortie affiche du texte.
  • Reportez-vous au guide de style Kotlin pour connaître les conventions de mise en forme et de programmation à suivre lors du codage en langage Kotlin.
  • Le dépannage consiste à corriger les erreurs dans votre code.

En savoir plus