1. Avant de commencer
Dans les applications de votre téléphone, vous remarquerez que certaines parties de l'appli restent les mêmes, tandis que d'autres changent (ou sont variables).
Par exemple, les noms des catégories dans l'application Paramètres restent les mêmes : "Réseau et Internet", "Appareils connectés", "Applications", etc.
En revanche, les articles changent souvent dans une application d'actualités. Le nom, la source, l'heure de publication et les images des articles changent.
Comment rédiger votre code pour que le contenu évolue au fil du temps ? Vous ne pouvez pas réécrire le code dans votre application chaque fois que de nouveaux articles sont publiés, chaque jour, chaque heure et chaque minute.
Dans cet atelier de programmation, vous allez apprendre à écrire du code qui utilise des variables afin que certaines parties de votre programme puissent être modifiées sans nécessiter un nouvel ensemble d'instructions. Vous utiliserez Kotlin Playground comme dans l'atelier précédent.
Objectifs de l'atelier
- Programmes courts en Kotlin qui utilisent des variables.
Points abordés
- Comment définir une variable et mettre à jour sa valeur
- Comment sélectionner un type de données approprié pour une variable parmi les types de données de base en Kotlin
- Comment ajouter des commentaires à votre code.
Ce dont vous aurez besoin
- Un ordinateur avec accès à Internet et un navigateur Web.
2. Variables et types de données
En programmation informatique, une variable est un conteneur qui ne contient qu'une seule donnée. Vous pouvez vous la représenter comme une boîte qui contiendrait une seule valeur. La boîte comporte un libellé qui correspond au nom de la variable. En faisant référence à la boîte en l'appelant par son nom, vous avez accès à la valeur qu'elle contient.
Pourquoi stocker la valeur dans une boîte et faire référence à la boîte avec son nom, au lieu de l'utiliser directement ? Un problème se pose : lorsque votre code utilise des valeurs directement dans toutes les instructions, votre programme ne fonctionne que pour ce cas spécifique.
Voici une analogie qui peut vous aider à comprendre plus facilement l'utilité des variables. Une personne que vous avez rencontrée récemment vous a envoyé la lettre ci-dessous.
Chère Lauren,
Ce fut un plaisir de vous voir aujourd'hui au bureau. J'ai hâte de vous voir vendredi.
Bonne journée !
Cette lettre est intéressante, mais elle ne peut s'appliquer que dans votre situation spécifique avec Lauren. Pourquoi ne pas écrire la même lettre plusieurs fois, avec de légères variations selon les personnes ? Il serait plus efficace de créer un modèle de lettre unique, en laissant les champs vides pour les parties susceptibles d'être modifiées.
Bonjour ____ ,
Ce fut un plaisir de vous voir aujourd'hui _________. J'ai hâte de vous voir ___________ .
Bonne journée !
Vous pouvez également spécifier le type d'informations qui figurent dans chaque espace. Ainsi, le modèle de lettre pourra s'adapter à chaque cas spécifique.
Bonjour { name } ,
Ce fut un plaisir de vous rencontrer aujourd'hui { location } (lieu). J'ai hâte de vous voir { date }.
Bonne journée !
Lors de la création d'une application, vous appliquez un concept similaire. Vous disposez d'espaces réservés pour certaines données, tandis que d'autres parties de l'application restent identiques.
Dans l'illustration ci-dessus, le texte "Welcome" (Bienvenue), le titre "Last News for You" (Dernières actualités pour vous) et le bouton "View more articles" (Afficher plus d'articles) dans une application News restent inchangés. À l'inverse, le nom d'utilisateur et le contenu de chaque article seront modifiés. C'est une excellente occasion d'utiliser des variables pour stocker chaque information.
Vous ne voudriez pas écrire un code (ou des instructions) dans votre application News qui ne fonctionnerait que pour un utilisateur nommé Alex, ou pour un article d'actualités qui aurait toujours le même titre et la même date de publication. Votre application doit être flexible : vous devez donc écrire votre code en faisant référence à des noms de variables tels que name
, article1Name
, article1Date
, etc. Votre code englobe alors tous les cas d'utilisation, et adaptera le nom de l'utilisateur et les informations sur l'article selon les cas rencontrés.
Exemple d'application contenant des variables
Voyons un exemple d'application qui peut utiliser des variables.
Dans une application de type Maps, une fenêtre d'informations affiche des informations sur chaque établissement (p. ex. un restaurant ou une entreprise). La capture d'écran ci-dessus de l'application Google Maps affiche des informations sur le siège de l'entreprise de Google, le Googleplex. Selon vous, quelles données sont stockées en tant que variables dans l'application ?
- Nom du lieu
- Note du lieu
- Nombre d'avis sur le lieu
- Indique si l'utilisateur a enregistré ou ajouté ce lieu à ses favoris
- Adresse du lieu
- Description du lieu
Modifiez les données stockées dans ces variables. Votre application Google Maps est suffisamment flexible pour afficher des informations sur d'autres lieux.
Types de données
Lorsque vous choisissez où placer des variables dans votre application, vous devez spécifier le type de données pouvant être stockées dans ces variables. En langage Kotlin, certains types de données de base sont fréquemment utilisés. Le tableau ci-dessous, chaque ligne vous présente un type de données différent. Chaque type de données est associé à une description du type de données qu'il peut contenir et des exemples de valeurs.
Type de données Kotlin | Types de données qu'il peut contenir | Exemples de valeurs littérales |
| Texte |
|
| Nombre entier |
|
| Nombre décimal |
|
| Nombre décimal (moins précis qu'un |
|
|
|
|
Vous connaissez maintenant certains types de données courants en langage Kotlin : quel type de données peut-on utiliser pour chacune des variables identifiées dans la page d'informations sur l'établissement vue précédemment ?
- Le nom du lieu est au format texte. Il peut donc être stocké dans une variable dont le type de données est
String.
. - La note du lieu correspond à un nombre décimal (p. ex. 4,2), et peut donc être stocké en tant que
Double
. - Le nombre d'avis sur le lieu est un nombre entier. Vous devez donc le stocker en tant que
Int
. - Si l'utilisateur a enregistré cet établissement, il n'a que deux valeurs possibles (enregistré ou non). Il est donc stocké comme une valeur
Boolean
, oùtrue
etfalse
appliquent l'un ou l'autre état. - L'adresse du lieu est un texte. Il s'agit donc d'une
String
. - La description du lieu est également un texte. Il doit donc s'agir d'une
String
.
Entraînez-vous à l'aide des deux autres situations ci-dessous. Identifiez l'utilisation de variables et leurs types de données dans les applications suivantes.
- Une application permettant de regarder des vidéos, comme l'application YouTube, comporte un écran affichant les informations de la vidéo. Où peut-on utiliser des variables ? À quel type de données correspondent ces variables ?
Il n'y a pas qu'une seule bonne réponse, mais dans une application de lecture de vidéos, vous pouvez notamment utiliser des variables pour les données suivantes :
- Nom de la vidéo (
String
) - Nom de la chaîne (
String
) - Nombre de vues de la vidéo (
Int
) - Nombre de "J'aime" sur la vidéo (
Int
) - Nombre de commentaires de la vidéo (
Int
)
- Dans une application de messagerie comme Gmail, l'écran de la boîte de réception affiche les e-mails les plus récents. Où peut-on utiliser des variables ? À quel type de données correspondent ces variables ?
Encore une fois, il n'y a pas qu'une seule bonne réponse. Dans une application de messagerie, vous pouvez utiliser des variables pour les données suivantes :
- Nom de l'expéditeur (
String
) - Objet de l'e-mail (
String
) - Suivi de l'e-mail (
Boolean
) - Nombre de nouveaux e-mails dans la boîte de réception (
Int
)
Essayer
- Ouvrez votre application préférée sur votre téléphone.
- Identifiez les emplacements où l'on utiliserait des variables dans l'application sur un écran spécifique.
- Devinez à quel type de données correspondent ces variables.
- Partagez vos réponses sur les réseaux sociaux avec une capture d'écran de l'application, une explication de l'utilisation des variables et le hashtag #AndroidBasics.
Bien joué ! Vous avez fait un excellent travail dans cet atelier de programmation. Passez à la section suivante pour en savoir plus sur l'utilisation des variables et des types de données à utiliser dans votre code.
3. Définir et utiliser des variables
Définir ou utiliser une variable
Vous devez définir une variable dans votre code avant de pouvoir l'utiliser. Vous avez déjà utilisé cette méthode lors du dernier atelier, qui vous a appris à définir les fonctions avant de les appeler.
Lorsque vous définissez une variable, vous lui attribuez un nom unique qui permettra de l'identifier. Vous pouvez également spécifier le type de données qu'il peut contenir. Enfin, vous pouvez fournir une valeur initiale qui sera stockée dans la variable, mais ce n'est pas obligatoire.
Une fois que vous avez défini une variable, vous pouvez l'utiliser dans votre programme. Pour utiliser une variable, saisissez son nom dans le code. Cette action indique au compilateur Kotlin que vous souhaitez utiliser la valeur de la variable à cet endroit du code.
Par exemple, définissez une variable pour le nombre de messages non lus dans la boîte de réception d'un utilisateur. Cette variable peut être nommée count
. Stockez une valeur comme le nombre 2
dans la variable, qui signifient que la boîte de réception de l'utilisateur comporte 2
messages non lus. (Vous pouvez stocker un autre nombre dans la variable, mais pour cet exemple, vous utiliserez le nombre 2
.)
Chaque fois que votre code doit accéder au nombre de messages non lus, saisissez count
dans votre code. Lors de l'exécution de vos instructions, le compilateur Kotlin voit le nom de la variable dans votre code et utilise la valeur de la variable à la place.
Voici la terminologie technique plus précise pour décrire ce processus :
Une expression est une petite unité de code associée à une valeur. Une expression peut être composée de variables, d'appels de fonction, etc. Dans le cas ci-dessous, l'expression est constituée d'une variable : la variable count
. La valeur de l'expression est 2
.
Evaluate (to) signifie déterminer la valeur d'une expression. Dans ce cas, l'expression est 2
. Le compilateur évalue les expressions dans le code et les utilise lorsque le programme exécute les instructions.
Pour observer ce comportement dans Kotlin Playground, exécutez le programme à la section suivante.
Exemple
- Ouvrez Kotlin Playground dans un navigateur Web.
- Remplacez le code existant dans Kotlin Playground par le programme suivant.
Ce programme crée une variable appelée count
avec une valeur initiale de 2
et l'utilise en imprimant la valeur de la variable count
dans la sortie. Ne vous inquiétez pas si vous ne maîtrisez pas encore tous les aspects de la syntaxe du code. Nous y reviendrons plus en détail dans les prochaines sections.
fun main() {
val count: Int = 2
println(count)
}
- Exécutez le programme. La sortie doit se présenter comme suit :
2
Déclaration de variable
Dans le programme que vous avez exécuté, la deuxième ligne de code indique :
val count: Int = 2
Cette instruction crée une variable entière appelée count
qui contient le nombre 2
.
Il faut parfois un certain temps pour se familiariser avec la lecture de la syntaxe (ou du format) de déclaration de variable en langage Kotlin. Le schéma ci-dessous indique où se trouve chaque détail de la variable, ainsi que l'emplacement des espaces et des symboles.
Dans le contexte de la variable count
, vous pouvez voir que la déclaration de variable commence par le mot val
. Le nom de la variable est count
. Le type de données est Int
, et la valeur initiale est 2
.
Chaque partie de la déclaration de variable est expliquée plus en détail ci-dessous.
Mot clé pour définir une nouvelle variable
Pour définir une nouvelle variable, commencez par le mot clé Kotlin val
(signifiant "valeur"). Le compilateur Kotlin sait alors qu'une déclaration de variable figure dans cette instruction.
Nom de la variable
Vous attribuez un nom à une variable de la même façon que vous nommez une fonction. Dans la déclaration de variable, le nom de la variable suit le mot clé val
.
Vous pouvez choisir le nom de votre choix. Toutefois, il est déconseillé d'utiliser des mots clés Kotlin en tant que nom de variable.
Il est préférable de choisir un nom qui décrit les données contenues dans la variable afin que votre code soit plus facile à lire.
Les noms de variables doivent respecter la convention Camel Case ("casse de chameau"), comme vous l'avez vu pour les noms de fonctions. Le premier mot du nom de la variable 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 variables :
numberOfEmails
cityName
bookPublicationDate
Pour l'exemple de code présenté précédemment, count
est le nom de la variable.
val count: Int = 2
Type de données variable
Après le nom de la variable, vous devez ajouter le signe deux-points, une espace, puis le type de données de la variable. Comme indiqué précédemment, String
, Int
, Double
, Float,
et Boolean
font partie des types de données de base en Kotlin. Vous découvrirez d'autres types de données dans la suite de ce cours. N'oubliez pas d'orthographier correctement les types de données et de les commencer par une lettre majuscule.
Pour l'exemple de variable count
, Int
correspond au type de données de la variable.
val count: Int = 2
Opérateur d'attribution
Dans la déclaration de variable, le signe égal (=
) suit le type de données. Le signe égal est appelé opérateur d'attribution. L'opérateur d'attribution attribue une valeur à la variable. En d'autres termes, la valeur figurant à droite du signe égal est stockée dans la variable située à gauche du signe égal.
Valeur initiale variable
La valeur de la variable correspond aux données réellement stockées dans la variable.
Pour l'exemple de variable count
, le nombre 2
correspond à la valeur initiale de la variable.
val count: Int = 2
Vous pouvez également entendre : "la variable count
est initialisée sur 2
". Cela signifie que 2
est la première valeur stockée dans la variable lorsque celle-ci est déclarée.
La valeur initiale varie en fonction du type de données déclaré pour la variable.
Reportez-vous au tableau ci-dessous, que vous avez peut-être déjà rencontré dans l'atelier de programmation. La troisième colonne contient des exemples de valeurs pouvant être stockées dans une variable de chaque type correspondant. Ces valeurs sont appelées des littéraux, car il s'agit de valeurs fixes ou constantes (la valeur est constamment identique). Par exemple, l'entier 32 aura toujours la valeur 32. En revanche, une variable n'est pas un littéral, car sa valeur peut changer. Ces valeurs littérales peuvent être mentionnées en fonction de leur type : littéral de chaîne, littéral d'entier, littéral booléen, etc.
Type de données Kotlin | Types de données qu'il peut contenir | Exemples de valeurs littérales |
| Texte |
|
| Nombre entier |
|
| Nombre décimal |
|
| Nombre décimal (moins précis qu'un |
|
|
|
|
Il est important d'indiquer une valeur appropriée et valide en fonction du type de données de la variable. Par exemple, vous ne pouvez pas stocker de littéral de chaîne comme "Hello"
dans une variable de type Int
, car le compilateur Kotlin génère une erreur.
Utiliser une variable
Vous trouverez ci-dessous le programme original que vous avez exécuté dans Kotlin Playground. Jusqu'à présent, vous avez appris que la deuxième ligne de code crée une variable entière appelée count
, dont la valeur est 2
.
fun main() {
val count: Int = 2
println(count)
}
Examinons à présent la troisième ligne de code. Vous imprimez la variable count
dans la sortie :
println(count)
Notez qu'il n'y a pas de guillemets autour du mot count
. Il s'agit d'un nom de variable, pas d'un littéral de chaîne. S'il s'agissait d'un littéral de chaîne, le mot pourrait être entouré par des guillemets. Lorsque vous exécutez le programme, le compilateur Kotlin évalue l'expression contenue entre parenthèses, à savoir count
, pour l'instruction println()
. Étant donné que l'expression renvoie 2
, la méthode println()
est appelée avec l'entrée 2
: println(2)
.
Par conséquent, la sortie du programme est :
2
Le nombre affiché dans la sortie n'est pas très utile. Il serait plus judicieux d'afficher un message plus détaillé dans la sortie pour expliquer ce que 2
représente.
Modèle de chaîne
Voici un exemple de message plus utile :
You have 2 unread messages.
Suivez les étapes ci-dessous pour afficher un message plus utile.
- Mettez à jour votre programme dans Kotlin Playground avec le code ci-dessous. Pour l'appel
println()
, transmettez un littéral de chaîne contenant le nom de la variablecount
. N'oubliez pas d'entourer le texte de guillemets. Notez que vous n'obtiendrez pas les résultats attendus. Vous résoudrez le problème lors d'une prochaine étape.
fun main() {
val count: Int = 2
println("You have count unread messages.")
}
- Exécutez le programme. La sortie doit se présenter comme suit :
You have count unread messages.
Cette phrase n'a aucun sens ! Vous souhaitez que la valeur de la variable count
s'affiche dans le message, et non dans le nom de la variable.
- Pour corriger votre programme, ajoutez le symbole dollar
$
avant la variablecount
:"You have $count unread messages."
Il s'agit d'un modèle de chaîne, car il contient une expression de modèle, qui est$count
ici. Une expression de modèle est une expression qui prend une valeur, qui est ensuite remplacée dans la chaîne. Dans ce cas, l'expression de modèle$count
prend la valeur2
, et2
est remplacé dans la chaîne où se trouve l'expression.
fun main() {
val count: Int = 2
println("You have $count unread messages.")
}
- Lorsque vous exécutez le programme, la sortie correspond à l'objectif souhaité :
You have 2 unread messages.
Cette phrase est beaucoup plus logique pour l'utilisateur !
- Remplacez maintenant la valeur initiale de la variable
count
par un autre littéral entier. Par exemple, vous pouvez choisir le nombre10
. Ne modifiez pas le reste du code.
fun main() {
val count: Int = 10
println("You have $count unread messages.")
}
- Exécutez le programme. Notez que le résultat change en conséquence et que vous n'avez même pas besoin de modifier l'instruction
println()
dans votre programme.
You have 10 unread messages.
Vous pouvez voir combien le modèle de chaîne peut se révéler utile. Vous n'avez écrit le modèle de chaîne qu'une seule fois dans votre code ("You have $count unread messages."
). Si vous modifiez la valeur initiale de la variable count
, l'instruction println()
fonctionne toujours. Votre code est désormais plus flexible !
Pour illustrer ce point, comparez les deux programmes ci-dessous. Le premier programme ci-dessous utilise un littéral de chaîne : le nombre exact de messages non lus s'affiche directement dans la chaîne. Ce programme ne fonctionne que lorsque l'utilisateur a 10 messages non lus.
fun main() {
println("You have 10 unread messages.")
}
Si vous utilisez une variable et un modèle de chaîne dans le deuxième programme ci-dessous, votre code couvrira un plus large éventail de cas. Ce deuxième programme est plus flexible !
fun main() {
val count: Int = 10
println("You have $count unread messages.")
}
Inférence de type
Voici une astuce qui vous permet d'écrire moins de code lorsque vous déclarez des variables.
On parle d'inférence de type lorsque le compilateur Kotlin peut déduire (ou déterminer) le type de données d'une variable, sans que le type ne soit écrit explicitement dans le code. Cela signifie que vous pouvez omettre le type de données dans une déclaration de variable si vous fournissez une valeur initiale pour cette variable. Le compilateur Kotlin examine le type de données de la valeur initiale et part du principe que vous souhaitez que la variable contienne les données de ce type.
La syntaxe d'une déclaration de variable suivante utilise l'inférence de type :
Revenons à l'exemple de "count" (nombre). Le programme contenait initialement cette ligne de code :
val count: Int = 2
Toutefois, cette ligne de code peut également être rédigée comme suit. Notez que les deux-points (:
) et le type de données Int
ne sont pas inclus. La syntaxe mise à jour nécessite moins de mots et permet d'obtenir le même résultat lorsque vous créez une variable Int
appelée count
avec la valeur 2
.
val count = 2
Le compilateur Kotlin sait que vous souhaitez stocker 2
(un nombre entier) dans la variable count
. Il peut donc déduire que la variable count
est de type Int
. Plutôt pratique. Il s'agit d'un exemple d'écriture plus concise en Kotlin.
Bien que cet exemple ne concerne qu'une variable de type Int
, le concept d'inférence de type s'applique à tous les types de données en langage Kotlin.
Opérations mathématiques de base avec nombres entiers
Quelle est la différence entre une variable Int
avec la valeur 2
et une variable String
avec la valeur "2"
? Lorsqu'elles sont toutes deux affichées dans la sortie, elles sont identiques.
Stocker des entiers en tant que Int
(par rapport à String
) présente un avantage : vous pouvez effectuer des opérations mathématiques avec des variables Int
, telles que des additions, des soustractions, des divisions et des multiplications (voir les autres opérateurs). Par exemple, vous pouvez ajouter deux variables entières pour obtenir la somme des deux. Dans certains cas, il est judicieux de stocker des entiers en tant que chaînes, mais le but de cette section est de vous montrer ce que vous pouvez faire avec des variables Int
.
- Revenez à Kotlin Playground et supprimez tout le code dans l'éditeur de code.
- Créez un programme dans lequel vous définissez une variable entière pour le nombre d'e-mails non lus dans une boîte de réception, puis initialisez-la avec une valeur comme
5
. Vous pouvez choisir un autre nombre si vous le souhaitez. Définissez une deuxième variable entière pour le nombre d'e-mails lus dans une boîte de réception. Initialisez-la sur une valeur comme100
. Vous pouvez choisir un autre nombre si vous le souhaitez. Imprimez ensuite le nombre total de messages dans la boîte de réception en ajoutant les deux nombres entiers.
fun main() {
val unreadCount = 5
val readCount = 100
println("You have ${unreadCount + readCount} total messages in your inbox.")
}
- Exécutez le programme pour qu'il affiche le nombre total de messages dans la boîte de réception :
You have 105 total messages in your inbox.
Pour un modèle de chaîne, vous avez appris que vous pouvez placer le symbole $
devant un seul nom de variable. Cependant, si votre expression est plus complexe, vous devez placer l'expression entre accolades en faisant précéder celles-ci du symbole $
: ${unreadCount + readCount}
. L'expression entre accolades unreadCount + readCount
prend la valeur 105
. La valeur 105
est ensuite remplacée dans le littéral de chaîne.
- Pour explorer ce sujet plus en détail, créez des variables avec des noms et des valeurs initiales différents, puis utilisez des expressions de modèle pour imprimer des messages dans la sortie.
Par exemple, modifiez votre programme pour imprimer ce qui suit :
100 photos 10 photos deleted 90 photos left
Voici une façon d'écrire votre programme, mais il existe d'autres méthodes tout aussi valables !
fun main() {
val numberOfPhotos = 100
val photosDeleted = 10
println("$numberOfPhotos photos")
println("$photosDeleted photos deleted")
println("${numberOfPhotos - photosDeleted} photos left")
}
4. Mettre à jour les variables
Lorsqu'une application est en cours d'exécution, il peut être nécessaire de mettre à jour la valeur d'une variable. Par exemple, dans une application d'achat, lorsque l'utilisateur ajoute des articles au panier, le total du panier augmente.
Illustrons ce cas d'utilisation (les achats) en créant un programme simple. La logique ci-dessous emploie le langage humain, et non le langage Kotlin. Cette technique est appelée pseudocode, car elle décrit les points clés du code qui sera écrit, mais elle ne contient pas tous les détails du code.
Dans la fonction principale d'un programme :
- Créez une variable entière
cartTotal
qui commence à la valeur0
. - L'utilisateur ajoute un pull à 20 $ à son panier.
- Définissez la variable
cartTotal
sur20
, qui correspond au coût actuel des articles dans le panier. - Imprimez le coût total des articles dans le panier de l'utilisateur, qui est la variable
cartTotal
, en sortie.
Vous n'avez pas besoin d'écrire de code pour l'action d'ajout dans le panier effectuée par l'utilisateur. (Vous n'avez pas encore appris comment un programme peut répondre aux entrées de l'utilisateur. Nous verrons ce point dans un prochain module.) Concentrez-vous donc sur les parties dans lesquelles vous créez, modifiez et imprimez la variable cartTotal
.
- Remplacez le code existant dans Kotlin Playground par le programme ci-dessous. À la ligne 2 du programme, initialisez la variable
cartTotal
sur la valeur0
. Puisque vous fournissez une valeur initiale, il n'est pas nécessaire de spécifier le type de donnéesInt
en raison de l'inférence de type. À la ligne 3 du programme, vous tentez de remplacer la variablecartTotal
par20
avec l'opérateur d'attribution (=
). À la ligne 4 du programme, vous imprimerez la variablecartTotal
à l'aide d'un modèle de chaîne.
fun main() {
val cartTotal = 0
cartTotal = 20
println("Total: $cartTotal")
}
- Exécutez le programme. Une erreur de compilation s'affiche.
- L'erreur indique que
val
ne peut pas être réattribué. L'erreur se situe à la troisième ligne du programme, qui tente de remplacer la valeur de la variablecartTotal
par20.
. Il n'est pas possible de réattribuer àval
cartTotal
une autre valeur (20
) une fois la valeur initiale (0
) attribuée.
Val cannot be reassigned
Si vous devez mettre à jour la valeur d'une variable, déclarez-la avec le mot clé Kotlin var
au lieu de val
.
- Mot clé
val
: à utiliser lorsque vous estimez que la valeur de la variable ne changera pas. - Mot clé
var
: à utiliser lorsque vous pensez que la valeur de la variable peut changer.
Avec val
, la variable est en lecture seule, ce qui signifie que vous pouvez uniquement consulter ou accéder à la valeur de la variable. Une fois la valeur définie, vous ne pouvez plus la modifier. Avec var
, la variable est modifiable, ce qui signifie qu'elle peut être modifiée. Il est possible de modifier la valeur.
Pour retenir la différence, voyez val
comme une valeur fixe et var
comme une variable. En Kotlin, il est recommandé d'utiliser le mot clé val
plutôt que le mot clé var
lorsque cela est possible.
- Modifiez la déclaration de variable
cartTotal
pour la ligne 2 du programme afin d'utiliservar
au lieu deval
. Voici à quoi ressemble le code :
fun main() {
var cartTotal = 0
cartTotal = 20
println("Total: $cartTotal")
}
- Notez la syntaxe du code à la ligne 3 du programme qui met à jour la variable.
cartTotal = 20
Utilisez l'opérateur d'attribution (=
) pour attribuer une nouvelle valeur (20
) à la variable existante (cartTotal
). Vous n'avez pas besoin d'utiliser le mot clé var
, car la variable est déjà définie.
À l'aide de l'analogie de la boîte, imaginez la valeur 20
stockée dans la boîte libellée cartTotal
.
Voici un schéma représentant la syntaxe générale d'une variable, déjà déclarée sur une ligne de code antérieure. Commencez l'instruction avec le nom de la variable que vous souhaitez mettre à jour. Ajoutez une espace, un signe égal, puis une autre espace. Écrivez ensuite la nouvelle valeur de la variable.
- Exécutez votre programme. Le code devrait maintenant se compiler correctement. La sortie suivante doit s'afficher :
Total: 20
- Pour voir comment la valeur de la variable change pendant l'exécution du programme, imprimez la variable
cartTotal
dans le résultat après la déclaration initiale de variable. Consultez les modifications de code ci-dessous. La ligne 3 comporte une nouvelle instructionprintln()
. Une ligne vide est également ajoutée à la ligne 4 du code. Les lignes vides n'ont aucune incidence sur la façon dont le compilateur comprend le code. Ajoutez une ligne vide pour faciliter la lecture de votre code. Elle vous permettra de séparer vos blocs de code de façon claire.
fun main() {
var cartTotal = 0
println("Total: $cartTotal")
cartTotal = 20
println("Total: $cartTotal")
}
- Exécutez le programme une nouvelle fois. La sortie doit se présenter comme suit :
Total: 0
Total: 20
Vous constatez qu'au départ, le panier total s'élève à 0
. Sa valeur est ensuite remplacée par 20
. La variable a été mise à jour avec succès, car vous avez remplacé cartTotal
, partant d'une variable en lecture seule (avec val
) pour obtenir une variable modifiable (avec var
).
N'oubliez pas que vous ne devez utiliser var
que pour déclarer une variable. Sinon, vous devez utiliser val
par défaut pour déclarer une variable. Cette pratique vous permet de renforcer la sécurité de votre code. L'utilisation de val
garantit que les variables ne seront pas mises à jour dans votre programme si vous ne souhaitez pas qu'elles le soient. Une fois qu'une valeur a été attribuée à val
, cette valeur est toujours conservée.
Opérateurs d’incrémentation et de décrémentation
Vous savez maintenant qu'une variable doit être déclarée en tant que var
pour mettre à jour sa valeur. Appliquez ces connaissances avec l'e-mail ci-dessous, qui devrait vous sembler familier.
- Remplacez le code dans Kotlin Playground par ce programme :
fun main() {
val count: Int = 10
println("You have $count unread messages.")
}
- Exécutez le programme. La sortie devrait afficher ce qui suit :
You have 10 unread messages.
- Remplacez le mot clé
val
par le mot clévar
pour transformer la variablecount
en une variable modifiable. La sortie ne devrait pas changer lorsque vous exécutez le programme.
fun main() {
var count: Int = 10
println("You have $count unread messages.")
}
- Cependant, vous pouvez maintenant mettre à jour
count
avec une autre valeur. Par exemple, lorsqu'un nouvel e-mail arrive dans la boîte de réception de l'utilisateur, vous pouvez augmenter la valeur decount
en lui ajoutant 1. Vous n'avez pas besoin d'écrire de code pour la réception d'un e-mail. Les données récupérées sur Internet constituent un sujet bien plus avancé qui fera l'objet d'un module à part entière. Pour l'instant, concentrons-nous sur la variablecount
qui augmente de1
avec la ligne de code suivante :
count = count + 1
L'expression à droite du signe égal est count + 1
et renvoie 11
. En effet, la valeur actuelle de count
est 10
(à la ligne 2 du programme) et 10 + 1
est égal à 11
. Avec l'opérateur d'attribution, la valeur 11
est attribuée ou stockée dans la variable count
.
Ajoutez cette ligne de code à votre programme en bas de la fonction main()
. Le code doit ressembler à l'extrait suivant :
fun main() {
var count = 10
println("You have $count unread messages.")
count = count + 1
}
Si vous exécutez le programme maintenant, vous obtenez le même résultat qu'avant, car vous n'avez ajouté aucun code pour utiliser la variable count
après sa mise à jour.
- Ajoutez une autre instruction d'impression qui affiche le nombre de messages non lus après la mise à jour de la variable.
fun main() {
var count = 10
println("You have $count unread messages.")
count = count + 1
println("You have $count unread messages.")
}
- Exécutez le programme. Le deuxième message devrait afficher le
count
mis à jour de11
messages.
You have 10 unread messages. You have 11 unread messages.
- Pour faire court, si vous souhaitez augmenter une variable de
1
, vous pouvez utiliser l'opérateur d'incrémentation (++
), qui se compose de deux symboles "plus". En utilisant ces symboles directement après le nom d'une variable, vous indiquez au compilateur que vous souhaitez ajouter 1 à la valeur actuelle de la variable, puis vous stockez la nouvelle valeur dans la variable. Les deux lignes de code suivantes sont équivalentes, mais l'utilisation de l'opérateur d'incrémentation++
nécessite moins de saisie.
count = count + 1
count++
Apportez cette modification à votre code, puis exécutez votre programme. Il ne doit pas y avoir d'espace entre le nom de la variable et l'opérateur d'incrémentation.
fun main() {
var count = 10
println("You have $count unread messages.")
count++
println("You have $count unread messages.")
}
- Exécutez le programme. Le résultat est identique, mais vous avez maintenant un nouvel opérateur à votre arc !
You have 10 unread messages. You have 11 unread messages.
- Modifiez maintenant la ligne 4 de votre programme pour utiliser l'opérateur de diminution (
--
) après le nom de la variablecount
. L'opérateur de diminution est composé de deux symboles "moins". En plaçant l'opérateur de diminution après le nom de la variable, vous indiquez au compilateur que vous souhaitez réduire la valeur de la variable de1
et stocker la nouvelle valeur dans la variable.
fun main() {
var count = 10
println("You have $count unread messages.")
count--
println("You have $count unread messages.")
}
- Exécutez le programme. La sortie suivante doit s'afficher :
You have 10 unread messages. You have 9 unread messages.
Dans cette section, vous avez appris à mettre à jour une variable modifiable à l'aide des opérateurs d'incrémentation (++
) et de diminution (--
). Ainsi, count++
est identique à count = count + 1
et count--
est identique à count = count - 1
.
5. Explorer d'autres types de données
Plus tôt dans l'atelier de programmation, vous avez découvert certains types de données de base courants : String
, Int
, Double
et Boolean
. Vous venez d'utiliser le type de données Int
. Vous allez maintenant explorer d'autres types de données.
Type de données Kotlin | Types de données qu'il peut contenir |
| Texte |
| Nombre entier |
| Nombre décimal |
|
|
Essayez ces programmes dans Kotlin Playground pour découvrir la sortie.
Double
Lorsque vous avez besoin d'une variable avec une valeur décimale, utilisez une variable Double
. Pour en savoir plus sur sa plage valide, consultez ce tableau, et examinez les chiffres décimaux qu'il peut stocker.
Imaginez que vous naviguez vers une destination et que votre itinéraire est divisé en trois parties distinctes, car vous devez faire des arrêts en cours de route. Ce programme indique la distance totale restante pour atteindre votre destination.
- Saisissez ce code dans Kotlin Playground. Comprenez-vous ce qui se passe sur chaque ligne de code ?
fun main() {
val trip1: Double = 3.20
val trip2: Double = 4.10
val trip3: Double = 1.72
val totalTripLength: Double = 0.0
println("$totalTripLength miles left to destination")
}
Trois variables appelées trip1
, trip2
et trip3
sont déclarées pour représenter la distance entre chaque étape de l'itinéraire. Toutes ces variables sont des variables Double
, car elles stockent des valeurs décimales. Utilisez val
pour déclarer chaque variable, car leurs valeurs ne changent pas au cours du programme. Le programme crée également une quatrième variable appelée totalTripLength
, qui est actuellement initialisée sur 0.0
. La dernière ligne du programme affiche un message avec la valeur totalTripLength
.
- Corrigez le code afin que la variable
totalTripLength
corresponde à la somme des trois distances de trajet.
val totalTripLength: Double = trip1 + trip2 + trip3
L'expression à droite du signe égal correspond à 9.02
, car 3.20 + 4.10 + 1.72
est égal à 9.02
. La valeur de 9.02
est stockée dans la variable totalTripLength
.
Votre programme doit se présenter comme suit :
fun main() {
val trip1: Double = 3.20
val trip2: Double = 4.10
val trip3: Double = 1.72
val totalTripLength: Double = trip1 + trip2 + trip3
println("$totalTripLength miles left to destination")
}
- Exécutez le programme. La sortie suivante doit s'afficher :
9.02 miles left to destination
- Corrigez votre code pour supprimer le type de données
Double
inutile des déclarations de variable, en raison de l'inférence de type. Le compilateur Kotlin peut déduire que ces variables sont des types de donnéesDouble
basés sur les nombres décimaux fournis en tant que valeurs initiales.
fun main() {
val trip1 = 3.20
val trip2 = 4.10
val trip3 = 1.72
val totalTripLength = trip1 + trip2 + trip3
println("$totalTripLength miles left to destination")
}
- Exécutez à nouveau votre code pour vous assurer qu'il est toujours compilé. Le résultat devrait être identique, mais votre code est désormais plus simple.
Chaîne
Lorsque vous avez besoin d'une variable pouvant stocker du texte, utilisez une variable String
. N'oubliez pas d'utiliser des guillemets autour des valeurs littérales de chaîne, par exemple "Hello Kotlin"
. Les valeurs littérales Int
et Double
n'en ont pas besoin.
- Copiez et collez ce programme dans Kotlin Playground.
fun main() {
val nextMeeting = "Next meeting is:"
val date = "January 1"
val reminder = nextMeeting + date
println(reminder)
}
Notez qu'il existe deux variables String
déclarées : une variable nextMeeting
et une variable date
. Ensuite, une troisième variable String
appelée reminder
est déclarée. Elle est égale à la somme des variables nextMeeting
et date
.
Avec le symbole +, vous pouvez ajouter deux chaînes. C'est ce qu'on appelle la concaténation. Les deux chaînes sont combinées, l'une après l'autre. Le résultat de l'expression nextMeeting + date
est "Next meeting is:January 1"
, comme illustré dans le schéma ci-dessous.
La valeur "Next meeting is:January 1"
est ensuite stockée dans la variable reminder
à l'aide de l'opérateur d'attribution à la ligne 4 du programme.
- Exécutez votre programme. La sortie suivante doit s'afficher :
Next meeting is:January 1
Lorsque vous concaténez deux chaînes, aucune espace supplémentaire n'est ajoutée entre les chaînes. Pour ajouter une espace après les deux-points, vous devez ajouter l'espace à l'une des chaînes.
- Mettez à jour la variable
nextMeeting
en ajoutant une espace supplémentaire à la fin de la chaîne avant le guillemet fermant. (Vous pouvez également ajouter une espace supplémentaire au début de la variabledate
.) Le programme doit ressembler à l'extrait suivant :
fun main() {
val nextMeeting = "Next meeting is: "
val date = "January 1"
val reminder = nextMeeting + date
println(reminder)
}
- Exécutez de nouveau votre programme. La sortie doit contenir une espace après les deux-points.
Next meeting is: January 1
- Modifiez le code pour concaténer (ou ajouter) un autre texte à l'expression stockée dans la variable
reminder
.
Utilisez le symbole +
pour ajouter le littéral de chaîne "at work"
à la fin de la chaîne reminder
.
- Exécutez le programme.
La sortie suivante doit s'afficher :
Next meeting is: January 1 at work
Le code ci-dessous vous montre une façon d'implémenter le comportement.
fun main() {
val nextMeeting = "Next meeting is: "
val date = "January 1"
val reminder = nextMeeting + date + " at work"
println(reminder)
}
Notez qu'il n'y a pas de guillemets autour de nextMeeting
et date
, car il s'agit de noms de variables de chaîne existantes (où leurs valeurs respectives sont au format texte et entourées par des guillemets). Inversement, le littéral "at work"
n'est défini dans aucune variable. Vous devez donc utiliser des guillemets autour de ce texte pour que le compilateur comprenne qu'il s'agit d'une chaîne qui doit être concaténée sur les autres chaînes.
Vous pouvez obtenir le même résultat en déclarant une seule variable String
avec le texte intégral au lieu d'utiliser des variables distinctes. Toutefois, l'objectif de cet exercice est de montrer comment déclarer et manipuler des variables String
, en particulier comment concaténer des chaînes distinctes.
- Lorsque vous lisez du code contenant des chaînes, vous pouvez rencontrer des séquences d'échappement. Les séquences d'échappement sont des caractères précédés d'une barre oblique inverse (
\
), également appelée barre oblique inverse d'échappement.
Par exemple, \"
apparaît dans un littéral de chaîne, comme dans l'exemple ci-dessous. Copiez et collez ce code dans Kotlin Playground.
fun main() {
println("Say \"hello\"")
}
Vous avez appris à utiliser des guillemets doubles autour d'un littéral de chaîne. Mais comment procéder si vous souhaitez utiliser le symbole "
dans votre chaîne ? Vous devez ajouter la barre oblique inverse avant le guillemet \"
dans votre chaîne. N'oubliez pas qu'il doit toujours être placé entre guillemets.
- Exécutez le programme pour voir le résultat. Voici ce qui devrait s'afficher :
Say "hello"
Dans le résultat, des guillemets s'affichent autour de hello
, car nous avons ajouté \"
avant et après hello
dans l'instruction println()
.
Pour les autres séquences d'échappement prises en charge en Kotlin, reportez-vous à la page de documentation sur les séquences d'échappement. Par exemple, si vous souhaitez ajouter une ligne dans votre chaîne, utilisez le symbole \
avant le caractère n, comme dans \n
.
Vous savez maintenant concaténer des chaînes et échapper des séquences au sein des chaînes. Passez au dernier type de données abordé dans cet atelier de programmation.
Booléen
Le type de données Boolean
est utile lorsque votre variable ne comporte que deux valeurs possibles, représentées par true
ou false
.
Par exemple, il s'agit d'une variable qui indique si le mode Avion d'un appareil est activé ou désactivé, ou si les notifications d'une application sont activées ou désactivées.
- Saisissez ce code dans Kotlin Playground. À la ligne 2 de ce programme, vous déclarez une variable
Boolean
appeléenotificationsEnabled
et l'initialisez surtrue
. Vous pouvez omettre: Boolean
dans la déclaration afin de le supprimer si vous le souhaitez. À la ligne 3 du programme, vous affichez la valeur de la variablenotificationsEnabled
.
fun main() {
val notificationsEnabled: Boolean = true
println(notificationsEnabled)
}
Exécutez le programme. Voici ce qui devrait s'afficher :
true
- Remplacez la valeur initiale
Boolean
par "false" à la ligne 2 du programme.
fun main() {
val notificationsEnabled: Boolean = false
println(notificationsEnabled)
}
Exécutez le programme. Voici ce qui devrait s'afficher :
false
- Les autres types de données peuvent être concaténés avec
Strings
. Par exemple, vous pouvez concaténerBooleans
avecStrings
. Utilisez le symbole+
pour concaténer (ou ajouter) la valeur de la variable booléennenotificationsEnabled
à la fin de la chaîne"Are notifications enabled? "
.
fun main() {
val notificationsEnabled: Boolean = false
println("Are notifications enabled? " + notificationsEnabled)
}
Exécutez le programme pour voir le résultat de la concaténation. Le programme devrait afficher le résultat suivant :
Are notifications enabled? false
Vous pouvez constater qu'il est possible de définir la variable Boolean
sur une valeur true
ou false
. Les variables Boolean
vous permettent de coder des scénarios plus intéressants, dans lesquels vous exécutez des instructions lorsqu'une variable Boolean
a une valeur true
. Si la valeur de Boolean
est "false", vous pouvez ignorer ces instructions. Vous en apprendrez plus sur les Booleans
dans un prochain atelier de programmation.
6. Conventions de codage
Dans l'atelier de programmation précédent, vous avez découvert le guide de style Kotlin, suivi par d'autres développeurs professionnels, qui vous permet d'écrire un code cohérent sur Android et conforme aux recommandations de Google.
Voici quelques autres conventions de mise en forme et de codage à suivre en fonction des nouveaux thèmes que vous avez étudiés :
- Les noms des variables doivent être écrits en Camel Case ("casse de chameau") et commencer par une lettre minuscule.
- Dans une déclaration de variable, vous devez insérer une espace après les deux-points (:) lorsque vous spécifiez le type de données.
- Il doit y avoir une espace avant et après un opérateur comme l'attribution (
=
), l'addition (+
), la soustraction (-
), la multiplication (*
), la division (/
) et plus encore.
- Lorsque vous écrivez des programmes plus complexes, la limite est fixée à 100 caractères par ligne. De cette façon, vous pouvez lire facilement l'ensemble du code d'un programme sur l'écran de votre ordinateur, sans avoir à faire défiler la page horizontalement.
7. Commentaires dans votre code
Lorsque vous codez, une autre bonne pratique consiste à ajouter des commentaires décrivant le code. Les commentaires peuvent aider les personnes qui lisent votre code à le suivre plus facilement. Les deux barres obliques (//
) indiquent que le texte situé après le reste de la ligne est un commentaire. Elles ne sont donc pas interprétées comme du code. Il est courant d'ajouter une espace après les deux symboles de barre oblique.
// This is a comment.
Il est également possible de commencer un commentaire au milieu d'une ligne de code. Dans cet exemple, height = 1
est une instruction de codage normale. Tout ce qui se trouve après //
ou Assume the height is 1 to start with
est interprété comme un commentaire et n'est pas traité comme un élément du code.
height = 1 // Assume the height is 1 to start with.
Si vous souhaitez décrire le code plus en détail et ajouter un commentaire dépassant 100 caractères sur une ligne, utilisez un commentaire multiligne. Le commentaire de plusieurs lignes doit commencer par une barre oblique (/
) et un astérisque (*
) sous la forme /*
. Ajoutez un astérisque au début de chaque ligne du commentaire. Enfin, ajoutez un astérisque suivi d'une barre oblique (*/
) au commentaire.
/*
* This is a very long comment that can
* take up multiple lines.
*/
Ce programme contient des commentaires sur une ou plusieurs lignes, décrivant ce qu'effectue le programme :
/**
* This program displays the number of messages
* in the user's inbox.
*/
fun main() {
// Create a variable for the number of unread messages.
var count = 10
println("You have $count unread messages.")
// Decrease the number of messages by 1.
count--
println("You have $count unread messages.")
}
Comme indiqué précédemment, vous pouvez ajouter des lignes vides à votre code pour regrouper les instructions connexes et faciliter la lecture du code.
- Ajoutez des commentaires à un extrait de code que vous avez utilisé précédemment.
- Exécutez le programme pour vous assurer que le comportement n'est pas altéré : les commentaires ne devraient pas affecter la sortie.
8. Conclusion
Très beau travail ! Vous avez découvert les variables en Kotlin, leur utilité en programmation, et comment les créer, les mettre à jour et les utiliser. Vous avez testé différents types de données de base en Kotlin, y compris les types de données Int
, Double
, String
et Boolean
. Vous avez également découvert la différence entre les mots clés val
et var
.
Tous ces concepts sont essentiels pour devenir développeur.
Rendez-vous pour notre prochain atelier de programmation !
Résumé
- Une variable est un conteneur qui ne contient qu'une seule donnée.
- Vous devez déclarer une variable avant de l'utiliser.
- Utilisez le mot clé
val
pour définir une variable en lecture seule dont la valeur ne peut pas être modifiée après avoir été attribuée. - Utilisez le mot clé
var
pour définir une variable modifiable ou interchangeable. - En Kotlin, il est préférable d'utiliser
val
plutôt quevar
lorsque cela est possible. - Pour déclarer une variable, commencez par le mot clé
val
ouvar
. Indiquez ensuite le nom de la variable, le type de données et la valeur initiale. Exemple :val count: Int = 2
. - Avec l'inférence de type, omettez de mentionner le type de données dans la déclaration de variable si une valeur initiale est fournie.
- Voici les types de données Kotlin de base les plus courants :
Int
,String
,Boolean
,Float
etDouble
. - Utilisez l'opérateur d'attribution (
=
) pour attribuer une valeur à une variable lors de sa déclaration ou de sa mise à jour. - Vous ne pouvez mettre à jour qu'une variable déclarée comme variable modifiable (avec
var
). - Utilisez l'opérateur d'incrémentation (
++
) pour augmenter de 1 la valeur d'une variable d'entier, ou l'opérateur de diminution (--
) pour la diminuer de 1. - Utilisez le symbole
+
pour concaténer des chaînes. Vous pouvez également concaténer d'autres types de données commeInt
etBoolean
avecStrings
.