Kotlin Bootcamp for Programmers 2: Principes de base de Kotlin

Cet atelier de programmation fait partie du cours Kotlin Bootcamp for Programmers (Formation Kotlin pour les programmeurs). Vous tirerez le meilleur parti de ce cours si vous suivez les ateliers de programmation dans l'ordre. En fonction de vos connaissances, vous pouvez parcourir certaines sections. Ce cours s'adresse aux programmeurs qui connaissent un langage orienté objet et souhaitent apprendre l'Kotlin.

Introduction

Dans cet atelier de programmation, vous allez découvrir les principes de base du langage de programmation Kotlin: types de données, opérateurs, variables, structures de contrôle et variables nulles ou non. Ce cours s'adresse aux programmeurs qui connaissent un langage orienté objet et souhaitent apprendre à utiliser Kotlin.

Plutôt que de créer un exemple d'application, les leçons de ce cours sont conçues pour développer vos connaissances, mais elles ne doivent pas être indépendantes les unes des autres pour vous permettre de parcourir les sections que vous connaissez déjà. Pour les assembler, de nombreux exemples utilisent un thème d'aquarium. Et si vous voulez voir l'histoire complète de l'aquarium, consultez le cours Udacity Kotlin Bootcamp for Programmers.

Ce que vous devez déjà savoir

• Créer un projet dans IntelliJ IDEA
• Comment ouvrir et exécuter du code dans le REPL (Read-Eval-Print Loop) en Kotlin IDEA (Tools > Kotlin > Kotlin REPL)

Points abordés

• Utiliser les types de données, les opérateurs et les variables Kotlin
• Utiliser les valeurs booléennes et les conditions
• Différence entre les variables pouvant être nulles et non variables
• Fonctionnement des tableaux, des listes et des boucles en Kotlin

Objectifs de l'atelier

• Apprendre à utiliser le langage REPL de Kotlin pour apprendre les bases

Dans cette tâche, vous découvrirez les opérateurs et les types dans le langage de programmation Kotlin.

Étape 1: Explorez les opérateurs numériques

1. Ouvrez IntelliJ IDEA, si ce n'est pas déjà fait.
2. Pour ouvrir le REPL Kotlin, sélectionnez Tools (Outils) &gt, Kotlin &gt, et Kotlin REPL (REPL Kotlin).
   

Comme pour les autres langages, Kotlin utilise +, -, * et / pour les signes plus, moins, horaires et divisions. Kotlin accepte également différents types de nombres, tels que Int, Long, Double et Float.

3. Saisissez les expressions suivantes dans le REPL. Pour afficher le résultat, appuyez sur Control+Enter (Command+Enter sur un Mac) après chacun d'eux.

Remarque : Dans cet atelier de programmation, Marche/Arrêt permet d'indiquer la sortie de votre code. Dans la dernière version du REPL, le résultat inclut le numéro et le type du résultat.

1+1
⇒ res8: kotlin.Int = 2

53-3
⇒ res9: kotlin.Int = 50

50/10
⇒ res10: kotlin.Int = 5

1.0/2.0
⇒ res11: kotlin.Double = 0.5

2.0*3.5
⇒ res12: kotlin.Double = 7.0

Notez que les résultats des opérations conservent les types d'opérandes. Ainsi, 1/2 = 0, mais 1.0/2.0 = 0.5.

4. Essayez des expressions comportant différentes combinaisons de nombres entiers et décimaux.

6*50
⇒ res13: kotlin.Int = 300

6.0*50.0
⇒ res14: kotlin.Double = 300.0

6.0*50
⇒ res15: kotlin.Double = 300.0

5. Appelez des méthodes sur les nombres. Kotlin conserve les nombres en tant que rôles primitifs, mais vous permet d'appeler des méthodes sur des nombres comme des objets.

2.times(3)
⇒ res5: kotlin.Int = 6

3.5.plus(4)
⇒ res8: kotlin.Double = 7.5

2.4.div(2)
⇒ res9: kotlin.Double = 1.2

Remarque: Il est possible de créer des wrappers d'objets réels autour des nombres, appelés boxes. La boxe s'effectue automatiquement, comme pour les collections où des numéros sont déballés et prêts à l'emploi selon les besoins.

Avertissement:L'utilisation de wrappers d'objet nécessite plus de mémoire que le stockage d'un nombre primitif. N'utilisez pas la boxe, à moins que cela ne soit nécessaire, par exemple pour une collection qui sera traitée ultérieurement.

Étape 2: S'entraîner à utiliser des types

Kotlin ne convertit pas implicitement entre les types de nombres. Vous ne pouvez donc pas attribuer une valeur courte directement à une variable longue ni une valeur Byte à un élément Int. La conversion implicite des nombres est souvent à l'origine des erreurs des programmes. Vous pouvez toujours attribuer des valeurs de différents types en castant.

1. Pour afficher certains des casts possibles, définissez une variable de type Int dans le REPL.

val i: Int = 6

2. Créez une variable, puis saisissez son nom (voir ci-dessus) suivi de .to.

val b1 = i.to

IntelliJ IDEA affiche une liste des réalisations possibles. Cette saisie semi-automatique fonctionne pour les variables et les objets de tout type.

3. Sélectionnez toByte() dans la liste, puis imprimez la variable.

val b1 = i.toByte()
println(b1)

⇒ 6

4. Attribuez une valeur Byte à des variables de différents types.

val b2: Byte = 1 // OK, literals are checked statically
println(b2)
⇒ 1

val i1: Int = b2
⇒ error: type mismatch: inferred type is Byte but Int was expected

val i2: String = b2
⇒ error: type mismatch: inferred type is Byte but String was expected

val i3: Double = b2
⇒ error: type mismatch: inferred type is Byte but Double was expected

5. Essayez de les caster pour les devoirs qui ont renvoyé des erreurs.

val i4: Int = b2.toInt() // OK!
println(i4)
⇒ 1

val i5: String = b2.toString()
println(i5)
⇒ 1

val i6: Double = b2.toDouble()
println(i6)
⇒ 1.0

6. Afin de rendre les longues constantes numériques plus lisibles, Kotlin vous permet de placer des traits de soulignement dans les nombres, là où cela est pertinent. Essayez de saisir d'autres constantes numériques.

val oneMillion = 1_000_000
val socialSecurityNumber = 999_99_9999L
val hexBytes = 0xFF_EC_DE_5E
val bytes = 0b11010010_01101001_10010100_10010010

Remarque:Comme le type de code de Kotlin est fort, le compilateur peut généralement déduire le type des variables. Vous n'avez donc pas besoin de le déclarer explicitement.

Étape 3: Découvrir la valeur des types de variables

Kotlin prend en charge deux types de variables: modifiable et non modifiable. Avec val, vous pouvez attribuer une valeur une seule fois. Si vous tentez de renouveler l'attribution, un message d'erreur s'affichera. Avec var, vous pouvez attribuer une valeur, puis la modifier plus tard dans le programme.

1. Définissez des variables à l'aide de val et var, puis attribuez-leur de nouvelles valeurs.

var fish = 1
fish = 2
val aquarium = 1
aquarium = 2

⇒ error: val cannot be reassigned

Vous pouvez attribuer une valeur à fish, puis lui attribuer une nouvelle valeur, car elle est définie avec var. Si vous essayez d'attribuer une nouvelle valeur à aquarium, une erreur s'affiche, car la valeur est définie avec val.

Le type que vous stockez dans une variable est déduit lorsque le compilateur peut le déduire du contexte. Si vous le souhaitez, vous pouvez toujours spécifier explicitement le type d'une variable à l'aide du format deux-points.

2. Définissez certaines variables et indiquez le type explicitement.

var fish: Int = 12
var lakes: Double = 2.5

Une fois qu'un type a été attribué par vous ou le compilateur, vous ne pouvez pas le modifier ou un message d'erreur s'affiche.

Étape 4: Apprenez à connaître les chaînes

En mode Kotlin, les chaînes fonctionnent de la même manière que les chaînes de tout autre langage de programmation utilisant " pour les chaînes et ' pour les caractères uniques, et vous pouvez concaténer des chaînes avec l'opérateur +. Vous pouvez créer des modèles de chaîne en les combinant avec des valeurs. Le nom $variable est remplacé par le texte représentant la valeur. C'est ce qu'on appelle l'interpolation variable.

1. Créez un modèle de chaîne.

val numberOfFish = 5
val numberOfPlants = 12
"I have $numberOfFish fish" + " and $numberOfPlants plants"

⇒ res20: kotlin.String = I have 5 fish and 12 plants

2. Créez un modèle de chaîne contenant une expression. Comme dans d'autres langues, la valeur peut être le résultat d'une expression. Utilisez des accolades {} pour définir l'expression.

"I have ${numberOfFish + numberOfPlants} fish and plants"

⇒ res21: kotlin.String = I have 17 fish and plants

Dans cette tâche, vous allez découvrir les valeurs booléennes et les conditions de vérification dans le langage de programmation Kotlin. Comme d'autres langages, Kotlin utilise des valeurs booléennes et des opérateurs booléens tels que "inférieur à", "égal à", etc. (<, ==, >, !=, <=, >=).

1. Rédigez une instruction if/else.

val numberOfFish = 50
val numberOfPlants = 23
if (numberOfFish > numberOfPlants) {
    println("Good ratio!") 
} else {
    println("Unhealthy ratio")
}

⇒ Good ratio!

2. Essayez une plage dans une instruction if. En langage Kotlin, la condition que vous testez peut également utiliser des plages.

val fish = 50
if (fish in 1..100) {
    println(fish)
}

⇒ 50

3. Rédigez un if comportant plusieurs cas. Pour des conditions plus compliquées, utilisez des opérateurs logiques && et || ou logiques. Comme dans d'autres langues, vous pouvez utiliser plusieurs tickets à l'aide de else if.

if (numberOfFish == 0) {
    println("Empty tank")
} else if (numberOfFish < 40) {
    println("Got fish!")
} else {
    println("That's a lot of fish!")
}

⇒ That's a lot of fish!

4. Essayez une instruction when. Il existe une méthode plus pratique pour écrire cette série d'instructions if/else if/else en langage Kotlin à l'aide de l'instruction when, qui est semblable à l'instruction switch dans d'autres langages. Les conditions d'une instruction when peuvent également utiliser des plages.

when (numberOfFish) {
    0  -> println("Empty tank")
    in 1..39 -> println("Got fish!")
    else -> println("That's a lot of fish!")
}

⇒ That's a lot of fish!

Dans cette tâche, vous allez découvrir les variables pouvant être nulles et non nulles. Des erreurs de programmation impliquant des valeurs nulles ont entraîné de nombreux bugs. Kotlin essaie de réduire les bugs en introduisant des variables non nulles.

Étape 1: En savoir plus sur la possibilité de valeur nulle

Par défaut, les variables ne peuvent pas être null.

1. Déclarez une variable Int et attribuez-lui null.

var rocks: Int = null

⇒ error: null can not be a value of a non-null type Int

2. Utilisez l'opérateur"Point d'interrogation"?, après le type, pour indiquer qu'une variable peut être nulle. Déclarez une variable Int? et attribuez-lui null.

var marbles: Int? = null

Lorsque vous avez des types de données complexes, comme une liste:

• Vous pouvez autoriser la suppression des éléments de la liste.
• Vous pouvez autoriser la liste à être nulle, mais si elle n'est pas nulle, ses éléments ne peuvent pas être nuls.
• Vous pouvez autoriser la suppression de la liste ou des éléments.

Les listes et d'autres types de données complexes sont abordés ultérieurement.

Étape 2: Découvrez le et "?"

Vous pouvez tester null avec l'opérateur ?, ce qui vous évite d'écrire de nombreuses instructions if/else.

1. Écrivez un code plus long pour vérifier si la variable fishFoodTreats n'est pas null. Déduisez ensuite cette variable.

var fishFoodTreats = 6
if (fishFoodTreats != null) {
    fishFoodTreats = fishFoodTreats.dec()
}

2. Voyons maintenant la façon de rédiger Kotlin à l'aide de l'opérateur ?.

var fishFoodTreats = 6
fishFoodTreats = fishFoodTreats?.dec()

3. Vous pouvez également associer des tests de valeur nulle à l'aide de l'opérateur ?:. Prenons cet exemple:

fishFoodTreats = fishFoodTreats?.dec() ?: 0

Il s'agit d'un raccourci entre fishFoodTreats si ce n'est pas null, diminuer et utiliser. Sinon, utilisez la valeur après ?:, qui est 0. Si fishFoodTreats est défini sur null, l'évaluation est arrêtée et la méthode dec() n'est pas appelée.

Remarque : L'opérateur ?: est parfois appelé opérateur "Elvis", car il sourit sur le côté, avec une coiffure à la sanguine, alors qu'Elvis Presley coiffait. Pour en savoir plus sur l'opérateur Elvis, consultez la documentation Kotlin.

Point sur les pointeurs de valeur nulle

Si vous adorez NullPointerExceptions, Kotlin vous permet de les conserver. L'opérateur d'assertion non nul, !! (double bang), convertit une valeur en un type non nul et génère une exception si la valeur est null.

val len = s!!.length   // throws NullPointerException if s is null

Remarque: Dans l'argot de programmation, le point d'exclamation est souvent désigné par le terme ""bang; Cela signifie que l'opérateur d'assertion "non nul" est parfois désigné par le terme "bang"

Remarque : En règle générale, il est déconseillé d'utiliser l'opérateur de double frappe. C'est pourquoi les créateurs de langue vous font saisir deux points d'exclamation au lieu d'un. Toutefois, dans certains cas, l'ancien code Java est indispensable.

Dans cette tâche, vous découvrirez des tableaux et des listes, et vous apprendrez à créer des boucles dans le langage de programmation Kotlin.

Étape 1: Créez des listes

Les listes sont un type essentiel en langage Kotlin et sont semblables aux listes dans d'autres langages.

1. Déclarez une liste à l'aide de listOf et imprimez-la. Impossible de modifier cette liste.

val school = listOf("mackerel", "trout", "halibut")
println(school)

⇒ [mackerel, trout, halibut]

2. Déclarez une liste pouvant être modifiée à l'aide de la fonction mutableListOf. Supprimer un élément

val myList = mutableListOf("tuna", "salmon", "shark")
myList.remove("shark")

⇒ res36: kotlin.Boolean = true

La méthode remove() renvoie true lorsqu'elle supprime l'élément réussi.

Remarque : Si vous définissez une liste définie avec val, vous ne pouvez pas modifier la liste à laquelle la variable fait référence, mais vous pouvez modifier le contenu de la liste.

Étape 2: Créez des tableaux

Tout comme les autres langages, Kotlin utilise des tableaux. Contrairement aux listes en langage Kotlin, qui comportent des versions modifiables et immuables, il n'existe pas de version modifiable d'un élément Array. La taille d'un tableau est fixe. Vous ne pouvez pas ajouter ni supprimer d'éléments, sauf en les copiant dans un nouveau tableau.

Les règles utilisant val et var sont les mêmes pour les tableaux et pour les listes.

Remarque:Si vous définissez un tableau avec val, vous ne pouvez pas modifier le tableau auquel la variable fait référence, mais vous pouvez modifier le contenu du tableau.

1. Déclarez un tableau de chaînes à l'aide de arrayOf. Utilisez l'utilitaire java.util.Arrays.toString() pour imprimer le tableau.

val school = arrayOf("shark", "salmon", "minnow")
println(java.util.Arrays.toString(school))

⇒ [shark, salmon, minnow]

2. Un tableau déclaré avec arrayOf n'a pas de type associé aux éléments. Vous pouvez donc combiner des types, ce qui est utile. Déclarez un tableau avec différents types.

val mix = arrayOf("fish", 2)

3. Vous pouvez également déclarer des tableaux avec un seul type pour tous les éléments. Déclarez un tableau d'entiers à l'aide de intArrayOf(). Il existe des compilateurs ou fonctions d'instanciation correspondants pour les tableaux d'autres types.

val numbers = intArrayOf(1,2,3)

Remarque:L'utilisation d'un tableau de type primitif comme Int ou Byte permet d'éviter la surcharge en boxe.

4. Combiner deux tableaux avec l'opérateur +

val numbers = intArrayOf(1,2,3)
val numbers3 = intArrayOf(4,5,6)
val foo2 = numbers3 + numbers
println(foo2[5])

=> 3

5. Essayez différentes combinaisons de tableaux et de listes imbriqués. Comme dans les autres langues, vous pouvez imbriquer des tableaux et des listes. Autrement dit, lorsque vous placez un tableau dans un tableau, vous possédez un tableau de tableaux, et non un tableau aplati du contenu des deux. Les éléments d'un tableau peuvent également être des listes, et les éléments de listes peuvent être des tableaux.

val numbers = intArrayOf(1, 2, 3)
val oceans = listOf("Atlantic", "Pacific")
val oddList = listOf(numbers, oceans, "salmon")
println(oddList)

⇒ [[I@89178b4, [Atlantic, Pacific], salmon]

Le premier élément, numbers, est un Array. Lorsque vous ne l'utilisez pas pour imprimer le tableau, Kotlin affiche l'adresse au lieu du contenu du tableau.

6. L'une des caractéristiques intéressantes de Kotlin est que vous pouvez initialiser des tableaux avec du code au lieu de les initialiser sur 0. Essayez cet exemple:

val array = Array (5) { it * 2 }
println(java.util.Arrays.toString(array))

⇒ [0, 2, 4, 6, 8]

Le code d'initialisation se trouve entre les accolades, {}. Dans le code, it fait référence à l'index de tableau, en commençant par 0.

Étape 3: Créez des boucles

Une fois que vous disposez de listes et de tableaux, vous pouvez vous attendre à ce que les éléments apparaissent en boucle.

1. Créez un tableau. Utilisez une boucle for pour parcourir le tableau et imprimer les éléments.

val school = arrayOf("shark", "salmon", "minnow")
for (element in school) {
    print(element + " ")
}

⇒ shark salmon minnow

2. En langage Kotlin, vous pouvez lire en boucle les éléments et les index en même temps. Essayez cet exemple:

for ((index, element) in school.withIndex()) {
    println("Item at $index is $element\n")
}

⇒ Item at 0 is shark
Item at 1 is salmon
Item at 2 is minnow

3. Essayez différentes tailles et plages d'étapes. Vous pouvez spécifier des plages de nombres ou de caractères par ordre alphabétique. Dans une autre langue, il n'est pas nécessaire d'avancer de 1. Vous pouvez revenir en arrière en utilisant downTo.

for (i in 1..5) print(i)
⇒ 12345

for (i in 5 downTo 1) print(i)
⇒ 54321

for (i in 3..6 step 2) print(i)
⇒ 35

for (i in 'd'..'g') print (i)
⇒ defg

4. Essayez quelques boucles. Comme d'autres langages, Kotlin utilise while boucles, do...while boucles, et les opérateurs ++ et --. Kotlin possède également repeat boucles.

var bubbles = 0
while (bubbles < 50) {
    bubbles++
}
println("$bubbles bubbles in the water\n")

do {
    bubbles--
} while (bubbles > 50)
println("$bubbles bubbles in the water\n")

repeat(2) {
     println("A fish is swimming")
}

⇒ 50 bubbles in the water
49 bubbles in the water
A fish is swimmingA fish is swimming

Kotlin est très semblable aux autres langages de programmation, mais il présente quelques différences importantes, comme les opérateurs, les listes et les boucles.

Les fonctionnalités suivantes peuvent être différentes de celles en langage Kotlin.

• Les types Kotlin ne peuvent pas être convertis implicitement. Utilisez la diffusion.
• Les variables déclarées avec val ne peuvent être attribuées qu'une seule fois.
• Par défaut, les variables Kotlin ne peuvent pas avoir la valeur null. Utilisez ? pour rendre les variables pouvant être nulles.
• En langage Kotlin, vous pouvez lire en boucle l'index et les éléments d'un tableau en même temps dans une boucle for.

Les structures de programmation Kotlin suivantes sont semblables à celles d'autres langages:

• Les tableaux et les listes peuvent comporter un seul type ou des types mixtes.
• Les tableaux et les listes peuvent être imbriqués.
• Vous pouvez créer des boucles avec for, while, do/while et repeat.
• L'instruction when correspond à la version Kotlin' de l'instruction switch, mais when est plus flexible.

Documentation Kotlin

Si vous souhaitez en savoir plus sur un sujet de ce cours ou si vous rencontrez des difficultés, https://kotlinlang.org constitue le meilleur point de départ.

• Conventions de codage Kotlin
• Idiomes Kotlin

• Conversion de type explicite
• Définir des variables
• Modèles de chaîne
• Valeurs nulles
• Listes
• Tableaux
• if, when, for et while
• Opérateur ?: (Elvis)
• Opérateur !!

Tutoriels Kotlin

Le site Web https://try.kotlinlang.org propose des tutoriels enrichis appelés Kotlin Koans, un interpréteur Web ainsi qu'une documentation de référence complète avec des exemples.

Cours Udacity

Pour afficher le cours Udacity sur ce sujet, consultez Kotlin Bootcamp for Programmers (Formation Kotlin pour les programmeurs).

IntelliJ IDEA

Consultez la documentation sur IntelliJ IDEA sur le site Web de JetBrains.

Cette section répertorie les devoirs possibles pour les élèves qui effectuent cet atelier de programmation dans le cadre d'un cours animé par un enseignant. C'est à l'enseignant de procéder comme suit:

• Si nécessaire, rendez-les.
• Communiquez aux élèves comment rendre leurs devoirs.
• Notez les devoirs.

Les enseignants peuvent utiliser ces suggestions autant qu'ils le souhaitent, et ils n'ont pas besoin d'attribuer les devoirs de leur choix.

Si vous suivez vous-même cet atelier de programmation, n'hésitez pas à utiliser ces devoirs pour tester vos connaissances.

Répondez à ces questions.

Question 1

Laquelle de ces propositions déclare une liste non modifiable ?

▢ val school = arrayOf("shark", "salmon", "minnow")

▢ var school = arrayOf("shark", "salmon", "minnow")

▢ val school = listOf("shark", "salmon", "minnow")

▢ val school = mutableListOf("shark", "salmon", "minnow")

Question 2

Quelle sera la sortie du code suivant ?
for (i in 3..8 step 2) print(i)

▢ 345678

▢ 468

▢ 38

▢ 357

Question 3

À quoi sert le point d'interrogation dans ce code ?
var rocks: Int? = 3

▢ Le type de la variable rocks n'est pas fixe.

▢ La variable rocks peut être définie sur une valeur null.

▢ La valeur rocks ne peut pas être nulle.

▢ La variable rocks ne doit pas être initialisée immédiatement.

Passez à la leçon suivante : 3. Fonctions

Pour une présentation du cours, y compris des liens vers d'autres ateliers de programmation, consultez le "Kotlin Bootcamp for Programmers: Welcome to the course."