🛠️ Compétences en génie informatique

Dans chaque unité, vous développerez un savoir-faire en lien avec le génie informatique. Ces compétences sont évaluées au moyen de projets concrets.

Les leçons sur une compétence sont dénotées par le symbole : 🛠️

📚 Concepts

Dans chaque unité, vous apprendrez aussi des nouveaux concepts. Le plus de concepts que vous maîtrisez, le plus que vous alimenter vos compétences pour produire des choses intéressantes. Les concepts sont évalués au moyen de quiz sur papier et d’entrevues

Les leçons sur un concept sont dénotées par le symbole : 📚

Partie A : Fonctionnement de l’ordinateur

Algorithmes

Définitions fondamentales pour le reste du cours

Matériel informatique

Comment les machines exécutent des algorithmes

Logiciels du système

Comment les utilisateurs et les applications utilisent le matériel informatique

Partie B : Programmation

Préparer l’environnement de développement

Installer, configurer et tester les logiciels pour la programmation

Les bases de Java

Les éléments de base du langage Java

Décomposition et modularité

Découper un problème en sous-problèmes et comment l’implémenter dans un programme

Structures de contrôle

Comment contrôler l’exécution d’un programme - le rendre intelligent et puissant

Structures de données

Mieux gérer et manipuler les données dans un programme

Domaines d’application variés

Se familiariser avec les technologies utilisées pour programmer des applications dans une variété de domaines

Algorithmes

Lien avec l’éthique, la société ou les carrières

💭 Quelques pistes de réflexion :

• Quel pourcentage des informations que vous consommez de façon volontaire (vidéos, annonces, articles, etc.) sont suggérées par un algorithme? Savez-vous comment ces algorithmes prennent leurs décisions?
• Durant le développement d’un produit ou service technologique, qui a la chance de décider des valeurs et des priorités qui sont incorporées dans le produit? Comment est-ce que ces décisions affectent les utilisateurs?

Leçons

1. 📚 Définition - c’est quoi un algorithme?

2. 📚 Niveaux d’abstraction - masquer ou plonger dans les détails

3. 🛠️ Cas d’utilisation - comprendre le produit et les besoins des parties prenantes

Matériel

Lien avec l’éthique, la société ou les carrières

💭 Quelques pistes de réflexion :

• Combien d’énergie est nécessaire pour exécuter des algorithmes importants dans la société moderne, comme une recherche sur Google ou pour développer et utiliser un modèle comme ChatGPT?
• Comment est-ce que les matériaux utilisés dans les composants électroniques sont extraits et traités? Quels sont les impacts environnementaux de ces activités? Comment est-ce que les gens qui travaillent dans ces industries sont traités?

Leçons

1. 📚 Portes logiques - Implémentations électroniques des opérations booléennes

2. 📚 Architecture - Organisation des composants électroniques dans un ordinateur

3. 📚 Périphériques - Détails pratiques en lien avec les périphériques connectés à un ordinateur

Logiciels du système

Lien avec l’éthique, la société ou les carrières

💭 Quelques pistes de réflexion :

• La plupart des systèmes d’exploitation associent des applications critiques, comme les navigateurs web et la messagerie, au système d’exploitation lui-même. Quels sont les avantages et les inconvénients de cette approche pour l’utilisateur? Qui profite de ces inconvenients?
• Plusieurs logiciels sont développés selon le modèle de logiciel libre et open source. Quels sont les avantages et les inconvénients de ce modèle :
  • pour les utilisateurs?
  • pour les développeurs?
  • pour les entreprises?

Leçons

1. 📚 Représentation interne des données - Quelques standards pour interpréter les bits comme informations variées

2. 📚 Langages de bas niveau - Les bits peuvent aussi représenter des instructions

3. 📚 Machine virtuelle - une interface qui masque les détails de la machine réelle

4. 🛠️ Organisation des fichiers - structure hiérarchique et chemins

But des cas d’usage

Les cas d’usage se concentrent sur les utilisateurs du système plutôt que sur le système lui-même. Un cas d’usage doit être compréhensible par toutes les parties prenantes, pas seulement les développeurs et les testeurs. Cela inclut les clients, les utilisateurs et les dirigeants. Ainsi le texte d’un cas d’usage est plutôt narratif que technique.

Une des meilleures justifications pour la création de cas d’utilisation est qu’ils servent de véritables points de connexion. Si bien rédigés, ils peuvent être compris par toutes les parties prenantes qui peuvent alors ajouter leurs commentaires et suggestions avant que le développement ne commence. Cela permet de s’assurer que le produit ou service répondra aux besoins de tous les utilisateurs.

Comment rédiger un cas d’usage

Pour rédiger un cas d’usage, procédez comme suit :

1. Déterminer le public cible du produit et le décrire en détail
2. Nommer toutes les parties prenantes et sélectionnez un membre de cette liste comme acteur principal. Pour des projets d’informatique du point de vue des développeurs, l’acteur principal est souvent un utilisateur du système.
3. Déterminez exactement ce que l’utilisateur souhaite faire avec le produit (son objectif). On devrait créer un cas d’usage pour chaque objectif.
4. Décrivez les conditions préalables à l’utilisation du produit ou du service. Par exemple, est-ce qu’un équipement spécial est nécessaire? Est-ce que l’utilisateur doit être connecté à Internet?
5. Déterminer le flux typique d’événements pour une session ou l’acteur principal atteint son objectif. Cela ressemble généralement, pour les produits informatiques, à plusieurs cycles d’une action de l’utilisateur suivie par une réponse du système.
6. Envisager d’autres usages normaux possibles et les décrire comme flux alternatifs.
7. Envisager également des situations anormales (p. ex.: des bris ou des erreurs) et les décrire comme flux exceptionnels.
8. Finalement, décrivez les conditions de sortie qui suivent l’usage normal par l’utilisateur, p. ex.: l’enregistrement des données.

Idéalement, après la rédaction d’un cas d’usage, on aurait une discussion avec les parties prenantes pour obtenir des commentaires et des suggestions pour ajuster d’avantage les flux et les conditions afin de mieux répondre aux besoins de chacun.

Exemples

Références additionnelles

• Blog sur le sujet du point de vue des gestionnaires de produit
• Bridging the Gap : un site qui explique les cas d’usage en détail

Les bases numériques

D’abord il faut réaliser que les valeurs dans un ordinateur sont toutes représentées en base 2 (avec seulement les nombres 0 et 1).

Toutes les bases numériques - décimal, binaire, hexadécimal, etc. - sont des systèmes de numération positionnels, où chaque position représente une puissance de la base.

• La première position (à la droite) est la puissance 0, donnant toujours les unités.
• La valeur à chaque position est un facteur à multiplier par la puissance de la base pour obtenir la valeur de la position. Par exemple, en décimal, la valeur 23 est décomposée comme suit :

23 
= 2 * 10^1 + 3 * 10^0 
= 2 * 10   + 3 * 1 
= 20       + 3

Comme les valeurs à base 10 (où chaque position représente la prochaine puissance de 10), les positions des bits dans les valeurs à base 2 représentent la prochaine puissance de 2.

Une autre base utile, rendant le binaire plus facile à digérer pour les humains, est l’hexadécimal, la base 16, où chaque position représente une puissance de 16. L’hexadécimal utilise un seul nombre pour chaque 4 bits. Par exemple, la valeur 1101 en binaire est équivalente à d (13) en hexadécimal.

Encodage binaire pour différents types de données

Démonstration (vidéo - du début à 3:30)

Une excellente explication des bases du fonctionnement se trouve dans la vidéo de Computerphile, notamment les trois premières minutes et demi.

Explication des instructions de bas niveau

Quelques points clés :

• chaque donnée, incluant les instructions, se trouve à une adresse spécifique en mémoire vive
• les instructions font toujours référence à l’adresse en mémoire et non à la valeur qu’elle contient; certaines instructions demandent de lire la valeur à cet endroit et d’autres demandent d’écrire une nouvelle valeur à cet endroit
• il y a des adresses spécialisées sur le processeur pour stocker des valeurs à court terme durant les opérations - les registres de l’unité d’arithmétique et de logique
• il y a un registre spécial qui stocke toujours l’adresse de la prochaine instruction à exécuter - le compteur du programme; certaines opérations modifient directement cette valeur, sinon l’adresse avance par un nombre de bits spécifique correspondant à la largeur des cellules en mémoire.

Ce qui n’est pas mentionné dans la vidéo mais qui est également important :

• S’il y a des données que vous voulez utilisez en référence durant le programme ou conserver par la suite, il doit avoir des adresses en mémoire pour ces valeurs au delà des registres de l’UAL (qui seront réutilisés pour d’autres opérations)
• On montre les instructions utilisant des mots qu’on peut lire et des nombres décimaux : Cela correspond au langage assembleur ou à un autre langage de bas niveau. Ces instructions seraient traduits en binaire (langage machine) pour l’exécution :
  • un code unique par mot-clé, chaque code correspondant à un circuit qui existe dans le processeur
  • toutes les valeurs sont en binaire
  • un format standard pour l’instruction, p. ex. 1 octet pour le code d’instruction et, selon l’instruction, des nombres spécifiques d’octets pour la 1e opérande et pour la 2e opérande.

Langages de bas niveau

Quand tout est en binaire (les codes d’opération et les opérandes), le code s’appelle le langage machine. Les 1 et 0 opèrent directement sur les circuits de l’ordinateur (les portes logiques et composants vus précédement).

Quand on remplace le code d’opération avec un mot-clé et on écrit les adresses avec des caractères (p.ex.: r1, 0x0004), le code s’appelle un langage assembleur. Il est équivalent au langage machine, mais lisible par les humains.

Ce sont les deux langages de bas niveau. Les opérations sont contraintes à représenter directement les circuits de la machine. Les langages de haut niveau n’ont pas cette contrainte.

Langages de haut niveau

Avec les langagages de haut niveau, on peut se permettre d’utiliser des mots-clés et des structures plus naturelles pour les humains sachant que ces instructions seront analysés par un logiciel (l’interpréteur ou le compilateur) qui les traduira en langage machine (ou produira des messages d’erreur si les instructions ne sont pas valides).

On trouve dans la plupart des langages de haut niveau des mot-clés comme : if-else (si, sinon), for (pour les éléments ou valeurs suivants), while (tant que la condition suivante est vraie), etc. Chacun de ces mots-clés seraient remplacé par toute une série de codes d’opération en langage machine.

Comparaison des différents types de programmes

Voici une comparaison de programmes écrites en trois version présumant les informations suivantes :

• le code 0b0001 = 0x1 = 1 est l’opération d’enregistrement d’une valeur en mémoire dans le registre r1
• le code 0b0010 = 0x2 = 2 est l’opération d’ajout d’une valeur à celle déjà dans le registre r1
• le code 0b0011 = 0x3 = 3 est l’opération de stockage d’une valeur à une adresse en mémoire vive
• la valeur 0b00011011 = 0x1b = 27 est une adresse en mémoire vive qui contient la valeur 2 (0b10 = 0x2)
• la valeur 0b00011100 = 0x1c = 28 est une adresse en mémoire vive qui contient la valeur 3 (0b11 = 0x3)

Le but du programme est d’ajouter les valeurs 2 et 3 et le stocker en mémoire à l’adresse 0x1d.

0b0001 0b00011011
0b0010 0b00011100
0b0011 0b00011101

Load r1, 0x1b
Add r1, 0x1c
Store r1, 0x1d

n = 2 + 3

Préparer l’environnement de développement

1. 🛠️ Installation des outils de travail
2. 🛠️ Outils d’un environnement de développement intégré (VS Code)
3. 📚 Les outils Java
4. 🛠️ Partager le code (Git et GitHub)

Les bases de Java

1. 📚 Structure d’un projet Java
2. 🛠️ Communication interne (identifiants et commentaires)
3. 📚 Afficher des messages à la console - partie 1
4. 📚 Données (int, double, boolean, char, String)
5. 📚 Afficher des messages à la console - partie 2
6. 📚 Utiliser des méthodes
7. 📚 Importer des classes
8. 📚 Entrées via la console
9. 📚 Opérations numériques
10. 📚 Diagrammes de flux

Décomposition et modularité

1. 🛠️ Décomposition
2. 📚 Séquence d’exécution avec le code modulaire
3. 📚 Implémenter des méthodes donnant une valeur de retour
4. 📚 Implémenter des méthodes recevant des arguments
5. 📚 Portée des variables
6. 🛠️ Tests unitaires

Structures de contrôle

1. 📚 Opérations logiques
2. 📚 Sélection/embranchement (if, else if, else)
3. 📚 Itération/boucles (while, for)
4. 🛠️ Gérer des exceptions (try, catch)

Structures de données

1. 📚 Tableaux
2. 📚 Strings
3. 🛠️ Entrées et sorties avec les fichiers

Domaines d’application

Ces leçons restent à développer… les sujets sont actuellement traités via des démonstrations et des projets concrets en classe.

1. 🛠️ Diverses piles technologiques - des langages et des outils adaptés à la tâche
2. 🛠️ Gérer des projets Java de groupe ou de plus grande taille avec Maven
3. 🛠️ Utiliser le framework JavaFX pour créer des interfaces graphiques dans Java

Langage de programmation

Trousse de développement Java (JDK) avec JavaFX -> par extraction d’un .zip et modification de la variable Path

Installer et configurer le JDK

Éditeur de code

Visual Studio Code -> installation avec une interface graphique + ajout d’extensions spécifiques à Java

Installer et configurer VS Code

Gestion des versions

Logiciel : Git pour Windows -> installation avec une interface graphique + configuration initiale au console

Installer et configurer Git pour Windows

Serveur distant : GitHub -> création d’un compte + intégration avec VS Code

Cycle de travail avec GitHub

Ouvrir un projet

Pour ouvrir un projet, il faut ouvrir un dossier dans VS Code. Voici comment faire :

• Ouvrez VS Code.
• Cliquez sur “File” dans la barre de menu.
• Cliquez sur “Open Folder…”.
• Trouvez le dossier que vous voulez ouvrir et cliquez sur “Select Folder”.

Vous pouvez aussi ouvrir un dossier à partir de votre Explorateur de fichiers Windows :

• Naviguer au dossier voulu
• Faites un clic droit sur le dossier, choisissez “Plus d’options” et choisissez “Ouvrir avec Code”.

Le nom du dossier que vous avez ouvert devient une section de la barre latérale gauche de VS Code. Cliquez sur le nom du dossier pour voir le contenu de ce dossier ou tapez Ctrl + Shift + E (le “E” est pour “Explorateur de fichiers”) pour le même effet.

Testez votre compréhension

Dans VS Code, ouvrez le dossier qui contient le fichier Demo.java que vous avez créé dans une leçon précédente. Si vous n’avez pas encore créé de fichier Java, simplement ouvrir le dossier ~/Documents dans VS Code.

Créer un fichier Java dans votre projet

Pour ajouter un fichier Java à votre projet, il suffit de créer un fichier avec l’extension .java dans le dossier de votre projet. Voici comment faire :

• Cliquez sur le bouton “New File” dans l’Explorateur de fichiers de VS Code.

  

• Tapez le nom du fichier suivi de l’extension .java, p. ex. HelloWorld.java.

• Le fichier sera créé et ouvert dans l’éditeur de code.

C’est TRÈS IMPORTANT d’ajouter l’extension .java au nom du fichier, sinon les outils de Java ne fonctionneront pas correctement (même si VS Code peut reconnaître le code Java sans l’extension).

Testez votre compréhension

Créez le fichier HelloWorld.java dans votre projet.

Ajouter le code Java brisé suivant¹. Ne le réparez pas pour l’instant. On verra très bientôt comment les outils Java nous aident à trouver les erreurs.

void main() {
   system.out.prinln("Hello, World!")
}

Enregistrement automatique - un paramètre utile

Avec les outils de travail dans le nuage, comme la suite Google ou la suite Microsoft Office, nous sommes habitués à ce que nos documents soient enregistrés automatiquements pour nous, mais ce n’est pas le comportement par défaut dans VS Code.

Pour activer l’enregistrement automatique, la façon la plus simple est :

• d’ouvrir la palette de commandes avec Ctrl + Shift + P
• taper Auto Save pour trouver la commande Files: Toggle Auto Save. S’il n’était pas activé, il le sera maintenant. S’il était activé, il ne le sera plus.

Vous pouvez savoir si l’enregistrement automatique n’est pas activé si le X à côté du nom du fichier dans l’éditeur n’est plus un X mais un cercle ●. Cela signale que les derniers changements dans l’éditeur n’ont pas été enregistrés sur le disque.

Attention : si vous tentez de lancer un programme à partir d’un fichier qui n’a pas été enregistré, c’est la dernière version enregistrée qui se lance, pas ce que vous voyez dans l’éditeur. Croyez-moi, vous pouvez perdre beaucoup de temps à chercher une erreur qui n’existe plus simplement parce qu’il y a cet écart entre ce que vous voyez et ce qui est enregistré.

Testez votre compréhension

1. Regardez le nom du fichier HelloWorld.java dans l’éditeur. Est-ce que le X est un X ou un cercle? Le ● indique un fichier qui n’est pas enregistré.
2. Basculer l’activation de l’enregistrement automatique et vérifier si le cercle devient un X.
3. Ajoutez une ligne vide à la fin du code. Est-ce que le Xdevient un cercle ou reste un X?
4. Répétez les deux dernières étapes une autre fois et notez la différence.
5. Si l’enregistrement automatique n’est pas activé en ce moment, l’activer avant de continuer.

Extensions utiles pour programmer avec Java

C’est important d’avoir un peu d’équilibre dans la vie. Je vous suggère d’installer l’extension VS Code Pets en plus de l’extension de productivité ci-dessous. Choisissez un animal (ou un autre entité) de compagnie pour vous tenir compagnie pendant que vous travaillez.

On peut rendre VS Code plus puissant pour la programmation dans le langage de notre choix en ajoutant des extensions adaptées. Pour Java, ces extensions sont emballés dans le Java Extension Pack.

Ces outils vous aident à :

• Trouver des erreurs dans votre code avant de l’exécuter
• Exécuter votre code avec un bouton au lieu d’une commande
• Trouver des suggestions pour améliorer votre code
• Trouver des informations sur les classes et les méthodes que vous utilisez (si vous leur ajouter des commentaires de documentation)
• Passer à travers le code pas-à-pas avec un débogueur pour voir comment il fonctionne ou pour trouver des erreurs de logique

Installez et configurer le Java Extension Pack

1. Ouvrez la vue des extensions en tapant Ctrl + Shift + X (“X” pour “eXtensions”) ou en cliquant sur l’icône dans la barre latérale gauche.
2. Tapez Java Extension Pack dans la barre de recherche.
3. Trouvez la version de Microsoft et cliquez sur le bouton “Install”.

   Si vous avez une erreur indiquant qu’il faut installer un JDK, votre installation de Java est incomplète. Voir la leçon sur l’installation de Java pour résoudre ce problème (notamment la section sur les variables d’environnement).

4. Attendre que l’installation soit complète… vous le saurez quand l’indicateur Java dans la barre d’état en bas de l’écran arrête son animation.
5. Ouvrez les paramètres de VS Code avec Ctrl + ,.
6. Changez le paramètre “inlay hints” :
   • Tapez java inlay dans la barre de recherche.
   • Trouvez le paramètre “Java: Inlay Hints”.
   • Changez la valeur de “literal” -> “none”. Cela élimine des notations dans le code qui n’existent pas dans le texte que vous avez écrit.
7. Changez le paramètre du “mode de lancement” :
   • Tapez java launch dans la barre de recherche.
   • Trouvez le paramètre “Java: Server Launch Mode”.
   • Changez la valeur de “hybrid” -> “standard”. Cela assure que les outils d’analyse du code démarrent immédiatement quand vous ouvrez vos projets.
8. Redémarrez VS Code.

Testez votre compréhension

Ouvrez le fichier HelloWorld.java dans VS Code. Vous devriez voir des lignes rouges apparaître dans le code. Ces lignes indiquent des erreurs dans le code. Cliquez sur une ligne rouge pour voir le message d’erreur.

Cliquez sur le bouton “Run” en haut à droite de l’éditeur pour exécuter le code. Vous devriez voir les mêmes messages d’erreur dans la console que ceux que vous avez vus en passant votre curseur sur les lignes rouges.

Si vous parvenez à décoder ces messages d’erreur (ils ne sont pas toujours très clairs), vous pouvez essayer de corriger le code et le lancer de nouveau. Comment interpréter ces messages est un art qui se développe avec l’expérience et la pratique.

Terminal intégré

En lançant votre programme Java avec le bouton “Run” dans l’éditeur, vous avez déjà utilisé le terminal intégré : c’est là que la commande derrière le bouton “Run” est exécutée et c’est aussi là que la sortie de votre programme est affichée.

Vous pouvez utiliser le terminal intégré dans VS Code exactement comme vous utilisez le programme Terminal. Les deux utilisent le même shell (bash, PowerShell, etc.) et les mêmes commandes.

Pour ouvrir le terminal intégré, tapez Ctrl + ` (le ` est la touche à gauche de Entrée sur un clavier francophone et à la gauche du 1 sur un clavier anglophone) ou naviguer dans le menu “Terminal” puis choisir “New Terminal”.

Testez votre compréhension

1. Ouvrez le terminal intégré.
2. Tapez ls pour voir la liste des fichiers dans le dossier de votre projet. Assurez-vous que HelloWorld.java est dans la liste.
3. Tapez java HelloWorld.java pour lancer le programme dans le code source HelloWorld.java.
4. Tapez clear pour effacer la console.
5. Utilisez la flèche du haut pour charger la commande java HelloWorld.java (les flèches du haut et du bas permettent de naviguer dans l’historique des commandes). Tapez Enter pour lancer le programme une autre fois.
6. Tapez exit pour fermer le terminal.

Clôner un projet partagé via GitHub

Votre enseignant vous prépare des gabarits de projets, parfois juste des dossiers vides, pour organiser vos programmes dans le cours. Pour les utiliser, vous devez les clôner dans votre ordinateur. Voici comment faire :

• Acceptez d’abord la tâche dans GitHub Classroom, ce qui vous créera une copie personnelle du projet sur GitHub.

• Ouvrez VS Code.

• Ouvrez la palette de commandes avec Ctrl + Shift + P.

• Tapez “clone” pour trouver la commande Git: Clone et cliquez dessus. Si vous l’avez déjà utilisée, elle apparaîtra dans la liste des commandes récentes sans avoir à la chercher.

  Si c’est la première connexion, VS Code vous demandera de vous connecter à GitHub. Suivez ATTENTIVEMENT les instructions pour vous connecter. Si on vous propose une option “toujours…”, cochez-la pour éviter des problèmes de connexion à l’avenir.

  À SURVEILLER : Parfois la fenêtre pour une des étapes d’authentification apparaît en arrière-plan, bloquant la connexion. Regarder la barre des tâches pour voir s’il y a des nouvelles fenêtres ouvertes.

• Cliquez ensuite sur Clone from GitHub et attendre que la liste des dépôts apparaisse. Puisque vous n’en avez pas beaucoup, votre dépôt sera facile à trouver dans la liste.

• Cliquez sur le dépôt que vous voulez clôner et choisissez un dossier où le clôner dans la fenêtre qui s’ouvre. Je suggère fortement d’utiliser votre dossier “Documents” pour tous les projets.

• VS Code créera un dossier avec le nom du dépôt à cet endroit et copiera le projet dedans.

• VS Code vous proposera d’ouvrir le dossier clôné avec les options suivantes :

  • Open : ferme le projet ouvert actuellement et ouvre le projet clôné
  • Open in New Window : ouvre le projet clôné dans une nouvelle fenêtre de VS Code (gardant le projet actuellement ouvert dans la fenêtre originale)
  • Add to Workspace : ajoute le projet clôné à la liste des dossiers actuellement ouverts dans VS Code (utile si vous avez plusieurs projets ouverts en même temps)

    En général, les options Open ou Open in New Window sont les plus simples à gérer.

Clônez une seule fois, synchronisez par la suite

Si vous avez déjà clôné un projet, vous n’avez pas besoin de le clôner à nouveau pour continuez à travailler dedans. Vous pouvez simplement ouvrir le dossier du projet dans VS Code. Il y a même une section “Open Recent” dans le menu “File” pour vous aider à retrouver les projets que vous avez ouverts récemment.

Testez votre compréhension

Clônez le projet “pratique” dans votre dossier “Documents” et ouvrez-le dans VS Code. Le lien pour le gabarit de ce projet est partagé avec vous dans Classroom.

Modifier, indexer et valider des fichiers dans un dépôt local

Cette section vous montre comment apporter des changements dans votre dépôt local, les conserver avec Git et les partager avec le dépôt distant, sur GitHub.

Modifier

Cette étape est la partie normale de la production de code : vous créez, modifiez et supprimez des fichiers en faisant vos exercices ou en développant vos programmes. Assurez-vous de travailler dans un dossier de projet et non sur des fichiers isolés. Seulement les fichiers dans un dépôt local - comme ceux que vous clônés de GitHub - peuvent être indexés et validés. Les dépôts locaux sont tous des dossiers.

Vous savez que vous faites des modifications dans un dépôt local si vous voyez un “M” à côté des noms des fichiers modifiés ou un “U” (pour “Untracked”) pour les fichiers que vous venez de créer. Si vous faites des modifications et vous ne voyez pas ces indicateurs, il y a deux possibilités : vous n’avez pas enregistré les fichiers sur le disque (activez l’enregistrement automatique) ou les fichiers ne sont pas dans un dépôt (utiliser l’Explorateur de fichiers Windows pour les déplacer dans votre dépôt).

De plus, vous devrez utiliser les outils de travail (les extensions Java, le terminal intégré, etc.) pour vous aider à écrire du code Java valide et fonctionnel. La leçon précédente sur VS Code vous explique davantage ces outils. En d’autres mots, vous devrez tester votre code avant de passer aux prochaines étapes.

Indexer et valider

En plus des indicateurs de modification mentionnés plus haut, vous pouvez voir le nombre de fichiers modifiés sur l’icône de l’outil Git dans la barre latérale de VS Code. Vous pouvez seulement indexer et valider des fichiers modifiés, alors vous pouvez seulement passer à cette étape quand il y a un nombre affiché.

Ces étapes peuvent se faire au terminal - et vous avez beaucoup plus de possibilités au terminal - mais VS Code vous offre une interface graphique pour les faire, ce qui est plus convivial. Voici comment l’utiliser :

• Cliquez sur l’icône “Source Control” dans la barre latérale de VS Code ou en tapant Ctrl + Shift + G (“G” pour “Git”).
• Les fichiers modifiés apparaîtront dans la liste “Changes”. Ce sont tout les fichiers qu’il est possible d’indexer.

  Vous pouvez cliquer sur un fichier pour voir les modifications qu’il contient. Les lignes en vert sont les ajouts, les lignes en rouge sont les suppressions.

• Pour indexer un fichier, cliquez sur le + à côté du nom du fichier. Cela ajoutera le fichier à la liste des fichiers indexés. Vous pouvez indexer tous les fichiers en cliquant sur le + en haut de la liste (à côté de “Changes”). Les fichiers indexés sont les sujets de l’instantané que vous allez prendre en validant les modifications.
• Écrire un message qui décrit les modifications indexées. Il est impossible de compléter la validation sans ce message. Il y a une zone de texte en haut du panneau de contrôle pour taper ce message. Voici quelques exemples de messages courts et descriptif :
  • Salut.java et capture pour l’exercice 1
  • ajout de commentaires pour l’exercice 2
  • progession sur Projet.java
  • correction d’erreurs dans Main.java
• Valider les modifications indexées en cliquant sur le bouton “Commit” (le bouton avec la coche). Cela prend un instantané des modifications indexées. Ces modifications sont maintenant enregistrées dans Git, mais seulement sur votre ordinateur dans le dépôt local.

  Si vous oubliez d’écrire un message, VS Code bloque l’opération et ouvre un éditeur de message à la droite. Écrivez votre message sur une ligne qui ne commence pas par # (qui est un commentaire) et fermez l’éditeur (en l’enregistrant au besoin). La validation se complétera automatiquement.

Testez votre compréhension

Modifiez le fichier “README.md” dans le projet “pratique” : ajouter une ligne vide ou supprimez quelque chose. Indexez et validez le fichier avec un message descriptif.

Visitez votre dépôt sur GitHub pour voir que les modification n’ont pas été partagées. Rafraîchissez la page pour être certain. Ces étapes ont seulement créé une version qui peut être partagée avec un dépôt distant. Il faut faire la synchronisation pour partager cette version.

Synchroniser les changements avec le dépôt distant

Valider et synchroniser du code est comme la photographie. Un cliché se trouve d’abord juste sur l’appareil du photographe. Pour les partager avec le monde, le photographe doit les téléverser sur une plateforme de partage, comme un réseau social.

Partager des instantanés de code est pareil. La validation enregistre l’instantané sur votre ordinateur mais vous devez encore le téléverser sur le dépôt distant (GitHub), soit le synchroniser avec ce dépôt. Voici comment faire :

• Après la validation, le bouton “Commit” devient “Sync Changes” avec le nombre de validations à pousser. S’il y a aussi des validations sur le dépôt distant qui ne sont pas sur votre ordinateur, le bouton affichera le nombre de validations à tirer.
• Pour synchroniser, il suffit de cliquer sur le bouton.

Bonnes habitudes pour éviter les conflits de fusion

Pour éviter d’avoir à fusionner les validations à tirer avec les validations à pousser, vous devrez suivre ces règles d’or : toujours synchroniser (tirer) avant de commencer à travailler sur un projet et toujours synchroniser avant de fermer l’ordinateur. De cette façon, tout ce qui est à tirer arrive seul au début d’une session de travail, laissant seulement les modifications à pousser à la fin de la session de travail. De plus, vous commencerez toujours votre session avec la version la plus à jour du projet.

Après votre première synchronisation, VS Code vous demandera si vous voulez tirer périodiquement les modifications distantes. Je vous recommande de le faire (ce qui inclut une synchronisation chaque fois que vous ouvrez le projet), mais vous pouvez choisir de le faire manuellement si vous préférez afin de développer la discipline de synchroniser avant de travailler.

Vous devrez tout de même développer la discipline de synchroniser à la fin des périodes de travail.

Quand vous travaillerez en équipes (l’année prochaine), il y a des stratégies plus avancées pour éviter les conflits de fusion - notamment l’utilisation de branches, mais pour vos projets personnels, cette règle est suffisante et efficace.

Testez votre compréhension

Synchronisez les modifications du projet “pratique” avec le dépôt distant. Visitez votre dépôt sur GitHub pour voir que les modifications ont été partagées. Rafraîchissez la page au besoin.

Exemple - un programme qui affiche “Bonjour” à la console

Voici les étapes pour produire ce programme :

1. Créer un fichier qui s’appelle Bonjour.java - l’extension .java est important. D’autres éléments du nom seront expliqués dans la prochaine leçon.

   C’est possible que les outils de votre EDI suggèrent l’insertion d’une classe du même nom, p. ex. public class Bonjour { }, dès que le fichier s’ouvre dans l’éditeur. Vous devrez effacer ce code afin de maintenir la structure minimale pour ce programme.²

2. Définir une méthode main. Les deux accolades {} représentent les limites du contenu de la méthode.

   void main() {}
   

   Si vos outils Java sont activés, vous devrez voir deux liens : Run | Debug apparaître au-dessus de la méthode main. Cela signifie que le compilateur Java a reconnu la méthode main comme le point d’entrée du programme.

3. C’est utile de taper Entrée entre les deux accolades pour créer un espace pour les instructions. Vous verrez que l’accolade fermante est placée directement sous le début de la ligne void main() tandis que le curseur est indenté vers la droite. Cela est une convention de format pour nous aider à voir que les accolades sont bien fermées pour les différents blocs de code.

   void main() {
       
   }
   

4. Ajouter des instructions à l’intérieur de la méthode main, soit entre ces deux accolades. Dans ce cas-ci, on inclut une seule instruction qui affiche le texte “Bonjour!” à la sortie du système (la console)

   void main() {
        System.out.println("Bonjour!");
   }
   

   Notez que l’instruction se termine avec un point-virgule ;. C’est nécessaire pour toutes les instructions Java.

5. Lancez le programme avec le bouton Run - soit celui au-dessus de la méthode main dans l’éditeur, soit le bouton Play en haut à droite de VS Code.

   Normalement, je préfère lancer les programmes au terminal avec ma propre commande soit java NomDuFichier.java (ici ce serait java Bonjour.java) mais la structure simplifiée présentée ici exige une commande un peu plus complexe en date de Java23 java --enable-preview NomDuFichier.java.

6. Vous devriez voir le message “Bonjour!” affiché à la console, sinon un message d’erreur s’il y a un problème avec le code. Les messages d’erreur incluent plusieurs informations pour vous aider à trouver le problème, notamment le numéro de ligne où le programme a planté.

Indentation

L’indentation dans l’exemple ci-dessus est très important pour la lisibilité du code et pour vérifier que les accolades sont bien fermées. Notez que l’accolade fermante est visible directement en dessous de la définition de la structure qu’elle ferme (ici la méthode, mais il y en aura d’autres). C’est une convention de style très utile parce que c’est facile d’oublier ou d’effacer une accolade par accident.

VS Code devrait créer cette indentation automatiquement, mais c’est facile de le briser en modifiant ou en déplaçant du code. Utiliser régulièrement la commande “Mettre le document en forme” (dans VS Code : Alt+Shift+F ou clic droit > “Mettre le document en forme”) pour maintenir une indentation correcte. Voici des moments quand vous devriez utiliser cette commande :

• après avoir copié-collé un exemple de code
• après avoir déplacé des instructions ou un bloc de code que vous avez écrit
• si vous ne voyez plus les accolades fermantes sous la signature du bloc de code (comme void main()) parce qu’il y a d’autre code dans le chemin
• si toutes vos instructions dans un même bloc de code ne sont pas alignées verticalement
• avant de rendre un programme lors d’une évaluation

Erreurs de syntaxe communes

Notez que “Mettre le document en forme” ne fonctionne pas s’il y a des erreurs de syntaxe, soit du code qui n’est pas compris par le compilateur Java. Si les outils Java sont activés, ces erreurs seront signalés pendant que vous tapez votre code : l’endroit de l’erreur est souligné en rouge. Si vous passez votre curseur sur cet endroit, vous pouvez lire dans une info-bulle un message décrivant l’erreur. Si les outils Java ne sont pas activés, vous verrez le même message d’erreur et des informations sur son endroit dans le code quand vous tentez de lancer le programme.

Voici quelques exemples d’erreurs communes :

• des {, (, ; ou des " manquants ou de surplus dans le code
• mauvaise capitalisation d’un mot, p. ex. string au lieu de String
• mot mal écrit, p. ex. print1n (le chiffre 1) au lieu de println (la lettre L minuscule)
• du texte qui n’est pas emballé dans des guillemets (") -> ce texte est alors interprété comme le nom de quelque chose qui devrait exister dans le code mais qu’on ne trouve pas.

Règles Java pour les identifiants

Les règles suivantes s’appliquent quand vous choisissiez des noms pour les classes, les méthodes, les variables et les constantes dans Java. Le programme plantera si ces règles ne sont pas respectées:

• Caractères permis : L’identifiant est composé uniquement des caractères a-z, A-Z, 0-9, _ et $. Notez qu’il n’y a pas d’espaces dans cette liste. Les lettres avec accents sont aussi acceptés, mais à cause de la complexité des différents encodages de caractères, il est préférable de les éviter.
• Les majuscules et les minuscules font une différence : Les identifiants sont sensibles à la casse. Le même mot écrit avec des majuscules ou des minuscules fait référence à deux identifiants distincts.
• Aucun chiffre au début : Les identifiants ne peuvent pas commencer par un chiffre.
• Pas un mot clé : Les identifiants ne peuvent pas être des mots-clés Java, p. ex. public, class, void, int, for, if, etc. Ces mots sont déjà définis par Java et ne peuvent pas être utilisés pour autre chose.

Conventions Java pour les identifiants

Différents langages encouragent différents styles de noms pour les identifiants pour les différents élements du programme. Cela aide les développeurs à associer une fonction à un identifiant simplement en observant sa forme.

Voici les conventions de Java.

Casse chameau pour les méthodes et les variables

Tous les noms de variables et de méthodes respectent la casse chameau (“camel case” en anglais) : toutes les lettres sont minuscules et chaque mot suivant commence par une majuscule. Par exemple : nomDeVariable, nomDeMethode().

Pourquoi le nom chameau? Parce que les majuscules au milieu des mots ressemblent aux bosses sur le dos d’un chameau.

Casse pascal pour les classes et les noms de fichiers

La casse pascal et comme la casse chameau, mais la première lettre est aussi une majuscule. Par exemple : NomDeClasse.

C’est vraiment important d’écrire les noms de classe avec une majuscule initiale pour les distinguer des variables et des méthodes. C’est une convention de nommage très répandue même au-delà de Java.

Pourquoi le nom pascal? C’est un hommage à Pascal, un langage de programmation historiquement important qui utilisait cette convention.

En Java, le nom du fichier doit avoir le même nom que la classe qu’il contient. Si la classe s’appelle NomDeClasse, le fichier doit s’appeler NomDeClasse.java. Ainsi, tous les noms de fichiers seront également en casse pascal. Dans notre cas, où la déclaration de la classe sera implicite, il faut tout de même nommer le fichier avec la casse pascal parce que le fichier et la classe sont liés.

Casse serpent avec majuscules pour les constantes

Pour indiquer qu’une variable ne change jamais de valeur, soit qu’elle est constante, on utilise une casse spéciale. Les constantes sont écrites en majuscules avec des soulignements pour séparer les mots. Par exemple : NOM_DE_CONSTANTE.

Pourquoi le nom serpent? Possiblement parce qu’en chaînant les mots avec des soulignements, on imagine les segments du corps d’un serpent. Possiblement parce que les soulignement ressemblent à des serpents au sol. Le nom n’est pas officiel, mais il est communément utilisé depuis au moins 2004.

Résumé des conventions

Identifiants descriptifs

Si les conventions aident les développeurs à reconnaître la fonction générale d’un identifiant, les mots utilisés dans l’identifiant les aident à comprendre plus spécifiquement ce que l’identifiant représente dans le programme.

C’est extrêmement important de choisir des noms descriptifs pour tous les identifiants tant pour vous aider à comprendre le sens de ce que vous tentez d’accomplir que pour communiquer ce sens aux autres développeurs.

Cela s’applique pour tous les langages de programmation.

Exemple

Que veux dire l’expression suivante?

a = b * c;

À part savoir qu’on assigne le produit de deux valeurs à une troisième valeur, c’est impossible de le savoir.

Maintenant, que veux dire l’expression suivante?

areaOfRectangle = length * width;

ou

weeklyPay = hoursWorked * hourlyRate;

Ces deux expressions on exactement la même forme que le premier exemple, mais on peut savoir pourquoi on l’a utilisé dans chaque cas. C’est parce que les identifiants ont été nommés de manière descriptive.

Note : même si on travaille en français, il est préférable d’utiliser l’anglais pour les identifiants parce que les mots-clés du langage sont en anglais. Ainsi, le code est plus facile à lire et on évite les problèmes de caractères spéciaux (p. ex. é, ç, à, etc.).

Commentaires explicatifs - commentaires de ligne ou de bloc

Parfois simplement respecter les conventions de nommage et la pratique de noms descriptifs, il ne reste pas grande chose à expliquer dans le code. Mais il y a des moments où un commentaire est nécessaire pour expliquer un choix de variable ou un algorithme particulier. C’est là que les commentaires explicatifs ont leur place.

Les commentaires sont ignorés par le compilateur, donc ils n’ont pas d’impact sur le fonctionnement du programme. Ainsi, on devrait les écrire en français dans un langage naturel qui nous convient.

C’est un art de trouver à quel point les commentaires explicatifs passent d’utile à redondant. Lorsqu’il y a trop de commentaires ou les commentaires dupliquent l’information dans les identifiants descriptifs, ils nuisent à la clarté du code. En contrepartie, s’il n’y a pas assez de commentaires, la logique de certaines parties du code peut être difficile à suivre. EN CAS DE DOUTE, surtout comme novice, il vaut mieux en mettre un peu trop que pas assez.

Syntaxe des commentaires

Il y a deux façons de laisser des commentaires dans le code Java :

• Les commentaires de ligne suivent deux barres obliques // et se limitent à la ligne sur laquelle ils sont écrits.
• Les commentaires de bloc s’étendent entre les délimiteurs /* et */ ce qui leur permet de couvrir plusieurs lignes, au besoin.

Exemple de commentaire de ligne

On suit souvent la déclaration d’une variable avec un commentaire de ligne pour expliquer pourquoi on a choisi une valeur initiale particulière ou pour indiquer comment il sera utilisé plus loin, si ce n’est pas déjà assez clair par le nom de la variable.

int age; // conservera l'âge fourni par l'utilisateur

Si on arrive à une structure de contrôle (comme une sélection ou une boucle), on précède souvent la structure avec un commentaire pour expliquer le but de la structure. Si l’explication est courte, ce commentaire peut-être un commentaire de ligne.

// Décider si l'utilisateur peut voter
if (age > 18) {
    System.out.println("Vous pouvez voter!");
} else {
    System.out.println("Vous ne pouvez pas voter.");
}

Finalement, certaines opérations complexes peuvent être expliquées avec un commentaire de ligne.

// La distance entre deux points (x1, y1) et (x2, y2)
int dx = x2 - x1;
int dy = y2 - y1;
double distance = Math.sqrt(dx * dx + dy * dy);

Exemple de commentaire de bloc

Le commentaire de bloc est utilisé comme en-tête d’un fichier, pour présenter des informations comme la description, comment l’utiliser, qui l’a fait, s’il y a une licence spécifique attachée au code, etc.

/*
Nom de la classe : Salut
Description : Un programme simple qui affiche un message de salutation.
Auteur : David Crowley
Date de création : 2023-09-01
*/

On utilise aussi un commentaire de bloc si la logique d’un algorithme ne peut pas s’expliquer sur une seule ligne.

/*
On gagne si on atteint 100 points ou plus.
On perd si on atteint 20 tentatives.
On quitte en milieu du jeu si l'utilisateur a tapé "q".
*/
if (points >= 100) {
    System.out.println("Vous avez gagné!");
} else if (attempts >= 20) {
    System.out.println("Vous avez perdu.");
} else if (userInput.equals("q")) {
    System.out.println("Vous avez quitté le jeu.");
}

Notez que vous pouvez aussi utiliser plusieurs commentaires de ligne une après l’autre au lieu d’utiliser un commentaire de bloc. C’est ce qui arrive souvent, parce qu’on ne réalise pas la longueur du commentaire avant de l’écrire.

Documentation interne - Javadoc

Ceci est un sujet qui est plus avancé. Nous l’utiliserons pas dès le début, contrairement aux autres sujets de cette leçon. La section demeure ici pour référence future.

Les commentaires explicatifs sont utiles pour présenter notre logique lorsqu’un développeur lit les détails internes de notre code. Mais c’est aussi pratique de connaître le contenu d’une classe ou la structure d’une méthode même sans lire le code. C’est là que la documentation interne entre en jeu.

La documentation interne, appelé javadoc en Java, est un format de commentaire spécial qui est reconnu par les outils Java pour générer de la documentation officielle. Les outils Java vous affichent le contenu de ces commentaires dans l’auto-complétion (lorsque vous tapez votre code) et dans les info-bulles (lorsque votre souris passe sur un identifiant).

Pour créer un commentaire javadoc :

• on utilise un commentaire de bloc avec un * supplémentaire au début. Le bloc commence alors par /** (deux astérisques) et se termine par */.
• Le javadoc doit être placé immédiatement devant la déclaration de la classe ou de la méthode qu’il documente. Sinon, les outils Java ne sauront pas à quoi il se réfère : il sera considéré comme un simple commentaire de bloc.
• C’est mieux d’écrire le javadoc après avoir écrit le code. Les outils de votre EDI peuvent alors ajouter plusieurs détails automatiquement avec le bon format, vous laissant juste la tâche d’ajouter les descriptions.
• Votre EDI ajoutera probablement des * supplémentaires pour chaque ligne du javadoc. C’est une convention pour rendre le commentaire plus lisible, mais ces astérisques internes ne sont pas nécessaires pour que le javadoc fonctionne.

Format général pour le javadoc d’une méthode

Les paramètres (les @param) et la valeur de retour (le @return) sont des sujets plus avancés qui seront traités plus tard dans le cours. Pour l’instant, si on demande le javadoc d’une méthode, on s’attend à voir juste sa description.

/**
 * Description de la méthode.
 *
 * @param nomParamètre Description du paramètre
 * @param nomAutreParamètre Description de l'autre paramètre
 * @return Description de la valeur de retour
 */

print et println

Voici le contenu d’un fichier nommé SimplePrinting.java :

void main() {
    System.out.print("Bonjour ");
    System.out.println("tout le monde!");
    System.out.println("Comment ça va?");
}

Et voici sa sortie :

Bonjour tout le monde!
Comment ça va?

Notez que la première instruction, System.out.print("Bonjour ");, n’a pas de retour à la ligne parce qu’on a utilisé la méthode print(). Alors le texte de la deuxième instruction, System.out.println("tout le monde!");, continue sur la même ligne. Puisque cette instruction utilise la méthode println() le texte à afficher avec la troisième instruction, System.out.println("Comment ça va?"); est sur une nouvelle ligne. Cette dernière instruction utilise aussi la méthode println(), alors le curseur se trouve à la ligne suivante après l’affichage du message.

Insérer un retour de ligne manuellement : les caractères d’échappement

On peut insérer des retours de ligne manuellement dans les messages à afficher en utilisant le caractère d’échappement \n. Voici un exemple dans le fichier LineReturns.java :

void main() {
    System.out.println("Bonjour\n tout\n  le\n   monde!");
}

Et voici sa sortie :

Bonjour
 tout
  le
   monde!

Notez que le caractère \n est remplacé par un retour à la ligne dans le message affiché, alors chaque mot dans le message est sur une ligne séparée. Les mots sont aussi décalés de plus en plus vers la droite parce qu’on a inclut plus d’espaces après chaque caractère \n.

Il y a d’autres caractères d’échappement comme \" pour insérer une double guillemet dans un message entre guillemets. Voir cette page pour une liste complète.

Types de données de base

Les types Java de base sont :

Déclaration de variables

Le format pour la déclaration d’une variable est le suivant :

type nom;

par exemple :

int count;
double pi;
boolean isRaining;
char letter;
String name;

Initialisation de variables

Pour initialiser une variable, on doit lui assigner une première valeur. Le symbole = est utilisé en Java pour signifier que la variable à la gauche stocke maintenant la valeur à la droite.

Si la variable est déjà déclarée on utilise seulement son nom du côté gauche :

nom = valeur; // initialiser ou assigner une valeur à une variable qui existe déjà

On peut aussi donner une valeur initiale lors de la déclaration de variable, donc la déclaration complète serait du côté gauche :

type nom = valeur; // déclaration et initialisation en une seule ligne

Voici quelques exemples :

// ces variables ont été déclarées dans l'exemple précédent
count = 0;
pi = 3.14159;
isRaining = true;
letter = 'A';
name = "David";

// ces nouvelles variables sont initialisées durant la déclaration
double sum = 2.0 + 3.1; // assigner la somme de deux nombres
String answer = ""; // assigner le texte vide comme valeur initiale
int sum = 0;

Ordre des opérations dans une assignation de valeur

L’opération à droite du symbole = est effectuée avant l’assignation de la valeur à la variable à gauche. Par exemple, dans l’exemple double sum = 2.0 + 3.1;, la somme de 2.0 et 3.1 est calculée avant d’être assignée à la variable sum.

Ceci est très utile si on veut changer la valeur d’une variable par un montant fixe. Par exemple, count = count + 1; ajoute 1 à la valeur actuelle de count. Cette expression n’est pas une équation mathématique, mais plutôt une opération spécifique (l’assignation) qui est effectuée en deux étapes : d’abord, le côté droit est évalué, puis le résultat est assigné au côté gauche.

Exemple concret

Voici un court exemple dans le contexte d’un programme Java complet :

void main() {
    int age = 16;
    String name = "Myriam";
    System.out.print(name);
    System.out.print(" a ");
    System.out.print(age);
    System.out.println(" ans.");
}

et sa sortie serait :

Myriam a 16 ans.

Messages formatés : printf

Vous pouvez utiliser la méthode printf() pour afficher des messages formatés. C’est utile quand vous :

• essayez de coller plusieurs valeurs ensemble dans une phrase.
• voulez contrôler le nombre de chiffres après la virgule pour un nombre décimal.
• voulez afficher des valeurs en colonnes de largeur fixe.

Vous verrez que pour la plupart des situations, vous pouvez utiliser des print, des println et de la concaténation pour afficher ces messages au lieu d’utiliser printf : dans ces cas, c’est une préférence personnelle. Par contre, pour l’affichage uniforme des valeurs décimales ou pour l’alignement du texte, printf est la seule solution raisonnable.

Exemple - Coller des valeurs dans une phrase

Reproduire cet exemple dans un fichier nommé PrintGlue.java et tester la sortie.

Rappel : c’est toujours mieux de taper les exemples vous-même (et découvrir ce que vos outils vous aident à compléter, où se trouvent les symboles sur le clavier, etc.) que de copier-coller l’exemple. Vous gagnerez plus de confiance avec votre capacité à produire du code. C’est la différence entre CRÉER (taper) et UTILISER (copier-coller) du code, même si le code final est le même.

void main() {
    String name = "Malcolm";
    int age = 16;

    // AVEC PLUSIEURS PRINT ET PRINTLN (sans concaténation des valeurs)
    System.out.print("Mon nom est ");
    System.out.print(name);
    System.out.print(" et j'ai ");
    System.out.print(age);
    System.out.println(" ans.");

    // AVEC PRINTLN (et concaténation des valeurs)
    System.out.println("Mon nom est " + name + " et j'ai " + age + " ans.");

    // AVEC PRINTF
    System.out.printf("Mon nom est %s et j'ai %d ans.\n", name, age);
}

et la sortie identique pour les trois approches :

Mon nom est Malcolm et j'ai 16 ans.
Mon nom est Malcolm et j'ai 16 ans.
Mon nom est Malcolm et j'ai 16 ans.

Structure de la méthode printf

La méthode printf accepte un nombre variable d’arguments. Le premier argument est toujours le String qui définit le format du message à afficher, incluant le texte de base et des drapeaux de formatage pour les valeurs à insérer dans le message. Les prochains arguments sont les valeurs à insérer dans le message, remplaçant chaque drapeau.

System.out.printf("message avec drapeaux pour les valeurs", valeur1, valeur2, ...);

Dans dans l’exemple System.out.printf("Mon nom est %s et j'ai %d ans.\n", name, age); :

• Le String de formatage est "Mon nom est %s et j'ai %d ans.\n".
  • il y a deux drapeaux de formatage : %s pour une valeur de type String et %d pour une valeur de type int.
  • Il y a aussi le caractère d’échappement pour le retour de ligne, \n, parce que printf ne l’inclut pas; c’est comme print.
• Le prochain argument est name (de type String qui s’évalue à “Malcolm”). Sa valeur remplacera le %s, le premier drapeau de formatage.
• Le dernier argument est age (de type int qui s’évalue à 16). Sa valeur remplacera le %d, soit le dernier drapeau de formatage.

Voici un tableau de quelques drapeaux de formatage communs :

Exemple - Contrôler le nombre de chiffres après la virgule pour un nombre décimal

Voici quelques exemples que vous pouvez tester dans une session jshell. Lancez la commande jshell dans un terminal pour ouvrir une session jshell. Quittez la sesssion avec la commande \exit.

double PI = 3.141592653589793; // constante pour la valeur de pi
System.out.printf("La valeur de pi est %f.\n", PI);
System.out.printf("La valeur de pi est %.2f.\n", PI);

sortie :

La valeur de pi est 3.141593.
La valeur de pi est 3.14.

Comme le premier exemple, le premier argument est le String qui définit le format du message. Dans ce cas on utilise le drapeau %f pour une valeur de type double. La valeur à insérer est 3.141592653589793. Par défaut, printf affiche 6 chiffres après la virgule pour les nombres décimaux. Pour contrôler le nombre de chiffres après la virgule, on peut ajouter un point et un nombre entre le % et le f.

Dans le deuxième exemple, on a ajouté .2 pour afficher seulement 2 chiffres après la virgule. Le .2 est un élément optionnel dans le drapeau de formatage pour les valeurs décimales. On peut remplacer 2 par n’importe quel nombre pour afficher ce nombre de chiffres après la virgule.

Voici un tableau présentant quelques options pour le formatage des valeurs décimales :

Exemple - Afficher des colonnes de valeurs alignées

// Afficher des valeurs en colonnes de largeur fixe
System.out.printf("%-10s %10s\n", "NOM", "ÂGE"); // en-têtes
System.out.printf("%-10s %10d\n", "Malcolm", 16);
System.out.printf("%-10s %10d\n", "Myriam", 17);

sortie :

NOM               ÂGE
Malcolm            16
Myriam             17

Ici on a plusieurs instructions printf, une pour chaque ligne d’un tableau. La première instruction donne les en-têtes, donc les drapeaux de formatage dans le premier argument sont %s pour une valeur de type String. Pour spécifier la largeur de colonne, on peut ajouter des éléments optionnels entre % et le s. Dans ce cas :

• on a ajouté -10 pour spécifier une largeur de 10 caractères et un alignement à gauche.
• on a ajouté 10 pour spécifier une largeur de 10 caractères avec l’alignement par défaut (à droite).
• comme avec les valeurs décimales, on peut remplacer 10 par n’importe quel nombre pour spécifier la largeur de colonne voulue.
• Notez que les valeurs substituées seront tronquées (coupées) si elles sont plus longues que la largeur de colonne spécifiée. Soit, le format spécifié est respecté même s’il faut couper le texte pour le faire.

Les arguments suivants sont les valeurs à insérer dans le message, dans l’ordre où ils apparaissent dans le message. Donc "NOM" est inséré à la place de %-10s et "ÂGE" est inséré à la place de %10s.

Pour les lignes suivantes, les valeurs pour “Âge” sont de type int, alors on utilise le drapeau %d au lieu de %s, mais on maintient les mêmes spécifications pour la largeur et l’alignement, donc %10d au lieu de %10s. Les valeurs à insérer sont 16 pour la première ligne et 17 pour la deuxième.

Voici un tableau présentant quelques options pour le formatage des colonnes :

Utilise jshell

C’est mieux de testez les exemples ici dans le REPL jshell parce que les résultats sont affichés immédiatement un-par-un. Tapez une seule ligne de code à la fois et appuyez sur Enter pour voir le résultat.

Méthodes d’instances de String

Voici quelques exemples de méthodes qu’on peut utiliser avec des variables de type String :

String name = "David";
name.length(); // le nombre de caractères
name.charAt(0); // le premier caractère
name.toUpperCase();
// conserver le résultat dans une variable
String lowerName = name.toLowerCase();

Méthodes statiques de la classe Math

Voici quelques exemples de méthodes statiques de la classe Math :

Math.sqrt(9); // racine carrée ("square root") -> sqrt
Math.abs(-5); // valeur absolue (ignore le signe)
Math.pow(10, 3); // puissance ("power") -> pow... 10^3
// conserver le résultat dans une variable
double chance = Math.random(); // aléatoire entre 0.0 et 0.9999999
chance * 100; // changer l'échelle (0.0 à 99.9)
25 + chance * 25 // changer l'échelle et la valeur initiale (25.0 à 49.9)

Un regard sur les méthodes print

Est-ce que println est une méthode d’instance ou une méthode statique?

System.out.println("Bonjour");

C’est une méthode d’instance! La variable out dans la classe System est un objet de type PrintStream (placez votre curseur sur le mot out dans un programme Java complet pour voir son info-bulle), et les PrintStream ont une méthode println().

On verra plusieurs autres types de données dans le cours, comme des Random, des Scanner et des File, qui ont aussi des méthodes d’instance pour utiliser leurs objets.

Suggestions par votre EDI

Votre EDI devrait suggérer les méthodes d’instance ou les méthodes statique possibles dès que vous tapez le . après le nom de l’objet ou de la classe. Vous pouvez sélectionner une méthode dans la liste pour l’ajouter à votre code source. Quand les méthodes sont affichées dans la bulle de suggestion, vous voyez aussi le type des arguments et le type de retour.

Par contre, ce que vous faites au terminal - notamment les sessions jshell - ne bénificie pas de cette fonctionnalité.

Les outils Java prennent une minute ou plus pour s’activer pleinement après l’ouverture d’un projet dans VS Code. Ils ne s’activent jamais pleinement si vous n’avez pas configurez l’extension pour se lancer en mode Standard au lieu d’Hybrid. Si vous ne voyez rien ou vous voyez juste le message “Loading…” quand votre curseur est sur un nom comme String, vous devrez attendre encore un peu.

Gabarit de programme avec importations standard

Voici un gabarit de structure de programme Java avec les importations nécessaires pour utiliser les classes dans les packages java.io et java.util. Vous pouvez copier ce gabarit pour commencer un nouveau programme.

/*
 * En-tête de fichier
 */

import java.io.*; // importe sur demande les classes du package java.io
import java.util.*; // importe sur demande les classes du package java.util


void main() {
  // code du programme
}

Note

Depuis JDK 25, les classes dans java.util et java.io sont importés implictement (sans déclaration) comme si vous aviez déclaré leur importation. Bref, ces commande import ne sont plus nécessaires depuis Java 25.

Exemples de déclarations de variables avec les types importés

import java.util.*;

void main() {
  String myString; // pas besoin d'importation parce que String est dans java.lang
  Scanner myScanner; // importation nécessaire pour utiliser java.util.Scanner
  Random myRandom; // importation nécessaire pour utiliser java.util.Random
}

Si vous oubliez la déclaration d’importation, votre IDE peut généralement ajouter les importations nécessaires automatiquement. Dans VS Code, si vous tentez de déclarer un Scanner sans avoir ajouté la ligne pour l’importer, vous verrez une ligne ondulée rouge sous le nom de la classe indiquant une erreur. Si vous cliquez sur le nom souligné et tapez la commande Ctrl + . vous verrez une option pour ajouter l’importation nécessaire.

Les exemples ici n’initialisent pas les variables et ne les utilisent pas. On verra dans des leçons futures comment ces différents objets sont créés et utilisés.

Structure générale d’un programme avec un Scanner

Les Scanner sont utilisés pour lire du texte à partir de différentes sources. Pour commencer, on utilisera un Scanner qui surveille System.in pour complémenter le PrintStream (System.out) qu’on utilise déjà pour afficher des messsages texte à la console. Bref, les Scanner vont nous permettre de lire des réponses de l’utilisateur à la console et d’avoir des programmes interactifs.

Si vous ne l’aviez pas deviné, System.in et System.out sont les entrées et sorties standard de votre système d’exploitation, notamment la console.

La structure globale d’un programme qui utilise un Scanner est la suivante :

import java.util.*; // importer la définition de Scanner de java.util

void main() {
    Scanner console = new Scanner(System.in); // déclarer un Scanner pour la console

    // ... le reste du programme
}

Déclarer un Scanner

Le format de la déclaration d’un Scanner est le suivant :

Scanner nom = new Scanner(source);

où nom est le nom de la variable qui contiendra l’objet Scanner et source est la source de texte que le Scanner lira. Le nom est généralement un reflèt précis de la source.

Pour lire de la console

On utilise System.in, l’entrée standard, comme source.

Scanner console = new Scanner(System.in);

Pour lire un String

On utilise un String comme source.

String text = "Bonjour, le monde!";
Scanner textReader = new Scanner(text);

Fermer un Scanner

On ne ferme jamais le Scanner pour la console parce qu’on s’en sert généralement jusqu’à la fin du programme interactif. Ce Scanner sera fermé automatiquement en arrivant à la fin de la méthode main.

Par contre, c’est important de fermer les Scanner pour toutes les autres sources de texte, comme un fichier ou un String. On ferme un Scanner avec la méthode close() une fois qu’on a finit de le lire. Par exemple :

textReader.close();

Introduction aux méthodes de Scanner - extraire les données d’un String

Pour comprendre comment les méthodes de Scanner fonctionnent, on va les tester sur différents String. Les sections plus bas montrent le Scanner dans le contexte d’un programme interactif.

String words = "\n   \tBonjour le monde!";
Scanner wordsReader = new Scanner(words); // Scanner qui utilise le texte 'words' comme source

String word; // variable pour stocker le mot lu

word = wordsReader.next(); // ignore les espaces initiaux puis saisit tout jusqu'au prochain espace, soit "Bonjour"
System.out.println(word);

word = wordsReader.next(); // saisit "le"
System.out.println(word); 

word = wordsReader.next(); // saisit "monde!"
System.out.println(word); 
wordsReader.close();

String info = "Marie 15 85.5";
Scanner infoReader = new Scanner(info);
String nom = infoReader.next(); // saisir le nom
int age = infoReader.nextInt(); // saisir le texte pour le nombre entier
double moyenne = infoReader.nextDouble(); // saisir le nombre décimal
infoReader.close();
System.out.printf("%s a %d ans et sa moyenne est %.1f\n", nom, age, moyenne);

Marie a 15 ans et sa moyenne est 85.5

String info = "Marie 15 85.5";
Scanner infoReader = new Scanner(info);

infoReader.useLocale(Locale.CANADA); // spécifie le format "."

String nom = infoReader.next(); 
int age = infoReader.nextInt(); 
double moyenne = infoReader.nextDouble(); 
infoReader.close();
System.out.printf("%s a %d ans et sa moyenne est %.1f\n", nom, age, moyenne);

Version interactive : lire la console

En interagissant à la console, c’est important de donner des invites de réponse claires et spécifiques à l’utilisateur afin qu’elle sache quoi taper et avec quel format, si nécessaire.

Voici un exemple en transformant le programme précédent en un programme interactif :

Scanner console = new Scanner(System.in); // source = entrée standard
console.useLocale(Locale.CANADA_FRENCH); // spécifie le format ","

System.out.print("Quel est votre prénom? "); // invite de réponse
String nom = console.next(); 

System.out.print("Quel est votre âge? "); // invite de réponse
int age = console.nextInt(); 

// invite de réponse qui reflète la déclaration du Locale plus haut dans le code
System.out.print("Quelle est votre moyenne? (utilisez le ',' comme décimal) "); 
double moyenne = console.nextDouble(); 

System.out.printf("%s a %d ans et sa moyenne est %.1f\n", nom, age, moyenne);

// notez qu'on n'a pas fermé le Scanner pour la console

Enrichissement : valider la réponse avant de la saisir

Cette section est annotée comme “avancée” parce qu’elle incorpore des éléments de programmation que nous n’avons pas encore vus avec Java, notamment les opérations logiques et les boucles. Si vous ne comprenez pas tout de suite, ne vous inquiétez pas. Vous aurez l’occasion de revoir ces concepts plus tard dans le cours.

Si vous comprenez bien comment formuler une invite de réponse précise et comment assurer la cohérence entre votre invite et ce que vous avez écrit dans votre code, peut-être que vous ne serez pas satisfait de laisser une erreur de frappe par l’utilisateur faire planter votre programme. C’est là qu’on peut commencer à rendre le code plus tolérante aux erreurs en les gérant avant qu’elles ne causent des problèmes.

Pour valider une réponse avant de la saisir, on utilise les méthodes hasNextInt() et hasNextDouble() pour vérifier si le prochain mot est convertible en int ou double respectivement. Si la réponse est valide, on la saisit, la convertit et la conserve. Sinon, on doit vider le Scanner pour préparer la saisie suivante, alors on saisit la réponse comme texte sans la conserver. On peut également afficher un message d’erreur et inviter l’utilisateur à réessayer.

Scanner console = new Scanner(System.in);

System.out.print("Saisissez un nombre entier : ");
while (!console.hasNextInt()) {
    console.next(); // vider le Scanner du jeton incorrect
    System.out.println("Ce n'est pas un nombre entier valide.");
    System.out.print("Saisissez un nombre entier : ");
}

int number = console.nextInt();
System.out.println("Vous avez saisi " + number);

L’opérateur ! est l’inverse logique (“not”). Il transforme true en false et false en true. Dans ce contexte, !console.hasNextInt() signifie “tant que le Scanner n’a pas un nombre entier valide comme prochain jeton”.

jshell

C’est pratique d’explorer ces opérations dans une session interactive qui donne le résultat instruction par instruction (au lieu d’écrire un programme complet et l’exécuter). Pour le faire, simplement lancer la commande jshell au terminal. Ensuite tapez vos instructions une à la fois (le ; est optionnel dans jshell). Pour quitter, tapez la commande /exit ou fermez le terminal.

Opérations mathématiques

Voici la liste des opérateurs mathématiques qui fonctionnent sur deux valeurs numériques, soit de type int ou double :

• + addition
• - soustraction
• / division
• * multiplication
• % modulo (restant)

Division entière

La division entre deux entiers (int) peut seulement donner un entier comme résultat parce qu’il n’y a pas de partie décimale pour un int.

Exemples à évaluer dans jshell :

7 / 2; // donne 3 (pas 3.5)
7 / 3; // donne 2 (pas 2.333...)
1 / 2; // donne 0 (pas 0.5)

Modulo (restant)

Le modulo (%) donne le reste de la division.

1 % 3; // restants de la division par 3
2 % 3;
3 % 3;
4 % 3;

7 % 2; // restant de la division par 2

113 % 10; // restant de la division par 10

C’est utile pour vérifier si un nombre est divisible par un autre utilisant la condition “egale 0?”, soit == 0 en Java. Par exemple :

if ((a % 17) == 0) {
    // a est divisible par 17 parce qu'il n'y a pas de restant
    // fait quelque chose ici avec a
}

Les prochaines leçons présententent les opérations logiques (comme ==) et les structures de contrôle (if, while, for, etc.) qui permettent d’utiliser des conditions comme celle-ci.

Incrémentation et décrémentation

Ces opérateurs simplifient des assignations où on modifie la valeur d’une variable de type int ou double par une quantité fixe.

int a = 5;
a++; // a vaut maintenant 6
a--; // a vaut maintenant 5
a += 3; // a vaut maintenant 8
a -= 2; // a vaut maintenant 6

Concaténation de texte

L’opérateur + est surchargé en Java; il a différentes définitions selon le type des opérandes.

• Si les deux opérandes sont numériques, + fait une addition
• Si au moins une des opérandes est du texte, + fait une concaténation. C’est-à-dire qu’il colle les deux représentations texte des valeurs pour donner un seul texte combiné.

Exemples :

• "Bon" + "jour" donne "Bonjour"
• "Trois = " + 3 donne "Trois = 3"

  le int 3 est converti en String "3" avant d’être collé au texte

• "4" + 3 donne "43"

  Parce que "4" est du texte, l’opérateur + colle les deux représentations texte des valeurs au lieu de faire une addition.

Classe Math

N’oubliez pas que la classe Math contient plusieurs méthodes pour faire des opérations mathématiques plus complexes. Par exemple : Math.pow(), Math.sqrt(), Math.abs(), Math.sin(), etc.

Formes

Début / fin	Traitement	Entrée / Sortie

Étiquettes

Dans chaque forme il y a du texte. À part les symboles pour le début et la fin, les étiquettes commencent par un verbe suivi par une description, p. ex.“ Assigner 3 à num“.

Traitements

• Assigner une valeur à une variable
• Modifier une variable
• Faire un calcul
• Combiner du texte (concaténation)

Entrées / sorties

Les entrées représentent de l’information qui n’est pas définie dans l’algorithme mais à laquelle on peut accéder :

• Réponses de l’utilisateur
• Contenu de fichiers
• Lecture d’instruments

Les sorties représentent de l’information qui est exportée de l’algorithme :

• Valeurs affichées à l’écran
• Valeurs envoyées à une imprimante
• Valeurs enregistrées dans un fichier

Exemple “Bonjour le monde”

void main() {
    System.out.println("Bonjour, le monde!");
}

Exemple avec traitement

void main() {
    int num = 3;
    System.out.println(num * 10);
}

Ce programme afficherait la valeur 30 parce que num est définie comme 3 et on affiche num * 10 soit 3 * 10.

Une version plus réaliste de ce programme serait le suivant, avec saisie de la valeur de l’utilisateur :

import java.util.*;

void main() {
    Scanner in = new Scanner(System.in);
    // saisir la valeur, incluant l'invite de commande
    System.out.print("Entrez un nombre entier > ");
    int num = in.nextInt();
    // afficher le résultat
    System.out.println(num * 10);
}

Produire ces diagrammes

On peut produire ces diagrammes avec toute sorte de logiciels de dessin, comme :

• Google Dessin (seul ou intégré dans Docs ou Slides)
• Lucidchart
• Draw.io (drawio.com, app.diagrams.net)
• etc.

Extension VS Code

Il y a une extension VS Code pour Draw.io qui nous permet de créer des diagrammes dans l’éditeur, alors c’est souvent le plus efficace dans ce cours. C’est Draw.io Integration par Henning Deitrichs (~2 million de téléchargements). Avec cette extension (ou son équivalent sur le web) :

• C’est bon de choisir le format .drawio.png qui produit une image affichable directement dans des documents mais également éditable dans le logiciel.
• Toutes les formes utilisées pour le diagramme de flux se trouvent dans la section Général : ovale, rectangle, parallélogramme.
• On trace des flèches directement de la première forme à la deuxième. On a même le choix de commencer une flèche à partir d’une forme et choisir parmi quelques formes pour la destination sans passer par le menu.
• On clique sur un objet pour y ajouter du texte en tapant.

Séquence

La structure représentée par ces diagrammes est la structure fondamentale de tout programme qui s’exécute sur un ordinateur classique : une simple séquence. Dans cette structure, toutes les instructions se succèdent dans l’ordre du début jusqu’à la fin.

Un programme modulaire

Au début d’une tâche de programmation, on peut penser à notre solution comme un seul programme :

Par contre, on a souvent à faire au moins les trois étapes suivantes dans chaque programme qui interagit avec un utilisateur :

Si on connaît les détails de la tâche, on peut probablement diviser l’étape “Actions” encore selon les différentes tâches à réaliser :

Ce qu’on vient de faire est une décomposition du problème selon une approche descendante : on a pris un problème complexe et on l’a divisé en plus petits problèmes. Chaque petit problème est plus facile à résoudre que le problème global.

En programmation, on peut utiliser des méthodes pour résoudre chaque petit problème.

Un projet modulaire

On peut appliquer la même approche à la planification d’un projet dans n’importe quelle domaine.

Par exemple, un projet de recherche qui commence comme ceci :

Peut être décomposé en étapes comme ceci :

Voyant les étapes exposées comme ça, on peut mieux prévoir le temps nécessaire ou mieux s’organiser en équipe pour répartir les tâches.

Diagramme de dépendances

Certaines étapes ou modules d’un projet ne peuvent pas se faire sans que d’autres ne soient complétées. Un diagramme de dépendances illustre ces relations entre les modules.

On a déjà vu un diagramme de flux (qui montre la séquence des étapes) dans une leçon précédente. Un diagramme de dépendances est différent sur plusieurs points :

• Il ne montre pas ce qui se passe dans les détails mais identifie seulement les “modules” ou les “étapes” du projet.
• Il ne montre pas l’ordre d’exécution mais plutôt quelle étape dépend de quelle autre étape.

Le projet de recherche

Ici on compare les deux types de diagrammes pour le projet de recherche :

Avez-vous remarqué que la direction des flèches est inversée entre les deux diagrammes? C’est parce que le diagramme de dépendances commence avec le projet complet et regarde ce qui est nécessaire pour le rendre… réponse : que le projet soit rédigé. Et pour rédiger le projet, on a besoin de quoi?… réponse : les notes de recherche. Et pour faire les notes, on a besoin de quoi?… réponse : les sources d’information, etc. Ici les flèches indiquent les dépendances. Si on a une flèche de A vers B, ça veut dire que A dépend de B.

Dans le diagramme de flux, c’est l’opposé : on commence avec la première étape à réaliser. Ensuite, on regarde ce qui doit se passer après. Et après, et après, jusqu’à la fin du projet. Si on a une flèche de A vers B, ça veut dire que B est l’étape qui suit A.

C’est naturel que les flèches soient inversées entre les deux diagrammes. Si A dépend de B, alors A doit attendre que B soit fait. Cela nous donne :

• flèche de dépendance de A vers B
• flèche de séquence de B vers A

Le programme modulaire

Maintenant on fait le même exercice pour le programme modulaire :

Ici la relation entre les deux types de diagrammes n’est pas aussi claire. Entre autres, on ne peut pas regarder le diagramme de flux et savoir, avec certitude, si une étape dépend de l’étape précédante ou non. De l’autre côté, il n’y a aucun lien direct entre les “modules” Accueil, Actions et Au revoir dans le diagramme de dépendances alors rien ne suggère une séquence sauf notre expérience qu’un accueil vient avant un au revoir.

En général, on produit chaque type de diagramme indépendamment en appliquant les concepts de chacun :

• le diagramme de flux montre toujours la séquence d’exécution des étapes;
• le diagramme de dépendances montre les dépendances entre les différents modules.

Chaînes d’appels

Dans les diagrammes de dépendances, les modules sont liées dans des chaînes de dépendance. Les modules en programmation sont souvent des méthodes. Dans ce contexte on parle de chaînes d’appels, parce qu’une méthode doit appeller les autres méthodes qu’elle a besoin d’utiliser.

Si une méthode à plusieurs dépendances, il y a des branches qui se forment dans le diagramme, créant autant de chaînes d’appels que de branches. Notre exemple de programme modulaire a donc ces cinq chaînes d’appels car la méthode Actions dépend de trois méthodes, triplant le nombre de chaînes passant par elle :

Au début d’une chaîne d’appels (le bloc avec aucune flèche entrante), on a la méthode dépendante d’une autre. À la fin d’une chaîne d’appels, on a une méthode qui n’a pas de dépendances (aucune flèche sortante), qui est indépendante.

Si on veut profiter pleinement de la décomposition (plusieurs problèmes plus simples au lieu d’un grand problème), on ne peut pas commencer par écrire les instructions pour les méthodes dépendantes car il faudra aussi immédiatement écrire les instructions pour toutes les autres méthodes plus bas dans la chaîne d’appels (la première méthode dépend d’eux)… on n’a pas vraiment simplifié notre tâche! Par contre, si on commence avec une des méthodes indépendantes, on peut écrire le code juste pour cette méthode et la tester. On a juste un petit problème à résoudre. Ensuite, on peut soit choisir une autre méthode indépendante à faire ou bien la prochaine méthode plus haut dans la chaîne d’appels. Dans chaque cas, on reste avec juste un petit problème à résoudre dans l’immédiat. Mais peu à peu, tous les modules du projet se réalisent.

Refactoriser - quand on a déjà tout écrit

Parfois on n’a pas prévu découper notre programme en plus petites méthodes, mais la taille du programme ou sa complexité ou le besoin de réutiliser plusieurs fois le même code nous pousse à le faire. Réorganiser le code sans changer son comportement s’appelle refactoriser. Il n’y a pas de planification, juste un besoin pressant pour la décomposition, pour la création de modules.

La plupart du temps, surtout en commençant à programmer, c’est dur de savoir quand quelque chose sera trop complexe avant de l’avoir écrit, alors la refactorisation est souvent ce qui motive les premières expériences avec le code modulaire.

Le code modulaire

Commençons avec un exemple simple¹ d’un programme décomposé, d’un programme modulaire.

Fichier : MainClass.java

void main() {
    welcome();
    doStuff();
    bye();
}

void welcome() {
    System.out.println("Bienvenue dans mon programme!");
}

void doStuff() {
    System.out.println("On fait des choses utiles ici...");
}

void bye() {
    System.out.println("Bye!");
}

Dans ce programme, comme dans tout programme Java, le programme principal est dans la méthode main. Dans ce cas-ci, le programme principal est très simple. Il appelle trois autres méthodes, welcome, doStuff et bye. On comprend très bien la structure globale du programme. Par la suite, tous les détails du programme se trouvent dans les méthodes individuelles appelées par main. Même si ces détails devenaient plus complexes, la méthode main resterait simple et facile à lire.

Le diagramme de flux

Le même programme est représenté ci-dessous dans un diagramme de flux.

Notez qu’il y a plusieurs séquences d’instructions distinctes dans le diagramme de flux : une pour chaque méthode.

L’algorithme commence toujours avec l’ovale “Début” et se termine avec l’ovale “Fin”. Par contre, on a maintenant un nouveau type de bloc dans le diagramme - un appel de procédure :

Ce bloc envoie l’exécution du programme à la séquence d’instructions qui commence par le nom inscrit dans le bloc. Quand la séquence d’instructions de la méthode appelée est terminée, l’exécution est retournée au point de l’appel et continue le long des flèches.

On voit aussi que les ovales de début et de fin sont légèrement différents pour les procédures :

• le mot “Début” est remplacé par le nom de la méthode
• le mot “Fin” est remplacé par “Fin de [nom de la méthode]” ou “Retourne”

Tracer la séquence d’exécution programme

Chaque appel d’une méthode envoie l’exécution du programme à la signature de la méthode appelée et à travers ses instructions. Quand la méthode appelée se termine, l’exécution est retournée au point de l’appel pour continuer avec le reste du programme.

On peut le voir et le représenter comme suit.

À partir du code

On peut utiliser l’outil Python Tutor pour visualiser l’exécution du programme étape par étape afin de mieux comprendre la mécanique d’appel et de retour de méthodes.

Notez que le code est logiquement identique à celui ci-dessus mais que la version de Java disponible (Java 8) ne permet pas les simplifications de la syntaxe qu’on a avec Java 22. On a donc la déclaration explicite d’une classe et les mots clés static et public pour les méthodes.

Sans un tel outil, on peut tracer manuellement l’éxecution avec un diagramme de séquence d’exécution, soit :

• une liste des numéros de ligne exécutés dans l’ordre d’exécution;
• on indente vers la droite avec une flèche pour indiquer un appel de méthode et
• on revient à gauche avec une autre flèche pour indiquer le retour de la méthode.

Pour notre version de MainClass.java (avec la syntaxe simplifiée), le diagramme de séquence d’exécution serait :

1
2 -> 7  
     8
2 <- 9 
3 -> 11 
     12
3 <- 13 
4 -> 15 
     16
4 <- 17 
5 

2 -> 7

3 -> 11

4 -> 15

2 <- 9

3 <- 13

4 <- 17

Notez que l’appel et le retour reviennent à la même ligne dans le diagramme de séquence, soit 2 appel welcome et welcome retourne à 2, etc.

Dans Python Tutor, on sautait les lignes de signature durant l’appel et la ligne appelante lors du retour. C’est parce que nos procédures n’ont pas de paramètres et ne retournent pas de valeur en se terminant alors il n’y avait rien à visualiser pour ces lignes. On voit les paramètres et les valeurs de retour dans une prochaine leçon.

Notez aussi que durant l’exécution des méthodes appelées, les numéros de ligne sont identées au même niveau que la signature de la méthode afin de distinguer ces instructions des instructions de la méthode appelante.

À partir du diagramme de flux

On peut aussi tracer la séquence d’exécution à partir du diagramme de flux. On y ajoute manuellement plus de flèches!

Encore une fois, comme avec le diagramme de séquence d’exécution, l’appel et le retour se font à partir du même bloc dans le diagramme de flux.

Exemples connus de méthodes avec valeur de retour

Vous connaissez déjà quelques méthodes avec valeur de retour :

• celles pour la classe Scanner - comme nextInt(), nextDouble(), nextLine()
• celles pour la classe Math - comme Math.pow() et Math.sqrt()
• celles pour la classe String - comme length() et toUpperCase()

Exemples connus de méthodes sans valeur de retour

Les méthodes sans valeur de retour ont le type de retour void. Elles sont souvent utilisées pour des actions qui modifient directement l’état de la mémoire du programme ou qui font des sorties (comme afficher à l’écran ou enregistrer dans un fichier).

Ceux que vous connaissez le mieux sont les méthodes :

• main - qui ne retourne rien au système d’exploitation : sa fin est la fin du programme
• println, print et printf de System.out - qui affichent des messages à la console

Il y a quelques indices que ces méthodes ne retournent pas de valeur :

1. On ne déclare aucune variable pour recevoir la valeur retourné (car il n’y en a pas)
2. Le mot-clé void précède immédiatment le nom de la méthode dans la déclaration, p. ex. void main() ou sa version plus standard public static void main(String[] args)

Écrire nos propres méthodes avec valeur de retour

Avec la décomposition, on a vu que c’est souvent utile de diviser un programme complet et plus petits sous-problèmes. Chacun serait une (ou plusieurs) méthode(s). Il faut alors savoir comment les déclarer dans nos programmes.

Signature de méthode

L’exemple de la leçon précédente, dans MainClass.java, montre comment déclarer les méthodes sans valeur de retour - comme void main() et void welcome(). C’est la même chose pour les méthodes avec valeur de retour, sauf qu’on remplace void par le type de retour désiré. Le format général est alors :

[type de retour] [nom de la méthode]() {
    // bloc de code
}

Corps de méthode

Les corps de méthode, les blocs de code entre les accolades {}, seront différents selon si le type est void (pas de valeur de retour) ou non.

void [nom de la méthode]() {
    // instructions
} // retour implicite à l'accolade fermante

void [nom de la méthode]() {
    // autres instructions
    return; // retour explicite sans valeur de retour
}

[type de retour] [nom de la méthode]() {
    // autres instructions
    return [valeur]; // retour explicite où valeur est du type de retour
}

Deux exemples

Le programme ci-dessous montre un exemple très simple (et banal) de deux méthodes avec valeur de retour.

Fichier : BasicReturn.java

String getName() {
    return "Dave3000";
}

int getMeaningOfLife() {
    return 42;
}

void main() {
    String name = getName();
    System.out.println("Bonjour, je m'appelle " + name);
    System.out.println("J'ai aussi un chiffre très important pour vous : " + getMeaningOfLife());
}

Remarquez qu’on a placé la méthode main à la fin du fichier. C’est possible de le faire, et souvent très naturel de le faire si vous avez planifié les différents modules de votre programme avant de commencer. Les développeurs tendent à mettre la méthode main soit au début, soit à la fin du fichier pour faciliter la lecture du programme.

Diagramme de flux pour une méthode avec valeur de retour

Ce qu’on a déjà appris sur les diagrammes de flux pour les méthodes s’applique, mais il faut maintenant :

1. Indiquer dans la définition de la méthode ce qui sera retourné
2. Utiliser dans l’algorithme principal ce qui est retourné suite à l’appel de la méthode

Voici le diagramme de flux pour le programme BasicReturn.java :

Le diagramme de flux nous aide à mieux voir la mécanique appel-retour. On voit quelque chose là qui n’est pas aussi apparent dans le code. Dans l’algorithme principal du diagramme de flux nous devons utiliser au moins deux instructions, soit :

• une pour l’appel de la méthode et
• une pour utiliser la valeur de retour.

Dans le code, tout ça se fait normalement sur la même ligne de code, en combinant plusieurs expressions (p. ex. : assignation et appel, affichage et appel) dans une seule instruction.

Notez aussi que l’appel précède toujours l’autre instruction dans le diagramme (comme durant l’exécution réelle du programme). Dans le code, ce n’est pas évident que ce soit le cas, car l’appel se trouve plus à gauche que l’autre instruction.

Structure générale pour l’utilisation d’une méthode avec valeur de retour

Tracer la séquence d’exécution

Peu importe si main se trouve au début ou à la fin du fichier, on commence toujours le programme à main. À part le déplacement de main, il n’y a rien de nouveau dans le diagramme de séquence d’exécution, sauf que :

• le fait de retourner à la même ligne que l’appel devrait faire plus de sens;
• on n’arrive pas à la ligne de l’accolade fermante s’il y a une instruction return; l’accolade fermante est un return implicite dans les autres cas.

9
10 -> 1
10 <- 2
11
12 -> 5
12 <- 6
13

Pour getName

10 -> 1

10 <- 2

Pour getMeaningOfLife

12 -> 5

12 <- 6

Diagramme de dépendances

Encore, pour ce diagramme on doit commencer à main et regarder quelles méthodes il appelle.

La nouveauté est qu’avec des valeurs de retour, on inclut le type de retour dans le bloc de la méthode. Plusieurs styles sont possibles, mais deux qui sont cohérents avec ce que nous voyons sont :

• [nom de la méthode]() -> [type de retour] … la flèche est semblable à ce qu’on utilise dans le diagramme de séquence d’exécution
• [nom de la méthode]() : [type de retour] … ce format ressemble à ce que vous voyez si vous ouvrez la panneau Structure (Outline en anglais) de VS Code.

Voici donc une version possible de ce diagramme. L’ajout des valeurs de retour nous indique que main dépend des valeurs String et int produites par les deux méthodes qu’il appelle.

Rôle des paramètres

Les paramètres rendent les méthodes plus flexibles. Leur code peut fonctionner avec différentes informations comme entrées, alors au lieu d’écrire une méthode pour chaque entrée possible, on a la possibilité de fournir cette information durant l’appel.

C’est un concept très puissant.

En mathématiques, vous avez quelque chose de similaire avec les fonctions, p. ex. : f(x) = x^2. Cette fonction nous donne le carré de x. x est donc un paramètre de f. En passant différentes valeur de x à la fonction f(x) on obtient différents résultats.

Exemples connus de méthodes avec paramètres

Vous connaissez déjà quelques méthodes avec des paramètres :

• toutes les formes de print“ :
  • System.out.print("Votre réponse > ")
  • System.out.println("Bonjour " + name + "!")
  • System.out.printf("%S\n", "david")
• créer un nouveau Scanner avec : new Scanner(System.in)
• spécifier le format de nombres sur un objet Scanner : .useLocale(Locale.CANADA_FRENCH)
• faire des calculs avec la classe Math : Math.pow(2, 3), Math.sqrt(9), Math.abs(-5)
• certaines opérations sur des objets String : comme .charAt(0)

Exemples connus de méthodes sans paramètres

Les méthodes sans paramètres sont appelées avec des parenthèses vides.

Ceux que vous connaissez le mieux sont les méthodes de Scanner :

• .next(), .nextLine(), .close()

On a aussi vu quelques méthodes de traitement des String :

• .length(), .toUpperCase()

Notez que ces méthodes commencent avec un point . car ils s’appelent suite au nom d’un objet. Elles utilisent l’information qui est déjà dans l’objet (le Scanner, le String) pour faire ce qu’ils ont à faire et n’ont donc pas besoin de paramètres.

Écrire nos propres méthodes avec paramètres

On a déjà vus la structure générale de la déclaration d’une méthode. Ici on ajoute un dernier détail : la liste de paramètres.

Signature de méthode

Voici le gabarit complet pour la déclaration d’une méthode, incluant maintenant les paramètres :

[type de retour] [nom de la méthode] ( [liste de paramètres] ) {
    // bloc de code,
    // avec instruction `return` au besoin
}

La liste de paramètres a le format suivant, soit une liste de déclarations de variables :

type1 nom1, type2 nom2, type3 nom3, ...

où les types sont ceux qu’on connaît (int, double, String, Scanner, etc.) et les noms sont un nom de variable selon les règles et les conventions qu’on utilise déjà.

Corps de méthode

Le but de déclarer des paramètres est d’avoir des informations qu’on peut manipuler dans le code de la méthode. On ne connaît pas encore la valeur de ces informations, mais on connaît leur type (à cause de la signature). On peut alors travailler librement avec ces variables dans le code comme on le ferait avec n’importe quel autre variable du même type.

Appeller des méthodes avec paramètres

Quand on appelle une méthode qui a déclaré des paramètres dans sa signature, nous devons fournir des informations du type approprié entre les parenthèses. Sinon le programme nous signale une erreur de syntaxe.

Les informations passées durant l’appel s’appellent des arguments.

Par exemple, si nous avons déclaré cette méthode en déclarant un paramètre String name :

void greetWithName(String name) {
    System.out.println("Bonjour " + name + "!");
}

Il faut absolument placer une valeur de type String entre les parenthèses durant l’appel, p. ex. :

void main(){
    greetWithName("Jean");
    greetWithName("Lucie");
    greetWithName(); // erreur de syntaxe à cette ligne
}

Différences entre paramètres et arguments

Comment ça marche? Le diagramme de flux

Comme le mécanisme appel-retour était plus explicite dans le diagramme de flux que dans le code, le mécanisme argument-appel l’est aussi.

Regardons donc le diagramme de flux pour l’exemple greetWithName ci-dessus.

Le diagramme de flux nous aide à mieux voir la mécanique argument-paramètre. On voit quelque chose là qui n’est pas aussi apparent dans le code.

Dans l’algorithme pour la méthode :

• la première instruction assigne la valeur reçue à une variable (dans cette exemple, name), ce qui correspond au paramètre de la méthode
• le reste du code est définie selon ce nom de variable

Dans l’algorithme principal du diagramme :

• l’instruction d’appel inclut une information à passer à la méthode, ce qui correspond à l’argument

Dans le code Java pour la méthode greetWithName, l’assignation de la valeur reçue est masquée / implicite.

Dans le diagramme de flux, on doit le mentionner explicitement.

Structure générale pour l’utilisation d’une méthode avec paramètre

Deux exemples

Le programme ci-dessous montre un exemple simple (et banal) de deux méthodes avec des paramètres.

Fichier : BasicParam.java

void greetWithName(String name) {
    System.out.println("Bonjour " + name + "!");
}

int product(int a, int b) {
    return a * b;
}

void main() {
    String david = "David";
    int x = 3;
    int b = 5;
    greetWithName(david);
    System.out.println(product(x, b));
}

Remarquez qu’on a encore placé la méthode main à la fin du fichier.

Tracer la séquence d’exécution

On commence toujours le programme à main. Le diagramme de séquence d’appel pour le programme dans BasicParam.java serait :

9
10
11
12
13 -> 1
      2
13 <- 3
14 -> 5
14 <- 6
15

Pour greetWithName

13 -> 1

13 <- 3

Pour product

14 -> 5

14 <- 6

Diagramme de dépendances

On commence à main et regarde quelles méthodes il appelle.

La nouveauté est qu’avec les paramètres, on inclut le type des chaque paramètre dans le bloc de la méthode entre des parenthèses. On peut trouvez cette information dans la signature de chaque méthode mais aussi dans la structure du document.

• [nom de la méthode]( [liste des types de paramètres] ) : [type de retour]

  

Voici donc une version possible de ce diagramme. L’ajout des types des paramètres nous indique que chaque méthode dépend sur main pour leur fournir les valeurs String et int pour leurs paramètres. On voit aussi que main devra géré la valeur int retournée par la méthode product.

Portée des variables

La portée d’une variable est synonyme de sa visibilité : jusqu’à quels endroits dans le code est-ce qu’on peut “voir” cette variable (la nommer sans erreur de syntaxe)?

Les variables globales sont visibles partout dans un programme¹. Elles sont déclarées à l’extérieur des méthodes et on peut les lire et les modifier dans toutes les méthodes du programme.

C’est un avantage parce qu’on a pas besoin d’échanger cette information entre les méthodes via des paramètres ou des valeurs de retour.

C’est un désavantage parce n’importe quelle partie de notre code peut modifier cette information, ce qui peut rendre le code difficile à corriger, briser la modularité du code (les sous-problèmes sont maintenant fusionnés autour de l’information partagée) ou introduire des problèmes de sécurité (modifications possibles au-delà des intentions originales).

Les variables locales sont seulement visibles dans la méthode où elles sont définies. Les paramètres et les variables définies dans le corps d’une méthode sont des variables locales. Jusqu’à présent, nous avons seulement utilisé des variables locales dans nos programmes.

Les avantages des variables locales sont que : l’information existe seulement à l’endroit où elle sera directement utile et plusieurs variables dans un programme peuvent avoir le même nom sans interférence parce que leurs portées ne se croisent pas.

Le désavantage est que pour partager l’information locale à une autre méthode, il faut “passer des messages” avec des arguments/paramètres et des valeurs de retour. Cela peut parfois rendre la liste des paramètres assez longue que c’est difficile à se rappeler quel paramètre va à quelle position.

---------------fichier------------------

déclaration de variable globale


méthode() {

    déclaration de variable locale

}


méthode( les paramètres sont des variable locales ) {

}

----------------------------------------

Variables globales

C’est rarement une bonne idée d’utiliser des variables globales parce que le code devient beaucoup plus dur à déboguer. Mais il y a quelques cas où c’est une solution bien adaptée :

La valeur est constante et requise par plusieurs méthodes

On peut alors déclarer une constante globale en le préfixant avec le mot-clé final et en appliquant la convention du nom en majuscules. Les Scanner pour la console, les codes de couleur ANSI et les structures de données (à venir dans une prochaine section du cours) sont des exemples de bons candidats de constantes globales.

Dans ce cas, le fait que la valeur soit constante élimine la possibilité de modification inappropriée et la portée globale peut réduire la complexité et la répétitivité des déclarations et appels de méthodes.

La variable représente un état du programme que plusieurs méthodes doivent consulter ou peuvent modifier

Plusieurs informations dans un jeu tombent dans cette catégorie. Si ces variables n’étaient pas globales, la liste des paramètres pour la plupart des méthodes deviendrait ingérable. De plus, la restriction avec Java d’une seule valeur de retour rend l’exportation de plus qu’une modification à ces valeurs, si pas impossible, du moins très complexe. Cette complexité additionnelle rendrait le code plus dur à lire, à déboguer et à modifier. Les risques liés aux variables globales sont alors moindre que les risques avec l’autre approche.

Exemples de constantes globales

Fichier GlobalScanner.java

import java.util.*;

final Scanner CONSOLE = new Scanner(System.in); // visible globalement

void main() {
    // final Scanner CONSOLE = new Scanner(System.in); // ne serait pas visible dans getName ni getInteger
    String name = getName();
    int age = getInteger("age");

    System.out.printf("%s a %d ans.\n", name, age);
}

String getName() {
    System.out.print("Quel est votre nom? > ");
    return CONSOLE.nextLine();
}

int getInteger(String what) {
    System.out.printf("Entrez un nombre entier pour votre %s > ", what);
    int result = CONSOLE.nextInt(); // pour consommer la valeur
    CONSOLE.nextLine(); // pour consommer le retour de ligne aussi
    return result;
}

Ici le Scanner pour la console est utilisée dans plusieurs méthodes et ne change pas de valeur (réfère toujours à System.in), alors c’est un bon candidat de constant globale.

Notez que la déclaration commence avec final disant à Java que cette valeur ne peut jamais changer durant l’exécution. Notez aussi qu’on a écrit le nom en majuscules afin de mieux le repérer comme constante.

Fichier GlobalColorCodes.java

import java.util.*;

final String RED = "\033[0;31m";
final String GREEN = "\033[0;32m";
final String YELLOW = "\033[0;33m";
final String RESET = "\033[0m";

void printRed(String text) {
   System.out.println(RED + text + RESET);
}

void printGreen(String text) {
   System.out.println(GREEN + text + RESET);
}

void printYellow(String text) {
   System.out.println(YELLOW + text + RESET);
}

void main() {
    printRed("Ceci est un message d'erreur!");
    printGreen("Ceci est un message de succès!");
    printYellow("Ceci est un avertissement");

    System.out.printf("%sCe texte%s est en %ssurbrillance%s%s!!!%s", 
            GREEN, RESET, YELLOW, RESET, RED, RESET);
}

Ici on a plusieurs constantes globales pour les différents codes de couleur pour le texte à la console. Ces constantes sont utilisées dans les différentes méthodes, incluant main qui fait un usage sur mesure pour la dernière phrase.

Variables globales d’état

Voici un exemple banal pour quelques variables globales pour un jeu.

Fichier : GlobalGameState.java

int lives = 3;
int xp = 0;
boolean hasWeapon = true;
boolean hasHorse = true;

void diedInBattle() {
    xp += 5;
    lives--;
    hasWeapon = false;
    System.out.println("Vous êtes mort au combat et avez perdu votre arme!");
}

void diedWhileRiding() {
    xp += 2;
    lives--;
    hasHorse = false;
    System.out.println("Vous êtes mort en tombant de votre cheval!");
}

void showStats() {
    System.out.println("Vies : " + lives);
    System.out.println("Points d'expérience : " + xp);
    System.out.println("Vous avez une arme : " + hasWeapon);
    System.out.println("Vous avez un cheval : " + hasHorse);
}

void main() {
    showStats();
    diedInBattle();
    showStats();
    diedWhileRiding();
    showStats();
}

Priorité de nom selon la portée

Une des caractéristiques d’un programme avec différentes portées de variables est que le même nom peut être déclaré à plusieurs endroits sans conflits en autant que leurs portées soient différentes.

S’il y a deux variables du même type et du même nom, mais une est globale est l’autre est locale, la version locale sera toujours utilisée en priorité.

Voici quelques exemples courts pour illustrer la chose.

/* Globale versus locale */

String name = "Steve";

void main() {
    String name = "Angelica";
    name = "Naomi";
    System.out.println(name);
}

/* Locale versus locale */

void main() {
    String name = "Angelica";
    System.out.println(rename(name));
    System.out.println(name);
}

String rename(String name) {
    name = "Demonica";
    return name;
}

Quelques exemples d’erreur (de conflit) de portée

Variable inaccessible

void isolated() {
    int answer = 7;
}

void main() {
    System.out.println(answer); // erreur "cannot find symbol"
}

Ici, answer est locale à la méthode isolated, alors il n’est pas visible dans main, contrairement à si cette variable avait été déclarée globalement, à l’extérieure d’une méthode.

int answer = 7; // déclaration globale

void main() {
    System.out.println(answer); // answer est visible
}

Déclaration dupliquée

String thing(String t) {
    String t = t + "2"; // erreur "duplicate local variable"
    return t;
}

void main() {
    System.out.println(thing("thing"));
}

Ici, dans la méthode thing on déclare déjà un paramètre String t. Alors quand on déclare une autre variable locale du même nom à la ligne 2, Java nous indique une erreur. Si l’intention était de simplement modifier la valeur reçue dans le paramètre alors on peut réécrire la ligne 2 comme ceci :

String thing(String t) {
    t = t + "2"; // référence valide au paramètre t déjà déclarée
    return t;
}

void main() {
    System.out.println(thing("thing"));
}

La différence est que la ligne 2 n’est plus une déclaration d’une nouvelle variable. Elle est désormais une référence à la variable déjà déclarée dans la liste de paramètres.

Pourquoi faire des tests unitaires?

Un programme devient très rapidement large et complexe. On utilise déjà la décomposition pour gérer la complexité et la taille du programme : elle nous permet de résoudre une série de petits problèmes.

Par contre, l’avantage de la décomposition est largement gaspillé si on ne vérifie pas le bon fonctionnement de chaque méthode - chaque morceau du problème décomposé - avant de l’intégrer dans la méthode plus haut dans la chaîne d’appels. La raison est la suivante : s’il y a une erreur dans une méthode qu’on n’a pas testé mais on l’intègre sans connaissance dans une autre méthode, lorsque on exécute éventuellement le programme, on ne sait pas si l’erreur vient de la méthode appelante ou de la méthode appelée. Ce problème explose avec le nombre d’intégrations de méthodes qu’on fait avant de tester.

Avec les tests unitaires, on peut isoler les erreurs à une seule méthode, limitant la quantité de code à vérifier pour corriger l’erreur. Le but est de tester chaque méthode et de s’assurer de son fonctionnement avant de l’intégrer dans une autre méthode. Ainsi, si une erreur se produit, on sait qu’elle vient du plus récent code qu’on a écrit et non des autres méthodes qui existent déjà.

Un autre avantage des tests unitaires formelles, comme ceux avec le framework JUnit, est que si on modifie le programme, on peut relancer tous les tests que nous avons déjà écrits pour s’assurer que les modifications n’ont pas cassé quelque chose qui fonctionnait déjà.

Cas de tests

En faisant un test unitaire, on doit savoir quel comportement est attendu de notre méthode, soit qu’est-ce qui constitue un résultat acceptable. Les cas de tests sont simplement la description de ces comportements attendus pour une méthode donnée. C’est, en fait, la partie la plus importante de l’écriture des tests unitaires. Si on ne sait pas ce qu’on attend de notre méthode, on ne peut pas écrire de tests pour vérifier si la méthode fonctionne correctement.

Déterminer quels sont les cas de test importants est un art. Il faut trouver un équilibre entre tester tous les cas possibles et tester seulement les cas les plus importants. Voici quelques pistes pour déterminer les cas de test pour une méthode :

• Cas de test limites : les cas de test qui couvrent les valeurs aux limites de ce qui serait normalement attendu. Par exemple, si on doit donner une note entre 0 et 100, on devrait tester avec 0 et 100. De même, si dans la zone des valeurs acceptés, il y a des limites pour différentes catégories, on devrait tester ces limites aussi. Par exemple, si la note de passage est de 50, on devrait tester avec 49 et 50.
• Cas de test invalides : si notre programme doit gérer la qualité des entrées, il faut aussi prévoir les cas de test qui couvrent les valeurs qui ne devraient pas être acceptées. Par exemple, si on doit donner une note entre 0 et 100, on devrait tester avec -1, 101, et des lettres.

Tableau de cas tests

Pour l’exemple précédent, soit d’une méthode qui calcule la moyenne de deux notes et retourne le résultat comme valeur de retour, on peut préparer le tableau de cas de test suivant :

On peut représenter ce même tableau comme commentaire de bloc ou comme javadoc dans la méthode de test unitaire, comme ceci :

/*
 * Test la méthode `average` pour les cas suivants :
 * - deux notes int valides : 80, 90 => 85.0
 * - deux notes double valides : 80.0, 90.0 => 85.0
 * - notes limites : 0, 100 => 50.0
 * - notes limites : 0, 0 => 0.0
 * - notes limites : 100, 100 => 100.0
 * - note négative : -1, 90 => -1.0 // une valeur drapeau pour signaler un résultat invalide
 * - note supérieur à 100 : 80, 101 => -1.0 // une valeur drapeau pour signaler un résultat invalide
 */

Approche naïve pour les tests unitaires

Sans utiliser des outils spécialisés, nous pouvons simplement lancer manuellement le programme après avoir ajouté une nouvelle méthode. Naturellement, on aura probablement appelé la méthode dans la logique globale du programme pour voir si elle fonctionne. Ça marche pour des programmes très simples mais c’est limité même dans ces cas :

1. S’il y a plusieur cas de test, on doit les exécuter un par un et comparer les résultats manuellement, possiblement en insérant des System.out.println() pour afficher les résultats qu’on aura à retirer plus tard. Cela est une tâche lourde et sujette à des erreurs.
2. Si plusieurs parties du programme doivent s’exécuter avant d’arriver à l’appel de la nouvelle méthode à tester, on doit passer à travers tout le programme pour chaque test. Cela est une perte de temps et d’énergie qui fait en sorte qu’on évite souvent de tester rigoureusement les méthodes.

Mieux mais sans les outils de test unitaire

Pour faire mieux que l’approche décrite ci-dessus, on peut tenter d’écrire des tests unitaires sans l’appui des outils, notamment parce que l’installation des outils peut être complexe et parce que ça nous évite d’apprendre comment utiliser les outils. En écrivant nos propres tests, on peut définitivement pallier aux deux problèmes soulevés ci-dessus :

• on peut inclure les cas de test dans notre code de test
• on peut inclure les comparaisons automatiques avec les résultats attendus dans notre code de test
• on peut exécuter les tests unitaires sans passer par la logique globale du programme

Par contre, tout ça exige la rédaction de beaucoup de code additionnel (avec l’introduction presque garantie de nouvelles erreurs). Et tout ce nouveau code est probablement mieux écrit et définitivement déjà validé dans les outils de test unitaire.

De plus, le code de test “maison” est le plus facile à écrire et à lancer dans la même classe que les méthodes à tester. Cela rend le code dans cette classe plus difficile à lire, sans parler de la méthode main qui peut commencer à ressembler à quelque chose comme ceci :

Fichier: MyGreatProgram.java

void main() {
    // tests unitaires
    // testMethod1(); // masqué derrière un commentaire pour ne pas l'exécuter
    // testMethod2();
    testMethod3();


    // logique globale du programme
    // ...
}

void method1() {
    // ... code qu'on veut utiliser dans le programme
}

void testMethod1() {
    // ... code pour tester la méthode qu'on veut utiliser dans le programme
}

// ... reste des méthodes de la classe

Approche standard pour les tests unitaires avec JUnit 4

En se servant des outils existants, comme JUnit :

• notre classe peut être écrite exactement comme on l’a décrit avec la décomposition du problème sans code additionnel,
• les tests peuvent être écrits plus succinctement avec le code fourni par JUnit,
• le lancement des tests est entièrement indépendant du lancement de notre programme et
• nous n’avons pas besoin de programmer comment afficher les résultats des tests parce que JUnit le fait pour nous.

L’utilisation de JUnit nous impose pour la première fois une structure de projet Java qui dépasse un seul fichier :

• le fichier pour notre code et
• un autre fichier pour les tests unitaires.

La section suivante décrit la modification qu’il faut apporter à nos programmes pour les tester avec JUnit.

int add(int a, int b) {
    return a + b;
}

void main() {
    System.out.println(add(1, 2));
}

class Calculator {
    int add(int a, int b) {
        return a + b;
    }

    void main() {
        System.out.println(add(1, 2));
    }
}

class Calculator {
    int add(int a, int b) {
        return a + b;
    }

    void main() {
        System.out.println(add(1, 2));
    }
}

Gabarits - code de démarrage pour vos tests unitaires avec JUnit

Votre responsabilité principale en lien avec les tests unitaires est la définition des cas de tests pour chaque méthode que vous écrivez.

Par contre, vous pouvez aussi apprendre comment implémenter les tests unitaires qui appliquent ces cas de test à vos méthodes. Pour vous aider, les exemples de tests unitaires ci-dessous vous donnent du bon code de démarrage pour quatre cas communs :

• un test d’égalité,
• un test d’entrée (avec un Scanner global),
• un test d’entrée (avec un Scanner local) et
• un test de sortie.

Selon la structure de vos méthodes, vous aurez probablement à combiner le code de tests différents, p. ex. d’égalité et d’entrée ou d’éntrée et de sortie pour avoir la bonne structure de test pour vos méthodes.

Structure de la classe de test

Voici un gabarit de base pour une classe de test unitaire où vous remplacerez “MyClassname” par le nom de la classe que vous testez. Vous pouvez ajouter autant de méthodes de test que nécessaire dans cette classe.

import static org.junit.Assert.*; // pour les méthodes de comparaison
import org.junit.Test; // pour l'annotation @Test et les outils associés

public class MyClassnameTest {

    // déclaration d'un objet de la classe à tester
    // p. ex. Calculator calc = new Calculator();

    @Test
    // déclaration d'une' méthode de test pour une méthode dans votre code

    @Test
    // déclaration d'une méthode de test pour une autre méthode dans votre code

}

Test d’égalité

Les tests d’égalité sont pour des méthodes qui retournent une valeur. On compare la valeur retournée par la méthode avec la valeur attendue.

class Calculator {
    // ... reste du code de la classe

    int add(int a, int b) {
        return a + b;
    }
}

import static org.junit.Assert.*; // ajoutez cette ligne pour les méthodes de comparaison

import org.junit.Test;

public class CalculatorTest {

    Calculator calc = new Calculator(); // ajoutez cette ligne pour faire référence à votre code

    @Test
    public void testAdd() {

    }
}

    @Test
    public void testAdd() {
        /*
         * Cas de tests pour int add(int, int)
         *
         * Descr.   Entrées  Sortie attendue
         * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
         * base     1, 2    3
         */

        assertEquals(3, calc.add(1,2));
    }

    @Test
    public void testAverage() {
        /*
         * Cas de tests pour double average(double, double) :
         *
         * Descr.   Entrées     Sortie attendue
         * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
         * base     80.0, 90.0  85.0
         */

        assertEquals(85.0, calc.average(80.0, 90.0), 0.1);
    }

assertEquals(85.0, calc.average(80.0, 90.0), 0.0001);

Test d’entrée

Pour tester une méthode qui sollicite des entrées de l’utilisateur via la console, on a deux options selon la façon dont le Scanner de la console est géré dans la classe du programme :

Scanner static et global	Scanner passé comme paramètre (Scanner local)

Dans le cas d’un Scanner global, parce que la vie de la variable est plus longue que la vie de la méthode, on doit s’assurer de rétablir sa valeur originale avant de quitter le test. Pour le faire, on doit s’assurer de copier sa valeur originale au début du test.

Pour le Scanner local, ces étapes sont éliminées, mais on doit s’assurer de passer le Scanner comme argument à la méthode à tester.

import java.util.Scanner;

class Calculator {

    /** Scanner global pour toutes les méthodes de la classe */
    Scanner console = new Scanner(System.in);

    // ... reste du code de la classe

    String getNameUsingGlobalScanner() {
        System.out.print("Entrez votre prénom > ");
        String name = console.next(); // utilise le Scanner global
        console.nextLine(); // jeter tout après le premier mot
        return name;
    }
}

    @Test
    public void testGetNameUsingGlobalScanner() {
        /*
         * Cas de test pour String getName() qui utilise un
         * Scanner déclaré globalement
         * 
         * Descr.           Entrée          Sortie attendue
         * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
         * normal           "david"         "david"
         * un caractère     "A"             "A"
         * plusieurs mots   "David Crowley" "David"
         */

        /* PRÉPARATION */

        // garder une référence au Scanner original de calc
        Scanner original = calc.console;

        // définir les cas de test
        String testInput = "david\n" +
                "A\n" +
                "David Crowley\n"; // les \n sont les `Entrée` de l'utilisateur

        // créer une source d'entrées qui contient nos cas de tests
        InputStream testStream = new ByteArrayInputStream(testInput.getBytes());

        // passer la nouvelle source d'entrées au Scanner de calc
        calc.console = new Scanner(testStream); 

        /* TESTS */
        
        assertEquals("david", calc.getNameUsingGlobalScanner());
        assertEquals("A", calc.getNameUsingGlobalScanner());
        assertEquals("David", calc.getNameUsingGlobalScanner());

        /* NETTOYAGE */

        // rediriger le Scanner global de calc à lire sa source originale
        calc.console = original;
    }

import static org.junit.Assert.*;

import java.io.*;   // ici
import java.util.*; // et ici

import org.junit.Test;

public class CalculatorTest {
    // ... reste du code de la classe

}

import java.util.Scanner;

class Calculator {
    String getName(Scanner in) {
        System.out.print("Entrez votre prénom > ");
        String name = in.next(); // fait référence au Scanner passé en paramètre
        in.nextLine(); // jeter tout après le premier mot
        return name;
    }

    void main() {
        Scanner console = new Scanner(System.in); // déclarer un Scanner local
        //... autre code
        String name = getName(console); // passer le Scanner local comme argument
        //... autre code
    }
}

    @Test
    public void testGetName() {
        /*
         * Cas de test pour String getName(Scanner)
         * 
         * Descr.           Entrée          Sortie attendue
         * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
         * normal           "david"         "david"
         * un caractère     "A"             "A"
         * plusieurs mots   "David Crowley" "David"
         */

        /* PRÉPARATION */

        // définir les cas de test
        String testInput = "david\n" +
                "A\n" +
                "David Crowley\n"; // les \n sont les `Entrée` de l'utilisateur

        // créer un Scanner qui lit nos entrées de test au lieu de l'entrée standard
        InputStream testStream = new ByteArrayInputStream(testInput.getBytes());
        Scanner testScanner = new Scanner(testStream);

        /* TESTS */

        assertEquals("david", calc.getName(testScanner));
        assertEquals("A", calc.getName(testScanner));
        assertEquals("David", calc.getName(testScanner));

        /* NETTOYAGE */

        // Le nouveau Scanner est détruit automatiquement à la fin de cette méthode
    }

import static org.junit.Assert.*;

import java.io.*;   // ici
import java.util.*; // et ici

import org.junit.Test;

public class CalculatorTest {
    // ... reste du code de la classe

}

Test de sortie

Les tests de sortie sont utiles pour les méthodes void qui passent leurs résultats à la console. On peut utiliser la redirection de la sortie standard pour capturer les messages affichés par la méthode et les comparer avec les messages attendus.

    void sayName(String name) {
        System.out.println("Bonjour " + name);
    }

    @Test
    public void testSayName() {
        /*
         * Cas de test pour void sayName(String)
         * 
         * Descr.           Entrée          Sortie attendue
         * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
         * normal           "David"         "Bonjour David"
         * un caractère     "A"             "Bonjour A"
         * plusieurs mots   "David Crowley" "Bonjour David Crowley"
         * 
         */

        /* PRÉPARATION */

        // garder une référence à la sortie standard originale
        PrintStream original = System.out;

        // rediriger la sortie standard vers un flux de sortie temporaire
        OutputStream outContent = new ByteArrayOutputStream();
        System.setOut(new PrintStream(outContent));
    
        /* TESTS */

        calc.sayName("David");
        calc.sayName("A");
        calc.sayName("David Crowley");

        String expectedOutput = "Bonjour David\nBonjour A\nBonjour David Crowley\n";

        assertEquals(expectedOutput, outContent.toString().replace("\r\n", "\n")); // le replace() est nécessaire sur Windows (encodage de fin de ligne différent)

        /* NETTOYAGE */

        // rétablir la sortie standard originale
        System.setOut(original);
    }

import static org.junit.Assert.*;

import java.io.*;   // ici

import org.junit.Test;

public class CalculatorTest {
    // ... reste du code de la classe

}

Les exemples complets

Vous pouvez voir le code complet pour les classes Calculator et CalculatorTest dans les fichiers Calculator.java et CalculatorTest.java.

Variables booléennes (type boolean)

L’expression booléenne la plus simple est une valeur littérale booléenne : soit true (vrai), soit false (faux). On peut utiliser ces valeurs littérales directement ou assignées à des variables, par exemple, boolean repeat = true;.

Une variable booléenne est pratique pour représenter l’état de quelque chose, par exemples : repeat ci-dessus qui peut indiqur s’il faut répéter une action ou non ou boolean isOn = true; qui peut représenter si une fonctionnalité est activée ou non. Ce type d’usage des valeurs booléennes s’appelle un drapeau. On peut regarder son état dans des conditions ou modifier son état dans le code, par exemple isOn = false; pour éteindre l’ampoule.

Opérations de comparaison

Un autre type d’expression booléenne est une opération de comparaison. Une opération de comparaison compare deux valeurs et retourne une valeur booléenne. Par exemple, x == y est une expression de comparaison qui retourne true si x est égal à y et false sinon. Les opérateurs de comparaison sont :

• == (égal),
• != (différent/pas égal),
• < (inférieur),
• <= (inférieur ou égal),
• > (supérieur)
• et >= (supérieur ou égal).

Voici quelques exemples à tester dans une session jshell :

5 == 5; // notez : comparer l'égalité utilise deux "=", soit "=="
5 != 5;
5 < 5;
5 <= 5;
5 > 5;
5 >= 5;

int x = 4; // notez : assigner utilise un seul "="
int y = 5;
x == y;
x != y;
x < y;
x <= y;
x > y;
x >= y;

Méthodes de comparaison

Il y a aussi des méthodes de comparaison, généralement utilisées pour comparer différents objets du même type. On doit utiliser une méthode de comparaison pour comparer des objets de type String. Par exemple, "abc".equals("abc") retourne true et "abc".equals("def") retourne false. Il y a quatre méthodes de comparaison pour les String :

• equals (égal), par exemple "abc".equals("abc")
• equalsIgnoreCase (égal, sans tenir compte de la casse), par exemple "abc".equalsIgnoreCase("ABC") retourne true
• compareTo (inférieur, égal ou supérieur), qui retourne une valeur négative si la première valeur est inférieur, zéro si les deux valeurs sont égales et une valeur positive si la première valeur est supérieure. Par exemple "abc".compareTo("def") retourne une valeur négative (-3).
• compareToIgnoreCase (inférieur, égal ou supérieur, sans tenir compte de la casse)

La raison pourquoi la comparaison directe d’objets comme des String ne fonctionne pas est expliquée dans le cours ICS4U. C’est en lien avec la représentation de ces valeurs en mémoire versus la façon dont les valeurs primitives (comme des int) sont représentées en mémoire.

Voici quelques exemples de comparaisons de String à tester dans une session jshell :

"abc".equals("abc");
"abc".equals("def");
"abc".equals("ABC");
"abc".equalsIgnoreCase("ABC");

"abc".compareTo("def"); // donne un chiffre
"abc".compareTo("def") == 0; // tester l'égalité (donne un booléen)
"abc".compareTo("def") < 0; // tester si "abc" est inférieur à "def"
"abc".compareTo("def") > 0; // tester si "abc" est supérieur à "def"

// La comparaison se fait à la base de la valeur Unicode des caractères
// et les majuscules sont AVANT les minuscules dans la table Unicode
"abc".compareTo("ABC"); // donne un chiffre positif
"abc".compareTo("ABC") > 0; // tester la supériorité (donne un booléen)
"abc".compareToIgnoreCase("ABC"); // donne un chiffre
"abc".compareToIgnoreCase("ABC") == 0; // tester l'égalité (donne un booléen)

Notez que pour utiliser les méthodes compareTo comme conditions, il faut utiliser le chiffre retourné par la méthode dans une expression de comparaison afin d’obtenir un résultat true ou false.

Opérateurs logiques - combiner des conditions

On peut combiner le résultat d’expressions booléennes avec les opérateurs logiques ET (&&) et OU (||). On peut aussi inverser le résultat d’une expression booléenne en le précédant avec l’opérateur PAS (!).

Comme avec d’autres opérateurs, il y a un ordre de priorité. L’opérateur PAS a la priorité la plus élevée, suivi de ET et, finalement, OU. On peut utiliser des parenthèses pour changer l’ordre d’évaluation.

Voici quelques exemples à tester dans une session jshell :

// exemples pour voir les opérateurs
true && true; // ET
true && false;
false && true;
false && false;
false || true; // OU
!true; // PAS
!false;
!true && true;
!(true && true); // effet des parenthèses

// exemples plus réalistes
int x = 5;
(x > 0) && (x < 10); // entre 0 et 10
(x < 0) || (x > 10); // en dehors de 0 à 10

// déterminer si je mange au restaurant utilisant deux variables booléennes
amHungry && restaurantOpen;

// l'équivalent de != pour la méthode de comparaison .equals()
!"abc".equals("def");

Sélection conditionnelle avec if et else

La sélection permet d’exécuter du code seulement si une condition est vraie. La condition est n’importe quelle expression booléenne, soit une expression qui s’évalue à true ou false :

if (condition) {
    // code à exécuter si la condition est vraie
}

On a aussi l’option d’exécuter du code si la condition est fausse en ajoutant un bloc else immédiatement après le bloc if :

if (condition) {
    // code à exécuter si la condition est vraie
} else {
    // code à exécuter si la condition est fausse
}

Plusieurs cas exclusifs avec else if

Si on a plusieurs cas exclusifs (des cas où seulement un cas peut être est vrai) à vérifier, on peut immédiatement déclarer un bloc if suivant le mot-clé else afin de poser la prochaine condition :

if (condition1) {
    // code à exécuter si la condition1 est vraie
} else if (condition2) {
    // code à exécuter si la condition2 est vraie
} else if (condition3) {
    // code à exécuter si la condition3 est vraie
} else {
    // code à exécuter si aucune des conditions précédentes n'est vraie
}

Cette façon d’enchaîner les conditions assure que seulement un bloc sera exécuté. Il faut donc faire attention de bien écrire les conditions afin de représenter tous les cas possibles et de ne pas en oublier. C’est un bon exemple de situation où faire des tests pour chaque cas, notamment les cas limites, est important.

Voici un exemple de code qui utilise plusieurs cas exclusifs dans le fichier LinkedConditions.java :

import java.util.*;

void main() {
    Scanner console = new Scanner(System.in);
    System.out.println("Quel est votre âge? ");
    int age = console.nextInt();

    if (age < 4) {
        System.out.println("Enfant préscolaire");
    } else if (age <= 11) {
        System.out.println("Enfant d'école élémentaire");
    } else if (age <= 14) {
        System.out.println("Adolescent d'école intermédiaire.");
    } else if (age <= 18) {
        System.out.println("Adolescent d'école secondaire.");
    } else {
        System.out.println("Adulte.");
    }
}

Enfant d'école élémentaire

...
6
7
8
10
12
14
15
16
19

Plusieurs cas indépendants

Si on a plusieurs cas indépendants (des cas où plusieurs cas peuvent être vrais), on peut utiliser plusieurs blocs if :

if (condition1) {
    // code à exécuter si la condition1 est vraie
}
if (condition2) {
    // code à exécuter si la condition2 est vraie
}
if (condition3) {
    // code à exécuter si la condition3 est vraie
}

Voici un exemple de code qui utilise plusieurs cas indépendants dans le fichier IndependantConditions.java :

String input(String prompt) {
    System.out.print(prompt + " > ");
    return System.console().readLine(); 
                // plus simple mais moins puissante qu'un Scanner
}

void main() {
    String favColour = input("Couleur préférée");
    String favSeason = input("Saison préférée");
    int favNumber = Integer.parseInt(input("Nombre entier préférée")); 
        // on converti le String en int dans une 2ème opération

    if (favColour.equals("bleu")) {
        System.out.println("Le bleu est ma couleur préférée aussi!");
    }
    if (favSeason.equals("été")) {
        System.out.println("L'été est ma saison préférée aussi!");
    }
    if (favNumber == 7) {
        System.out.println("7 est mon nombre préféré aussi!");
    }
}

Boucle while

Voici la syntaxe de base pour une boucle while :

while (condition) {
    // bloc de code
    // mécanisme de mise à jour
}

C’est important de noter que l’exécution des instructions ne continue pas après le bloc de code mais revient à la condition. C’est ça qui forme la boucle. Si la condition est true, le bloc de code est répété. Si la condition est false, l’exécution continue après la boucle. Ici, le diagramme de flux donne une meilleure représentation de l’exécution réelle de étapes.

Exemple : Traiter une suite de nombres

Pour traiter une suite de nombres, on définit d’abord une variable de contrôle qui représente la valeur initiale de la suite. Ensuite, on définit la condition de la boucle en fonction de cette variable de contrôle. Finalement, on met à jour la variable de contrôle à l’intérieur du bloc de code.

Placez le code suivant dans un fichier qui s’appelle LoopExamples1.java et exécutez-le pour voir les résultats.

Par exemple, pour afficher les nombres de 1 à 10 :

Avec while

void whileLoop() {
    int i = 1;          // initialiser la variable de contrôle
    while (i <= 10) {   // condition utilisant la variable de contrôle
        System.out.println(i);
        i++; // mise à jour de la variable de contrôle (incrémenter)
    }
}

void main() {
    whileLoop();
}

1
2
3
4
5
6
7
8
9
10

Avec for

La boucle for est spécialisée pour ce type de tâche. Elle inclut les trois éléments clés de la boucle directement dans sa déclaration. Sa syntaxe est la suivante :

for (initialisation; condition; mise à jour) {
    // bloc de code
}

Par exemple, pour afficher les nombres de 1 à 10 avec une boucle for :

void forLoop() {
    for (int i = 1; i <= 10; i++) { // les trois éléments séparés par des ;
        System.out.println(i);
    }
}

Si on appelle aussi cette méthode dans main, on aura exactement la même sortie qu’avec la version while. Ajoutez-le à votre fichier LoopExamples1.java pour le vérifier.

Défi

Pouvez vous trouver et afficher la somme de toutes les valeurs de 1 à 10 en modifiant une des boucles ci-dessus?

Indice : vous aurez besoin d’une variable accumulateur en plus de la variable de contrôle.

Exemple : Valider des données d’entrée

Un autre contexte pour une boucle est demander une réponse à l’utilisateur tant que la réponse n’est pas valide.

Une situation typique est lorsqu’on demande une confirmation oui/non à l’utilisateur. On peut utiliser une boucle while pour s’assurer que la réponse est valide.

Voici deux façons de le faire. Il en existe d’autres! Vous pouvez tester ces méthodes dans un nouveau fichier LoopExamples2.java.

Avec une variable de contrôle pour la condition de la boucle

import java.util.*;

final Scanner INPUT = new Scanner(System.in);

String again() {
    String answer = ""; // variable : contrôle ET accumulateur

    while (!(answer.equals("oui") || answer.equals("non"))) { 
        System.out.print("Voulez-vous continuer? (oui/non) > ");
        answer = INPUT.next().toLowerCase();
            // mise à jour avec une réponse en minuscules
    }
    return answer;
}

void main() {
    while (again().equals("oui")) {
        // code à répéter
    }
    System.out.println("Au revoir");
}

Il y a deux conditions dans ce code.

Le plus complexe est dans again() : !(answer.equals("oui") || answer.equals("non")) :

• Le ! au début indique qu’on veut inverser le résultat entre les parenthèses - c’est parce que ce qu’on décrit entre parenthèses correspond à ce que nous voulons, mais la boucle devrait se répéter dans le cas contraire
• Le || est l’opérateur “ou” qui sera vrai si l’une ou l’autre des conditions est vraie.
• On utilise .equals() pour comparer l’égalité parce qu’on compare deux String.

Plaçant tout ça ensemble avec le mot-clé while, on devrait lire :

si la réponse EST "oui" OU "non", NE PAS répéter le bloc de code

La deuxième condition est dans main : again().equals("oui") :

• again retourne un String au programme qui est directement utilisé dans la comparaison

Voici un exemple d’interaction avec l’utilisateur pour ce programme :

Voulez-vous continuer? (oui/non) > peut-être
Voulez-vous continuer? (oui/non) > n
Voulez-vous continuer? (oui/non) > Non
Au revoir

Défi

La condition pour évaluer si la réponse était invalide (alors répéter la boucle) est la suivante :

!(answer.equals("oui") || answer.equals("non")) = si la réponse EST "oui" OU "non", NE PAS répéter le bloc de code

On peut écrire cette même condition d’une autre façon.

Exemple : Répéter un programme jusqu’à ce que l’utilisateur décide de le quitter

Un autre contexte commun est une boucle de programme intentionellement infinie. Pour ces cas, la déclaration de la boucle est while (true). C’est ce qui se passe avec les fenêtres de vos applications : l’affichage est rafraîchi en permanence jusqu’à ce que vous fermiez la fenêtre.

Mais comment quitter une boucle où la condition de boucle est une constante? Réponse : on utilise une instruction break à l’intérieur du bloc de code. L’instruction break est insérée dans une sélection qui évalue si la condition de sortie est atteinte.

while (true) { // passe tout droit
    // bloc de code
    if (condition) {
        break; // sortie de la boucle
    }
}

Notez que le mot-clé while n’apparaît jamais dans ces diagrammes, ni les autres mot-clés (p. ex.: if, else, true, break). Il s’agit simplement de conditions et d’embranchements dans les diagrammes. Dans les divers cas d’itération, une des branches forme une boucle. Sinon on parle de sélection / d’embranchement tout court.

Retour sur la validation de données

On pourrait remplacer la version de main dans LoopExamples2.java avec la version suivante :

void main() {
    while (true) {
        // code de la tâche

        // code pour demander à l'utilisateur s'il veut continuer

        if (again().equals("non")) {
            break; // sortie de la boucle
        } else {
            // code pour réinitialiser les variables de la tâche
        }
    }
}

Pour d’autres tâches

Un autre exemple est pour faire la somme d’une série de nombres. On demande à l’utilisateur d’entrer un nombre à la fois. Si le nombre est -999, on quitte la boucle. Sinon, on ajoute le nombre à la somme.

Reprendre cet exemple dans un nouveau fichier LoopExamples3.java.

import java.util.*;

void main() {
    Scanner input = new Scanner(System.in);

    int sum = 0; // variable accumulateur

    while (true) {
        System.out.print(
            "Entrez un nombre entier (-999 pour quitter) : "
        );
        
        int num = input.nextInt(); // variable de contrôle
        if (num == -999) {
            break; // mot-clé pour quitter la boucle
        } else {
            sum += num;
        }
    }
    System.out.println("La somme est " + sum);
}

Et voici deux exemples d’interaction avec l’utilisateur :

Entrez un nombre entier (-999 pour quitter) : 5
Entrez un nombre entier (-999 pour quitter) : 10
Entrez un nombre entier (-999 pour quitter) : 15
Entrez un nombre entier (-999 pour quitter) : -999
La somme est 30

Entrez un nombre entier (-999 pour quitter) : -3
Entrez un nombre entier (-999 pour quitter) : 0
Entrez un nombre entier (-999 pour quitter) : 3
Entrez un nombre entier (-999 pour quitter) : 6
Entrez un nombre entier (-999 pour quitter) : -999
La somme est 6

Responsabilité unique

En génie logicielle, il y a un principe qui s’appelle la responsabilité unique. Ce principe nous dit que chaque méthode doit être responsable d’une seule chose. C’est une des raisons pourquoi nous brisons nos algorithmes en méthodes plus petites : cela limite la responsabilité de main à l’organisation globale des opérations et permet à chaque méthode d’avoir un objectif clair.

Si on utilise du code qui peut générer une exception, on a deux choix :

• ajouter une déclaration throws Exception à la signature de la méthode pour passer la gestion de l’exception à la méthode appelante, ou
• utiliser un bloc try et catch pour gérer l’exception dans la méthode directement.

La deuxième option est préférable selon le principe de responsabilité unique, car la méthode gère les problèmes potentiels avec le code qu’il utilise pour accomplir sa tâche, et les autres méthodes n’ont pas besoin de s’en soucier : elles peuvent se concentrer sur leur propre tâche.

Bloc try et catch pour des entrées invalides

Le bloc try contient le code qui peut lancer une exception, et le bloc catch contient le code à faire si une exception est lancée. Voici la structure de base d’un bloc try et catch :

try {
    // code qui pourrait lancer une exception
} catch (Exception e) {
    // code à exécuter si une exception est lancée
}

Voici un exemple de code¹ qui lance une exception si l’utilisateur entre un texte qui ne peut pas être converti en un nombre entier. Dans cet exemple, on ne laisse pas le programme planter, mais on demande à l’utilisateur de réessayer :

Fichier: ExceptionExample.java

import java.util.*;

Scanner input = new Scanner(System.in);

int getInt(String prompt) {
    // tentatives infinies jusqu'à ce que tout dans le try fonctionne
    while (true) { 
        try {
            System.out.print(prompt);
            int number = input.nextInt(); // peut planter
            return number; // quitte la méthode si tout va bien
        } catch (Exception e) { // si ça plante
            System.out.println("   Entrée invalide");
            input.next(); // vide l'entrée invalide du Scanner
        }
    }
}

void main() {
    int age = getInt("Entrez votre âge : "); // pas besoin de savoir que ça peut planter
    System.out.println("Vous avez soumis un âge de : " + age);
}

Notez que dans main on veut simplement obtenir un nombre entier et l’utiliser. Cela est possible parce que la méthode getInt gère les exceptions qui pourraient survenir lors de la conversion de l’entrée utilisateur en un nombre entier. Ainsi, chaque méthode s’occupe de sa propre responsabilité et n’a pas besoin de connaître les détails internes des autres méthodes. C’est un bon exemple de la responsabilité unique.

Voici une autre version de main ¹ pour ce même problème, mais dans ce cas-ci, main gère une autre sorte d’entrée invalide : une entrée qui n’est pas un âge valide. Ce type d’erreur ne cause pas d’exception, mais pourrait causer des erreurs de logique dans le programme.

void main() {
    int age = getInt("Entrez votre âge : ");
    if (age < 0) { // gérer une valeur logiquement invalide
        System.out.println("Âge invalide");
    } else {
        System.out.println("Vous avez soumis un âge de : " + age);
    }
}

Bloc try et catch pour des ressources comme des fichiers

Nous étudions les fichiers en plus de détail dans la dernière section de cette unité

Si le programme génère une exception lors de l’utilisation d’une ressource comme un fichier, il est important de fermer la ressource avant de quitter le programme. Pour cela, on utilise une déclaration try avec une ressource. Dans cette version de la structure, la ressource est déclarée dans les parenthèses après le mot-clé try. La ressource est automatiquement fermée par Java à la fin du bloc try, même si une exception est lancée.

Voici la structure d’une déclaration try-catch quand le plantage est lié à la ressource utilisée :

try ( déclaration de la ressource qui peut planter ) {
    // code à exécuter avec la ressource si ça ne plante pas
} catch (Exception e) {
    // code à exécuter si ça plante
}

Voici un exemple où la ressource qui peut planter est un FileWriter pour écrire dans un fichier.

void writeMessageToFile(String message) {
    try (FileWriter output = new FileWriter("./data/output.txt")) {
        output.write(message);
    } catch (Exception e) {
        System.out.println("Chemin de fichier invalide");
    }
}

Voici un deuxième exemple où la ressource qui peut planter est l’objet File qu’on passe au Scanner pour extraire son contenu.

String getFileContents(Locale decimalFormat) {
    try (Scanner fileReader = new Scanner(new File("./data/input.txt"))) {
        fileReader.useLocale(decimalFormat);
        fileReader.useDelimiter("\\Z"); // next() s'arrête au caractère de fin de fichier
        return fileReader.next();
    } catch (Exception e) {
        System.out.println("Fichier introuvable");
        return null; // quittez la méthode avec une référence `null` pour le String
    }
}

Notez que dans ces deux exemples, on doit déclarer et initialiser la ressource plantable entre des parenthèses après le mot-clé try.

Exceptions spécifiques

Pour ce cours, c’est tout à fait normal d’utiliser Exception - la plus générale de toutes les exceptions - comme type d’exception dans le bloc catch. Mais en situation de production logicielle, c’est important de déclarer l’exception spécifique qui peut survenir dans le bloc catch.

Par exemple :

• Dans le cas d’entrée invalide, le type d’exception qui est lancée est InputMismatchException (avec les méthodes de Scanner nextInt et nextDouble) ou NumberFormatException (si on utilise plutôt Integer.parseInt(input.next()) ou Double.parseDouble(input.next())). Ce sont des exceptions pour les erreurs de conversion de chaînes de caractères en nombres.
• Dans le cas de la lecture ou l’écriture de fichiers, l’exception est IOException.

Utiliser une exception spécifique permet de gérer les exceptions de manière plus précise. En fait, cette structure nous permet de déclarer un bloc catch pour chaque type d’exception qui peut survenir. Le premier bloc catch qui correspond à l’exception lancée est celui qui est exécuté, comme une cascade if-else if, alors c’est important de les mettre dans l’ordre du plus spécifique (p. ex. IOException) au plus général (Exception).

Gérer les exceptions

Parce qu’on essaie d’accéder à une ressource - un fichier - qui n’existe peut-être pas (si on l’a mal nommé ou si le chemin est mal formé ou si son dossier n’a pas été crée en premier), on utilise généralement un bloc try-catch avec ressources pour l’action de lire ou écrire dans un fichier. Le format général est :

try (déclarer et initialiser la ressource) {
  // code pour lire ou écrire dans le fichier
  /* retourner une valeur utile et/ou assigner les valeurs lues 
  à des variables déclarées à l'extérieur du bloc try-catch */
} catch (Exception e) {
  // message d'erreur
  // retourner/assigner une valeur par défaut
}

Un avantage majeur du bloc try-catch est que la ressource est automatiquement fermée à la fin du bloc, même si une exception est lancée. Cela évite les fuites de ressources et les erreurs de programmation.

Un autre avantage est qu’en cas de plantage, on a une valeur connue qu’on peut utiliser dans une condition pour éviter que le reste du programme ne plante. Par exemple, si on sait que la valeur d’un String lue revient null en cas d’erreur, on peut tester si la valeur est null comme pré-condition pour continuer le programme.

Il y a deux exemples de code dans la leçon sur les exceptions qui représentent des bons points de départ pour lire et écrire des fichiers :

Notes sur les exceptions

D’autres exemples d’algorithmes incluant des exceptions sont fournis plus bas.

Connaître la structure du fichier

Pour bien lire un fichier, il faut avoir une idée de sa structure ou, mieux, connaître exactement sa structure.

Cela vous permet de développer un plan pour lire le fichier, notamment :

• Est-ce que la première ligne est spéciale, avec un chiffre indiquant le nombre de lignes de données, par exemple ? -> Cela vous permet de déclarer un tableau de taille appropriée pour les données et de fixer une limite ferme pour la boucle de lecture.
• Est-ce que les données sur une ligne sont séparées par des virgules, des espaces, des tabulations, etc. ? -> Cela vous permet de configurer le Scanner correctement avec useDelimiter()
• Quels types de données se trouvent à chaque position sur une ligne ? -> Cela vous permet de configurer la suite d’instructions next* pour lire les données
• Est-ce que les nombres décimaux utilisent un point ou une virgule pour le séparateur décimal ? -> Cela vous permet de configurer le Scanner correctement avec useLocale()

Un objet sur mesure pour nos données

Connaissant la structure des données sur chaque ligne d’un fichier, vous pouvez vous casser la tête à savoir comment organiser toute l’information lue afin de pouvoir l’utiliser dans votre programme et pas seulement l’afficher à l’écran.

La solution est de créer une petite classe qui ne contient aucune méthode mais juste des variables pour stocker les données. On appelle cette classe une classe de données.^{1 2}

Par exemple, plus loin on voit un exemple où on veut lire le mois (String), la température moyenne (double) et la précipitation (int) pour chaque mois de l’année. On pourrait créer une classe WeatherData avec les variables month, averageTemp et precipitation pour stocker ces données.

/** Définit notre propre structure de données */
class WeatherData {
  String month;
  double averageTemp;
  int precipitation;
}

void main() {
  // déclare un tableau qui contient des éléments de type WeatherData
  WeatherData[] monthlyWeather = new WeatherData[12]; 
  //... lire les données dans le tableau
}

Sans notre propre type de données on aurait dû utiliser des tableaux séparés de String, double et int pour stocker les données. Cela aurait été plus difficile à lire et à maintenir. Et dans Java, on ne peut retourner qu’une seule valeur d’une méthode, alors on n’aurait pas pu retourner les trois tableaux ensemble. On serait obligé de déclarer ces tableaux globalement (dans la classe).

Dans la boucle de lecture, on peut assigner les valeurs lues aux 3 variables d’instance de chacune des 12 objets de la classe WeatherData et ensuite retourner le tableau pour l’utiliser dans le reste du programme. Par exemple :

import java.io.*;
import java.util.*;

void main() {
  Scanner fileReader = new Scanner(new File("weather_data2022.txt"));
  WeatherData[] monthlyWeather = getWeatherData(fileReader);
  filereader.close();

  // ...code pour utiliser monthlyWeather
}

class WeatherData {
  String month;
  double averageTemp;
  int precipitation;
}

WeatherData[] getWeatherData(Scanner fileReader) {
  WeatherData[] weather = new WeatherData[12]; // créer un tableau de 12 objets
  for (int i = 0; i < 12; i++) {
    weather[i] = new WeatherData(); // initialiser chaque objet
    // initialiser ses variables
    weather[i].month = fileReader.next(); 
    weather[i].averageTemp = fileReader.nextDouble();
    weather[i].precipitation = fileReader.nextInt();
  }
  return weather; // retourner le tableau
}

Une classe comme WeatherData est le début de la programmation orientée-objet, le thème du cours ICS4U.

Lire un fichier texte avec un Scanner

Il y a plusieurs façons de lire un fichier texte avec un Scanner.

• Pour un fichier simple, on peut créer un seul objet Scanner (pour le fichier) et utiliser une séquence de next* pour lire les données.
• Pour un fichier qui contient des données structurées qui se répètent, soit un tableau de valeurs comme, p. ex., un fichier CSV, en plus du Scanner pour le fichier, on doit généralement créer une boucle pour lire les données ligne-par-ligne.
• Pour un fichier de texte non structurée (comme une histoire), on peut extraire le contenu du fichier au complet dans un String et utiliser un Scanner pour lire ce String mot-par-mot ou phrase-par-phrase ou utiliser d’autres méthodes String pour l’enquêter.

Il y a plusieurs autres approches possibles, alors ces trois-ci ne sont que des points de départ. Dans tous les cas, l’algorithme ressemble généralement à ceci :

1. Déclarer des variables pour stocker les données lues.
2. Extraire les données dans un bloc try-catch avec ressources (la déclaration du Scanner pour le fichier); définir des valeurs par défaut en cas d’erreur.
3. Si la valeur lue est la valeur en cas d’erreur (clause de garde) :
   • quitter le programme (ou éviter autrement l’utilisation du code qui dépend des valeurs lues).
4. Sinon :
   • utiliser les données lues dans le reste du programme.

David 99

void main() {
  String name; // variables déclarées à l'extérieur du bloc try-catch
  int score;

  try (Scanner fileReader = new Scanner(new File("./highscore.txt"))) {
    name = fileReader.next(); // valeurs en cas de succès
    score = fileReader.nextInt();
  } catch (Exception e) {
    System.out.println("Erreur de lecture du fichier.");
    name = null; // valeurs en cas d'erreur
    score = 0;
  }

  // précondition ("clause de garde")
  if (name == null) {
    System.out.println("Aucun pointage n'a été enregistré.");
    // possiblement quitter le programme avec return;
  }

  // ...code pour utiliser name et score
}

Ottawa
Mois;Tmoy(C);Tmin(C);Tmax(C);Précip(mm)
Janvier;-9,1;-18,2;11,4;114
Février;-11,3;-22,4;10,2;98
Mars;-8,2;-12,3;17,3;140
...
Décembre;-12,3;-16,4;12,3;87

void main() {
  WeatherData[] weather; // variable déclarée à l'extérieur du bloc try-catch
  String city;

  try (Scanner fileReader = new Scanner(new File("./weather.txt"))) {
    fileReader.useDelimiter(";");
    fileReader.useLocale(Locale.CANADA_FRENCH);
    city = fileReader.nextLine(); // première ligne
    fileReader.nextLine(); // ignorer l'en-tête à la 2e ligne
    weather = new WeatherData[12]; // pour les 12 lignes de données
    for (int i = 0; i < 12; i++) {
      weather[i] = new WeatherData(); // initialiser chaque objet
      weather[i].month = fileReader.next(); // initialiser ses variables
      weather[i].averageTemp = fileReader.nextDouble();
      fileReader.next(); // ignorer la température minimale
      fileReader.next(); // ignorer la température maximale
      weather[i].precipitation = fileReader.nextInt();
    }
  } catch (Exception e) {
    System.out.println("Erreur de lecture du fichier.");
    weather = null; // valeurs en cas d'erreur
  }

  // précondition ("clause de garde")
  if (weather == null) {
    System.out.println("Aucune donnée météo n'a été enregistrée.");
    // possiblement quitter le programme avec return;
  }

  // ...code pour utiliser weather
}

Il était une fois, dans une galaxie lointaine, très lointaine...

void main(){
  String story; // variable déclarée à l'extérieur du bloc try-catch

  try (Scanner fileReader = new Scanner(new File("./story.txt"))) {
    fileReader.useDelimiter("\\Z"); // configurer le Scanner
    story = fileReader.next(); // lire le fichier au complet
  } catch (Exception e) {
    System.out.println("Erreur de lecture du fichier.");
    story = null; // valeurs en cas d'erreur
  }

  // précondition ("clause de garde")
  if (story == null) {
    System.out.println("Aucune histoire n'a été enregistrée.");
    // possiblement quitter le programme avec return;
  }

  // ...code pour utiliser story, 
  // incluant potentiellement d'autres Scanners
}

Écrire dans un fichier texte avec un FileWriter

…