Atelier 01

Bienvenue au premier labo ! À ce stade, on s’attend à ce que vous ayez déjà installé tous les logiciels nécessaires pour ce cours.

Considérez ce labo comme le dernier point de contrôle final avant que les choses deviennent sérieuses. L’intérêt de ce labo est de s’assurer que vous êtes tous opérationnels et que vous avez un environnement de développement pleinement fonctionnel.
Passer à travers les exercices suivants sert aussi de révision, pour s’assurer que vous êtes capables de naviguer correctement dans les préliminaires technologiques du développement en Java.

Suivez les instructions, ne prenez pas de raccourcis.

Pour les deux premiers volets (Bash et Java), vous devez travailler uniquement avec la ligne de commande. N’utilisez aucun outil graphique pour ces tâches. Ces tâches ne concernent pas la programmation, mais plutôt la vérification de votre environnement et l’entraînement à la maîtrise de vos outils. Il y aura des questions d’examen sur l’utilisation de la ligne de commande.

Notions de base en ligne de commande

Dans ce premier bloc, nous allons vérifier votre installation de bash et revoir quelques commandes essentielles.

Tester votre noyau

Ouvrez un nouveau terminal et tapez uname -a. Ensuite, appuyez sur Entrée.
La commande donne des détails sur le noyau de votre système d’exploitation. Comme vous êtes censés travailler avec un Unix (Linux / Mac / WSL), vous devriez voir une ligne semblable à :
Darwin air.ddns.uqam.ca 24.4.0 Darwin Kernel Version 24.4.0: Fri Apr 11 18:34:14 PDT 2025; root:xnu-11417.101.15~117/RELEASE_ARM64_T8122 arm64

Unix n’est pas optionnel

Si la commande n’est pas trouvée, ou indique "windows", installez WSL ou Ubuntu maintenant. Il n’est pas possible de poursuivre ce cours sans un système de type Unix.

Accès au système de fichiers

Ensuite, nous allons revoir quelques commandes essentielles de bash :

Commande	But
`cd`	Aller au répertoire personnel (homedirectory)
`cd x`	Entrer dans un sous-répertoire `x` (s’il existe)
`mkdir x`	Créer un nouveau sous-répertoire `x`
`touch y`	Créer un nouveau fichier texte `y`

À vous de jouer. Utilisez les commandes ci-dessus pour : (N’utilisez pas de gestionnaire de fichiers graphique)

Entrer dans votre répertoire personnel
Créer un nouveau dossier Lab01, et à l’intérieur deux sous-dossiers imbriqués : src, et dans src un autre dossier helloworld
Entrer dans les trois nouveaux dossiers et créer un nouveau fichier texte HelloWorld.java

À la fin, vous devriez avoir créé la structure suivante :

Lab01
└── src/
    └── helloworld
        └── HelloWorld.java

Entrées et sorties

Jusqu’à présent, votre structure de fichiers ne fait pas grand-chose, changeons ça !

Voici quelques commandes pour afficher à la console et écrire dans un fichier :

Commande	But
`echo 'toto'`	Écrire `toto` dans le terminal
`echo 'toto' > file`	Remplacer le contenu du fichier par `toto`
`cat file`	Afficher le contenu du fichier `file`

Maintenant, utilisez ces commandes pour faire ce qui suit : (N’utilisez pas de gestionnaire de fichiers graphique)

Tester l’écriture à la console, affichez cette chaîne à la console :
package helloworld;class HelloWorld{public static void main(String[] args){System.out.println("Hello INF2050");}}
- Remarque : Il s’agit bien d’un programme Java, compressé sur une seule ligne. Ne vous inquiétez pas du code pour l’instant, nous voulons seulement tester la console.
Si la chaîne s’affiche correctement, écrivez-la dans le fichier HelloWorld.java.
Vérifiez que la chaîne a bien été enregistrée dans le fichier HelloWorld.java, en utilisant cat.

Notions de base en Java

Avec les commandes bash précédentes, vous avez en fait créé un premier programme Java.
Voyons comment on peut l’exécuter.

Commandes

L’exécution d’un programme Java nécessite en réalité deux composants : un compilateur et un interpréteur :

Le compilateur traduit votre code source (celui que vous venez de créer) en bytecode Java : La commande javac appelle le compilateur Java.
L’interpréteur consomme le bytecode Java et l’envoie comme binaire à votre CPU : La commande java appelle la machine virtuelle Java, un interpréteur de bytecode Java.

Voici une illustration incomplète de la façon de compiler et d’exécuter du bytecode à partir de la ligne de commande :

Quelles sont les parties manquantes ? Écrivez vos réponses sur une feuille de papier et ensuite vérifiez votre compréhension.

Quelles sont les réponses, de gauche à droite ?

HelloWorld.java
javac HelloWorld.java
HelloWorld.class
java HelloWorld

Vérifier votre installation

Donc, pour travailler avec Java, nous avons besoin de deux commandes : javac et java. Vérifions si vous avez les bons outils installés :

Tapez java -version. Cela devrait afficher quelque chose comme :

openjdk version "23.0.2" 2025-07-15
OpenJDK Runtime Environment (build 23.0.2+12-54)
OpenJDK 64-Bit Server VM (build 23.0.2+12-54, mixed mode, sharing)

Tapez javac -version. Cela devrait afficher quelque chose comme :

javac 23.0.2

Vérifiez bien la version

Pour ce cours, il faut absolument la version 23 pour le compilateur et l’interpréteur (JVM). Des autres versions mèneront à des problèmes et probablement à une note plus basse.

Exécuter du code

Vous avez donc du code source et les outils pour le compiler et l’exécuter. Voyons si tout fonctionne comme prévu.

Compilez votre programme HelloWorld.java créé précédemment.
- Remarque : Le code source contient un nom de package, donc vous devez appeler javac depuis le répertoire src, et non depuis le dossier helloworld.
- Vérifiez qu’il y a maintenant un fichier HelloWorld.class.
Lancez votre programme compilé :
- Donnez le bytecode Java à votre interpréteur JVM. N’oubliez pas qu’il y a toujours un nom de package, donc vous devez appeler la JVM depuis le répertoire src, et non depuis le dossier helloworld.
- Vérifiez que la sortie du programme est correcte. Il devrait afficher Hello MGL7010 dans la console.

IntelliJ

À ce stade, vous êtes prêt avec les outils en ligne de commande.

Bien sûr, nous ne développerons pas de plus gros projets à partir de la ligne de commande, mais plutôt avec un environnement de développement intégré (IDE).
Pour ce cours, vous travaillerez avec IntelliJ Ultimate.

Vérifier la version d’IntelliJ

Commençons par vérifier que vous avez bien la bonne version installée :

Démarrez IntelliJ, ouvrez l’option "À propos" dans le menu du programme : "IntelliJ -> About IntelliJ IDE".
Vous devriez voir une fenêtre contextuelle semblable à ceci :

Vérifiez qu’il est écrit "Ultimate Edition".

Vous avez besoin de la version Ultimate

La version Ultimate n’est pas optionnelle. Dans ce cours, nous utiliserons des fonctionnalités exclusives à la version Ultimate. Il n’est pas possible de résoudre correctement les labos ou TP avec la version Standard. Si vous ne voyez pas "Ultimate Edition", assurez-vous de vous inscrire dès maintenant pour une licence éducative gratuite.

Importer un projet

Vous allez maintenant utiliser votre application Hello World codée précédemment dans IntelliJ et exécuter votre code à partir de l’IDE.

Utilisez File -> Open....
- Assurez-vous de ne pas utiliser une option Import, mais bien Open....
Un explorateur de fichiers apparaîtra. Sélectionnez le dossier Lab01 que vous avez créé précédemment. Ensuite, cliquez sur le bouton Open.
- Assurez-vous de sélectionner le dossier Lab01, et non un sous-dossier.

Une fois l’IDE ouvert, dépliez le dossier src et accédez au fichier HelloWorld.java.
Testez le formatage du code :
- Mac OS : Commande (⌘) + Option (⌥) + L
- Linux / Windows : Ctrl + Alt + L
Cliquez sur le triangle vert à gauche de la ligne de code.
- Vérifiez que ça affiche Hello MGL7010.

Que se passe-t-il réellement quand vous cliquez sur ce triangle vert ?

L’IDE appellera le compilateur Java, puis invoquera la machine virtuelle Java. Il utilise implicitement exactement les mêmes outils que vous utilisiez précédemment en ligne de commande.

Code with me

Tout au long du semestre, vous travaillerez souvent en équipes.
- Bien qu’il existe une solution standard pour les projets de groupe (git), pour les projets en binôme la meilleure solution reste le pair-programming.
- Cependant, il arrive souvent que vous ne soyez pas physiquement au même endroit.
Avec IntelliJ "Code with me", vous pouvez transformer votre IDE en un document virtuel partagé (un peu comme un Google Doc), et travailler en mode pair-programming, même si vous n’êtes pas physiquement au même endroit.
- Jetez un œil au plugin "Code with me" : Documentation en français
Testez le plugin "Code with me" avec l’étudiant à côté de vous :
- Vérifiez que vous voyez le même code.
- Vérifiez que vous pouvez tous les deux éditer le code.

Comparaison d’objets

En cours, nous avons vu qu’il existe une différence fondamentale entre la comparaison de types primitifs et la comparaison d’objets.

Ci-dessous se trouve un court programme qui présente une comparaison d’objets non sécurisée.

Copiez et collez le programme dans votre IDE.
Avant d’exécuter le programme, formulez une hypothèse sur sa sortie.
- Écrivez votre réponse sur une feuille de papier.
- Pour chaque sortie, ajoutez brièvement un argument de justification.
Exécutez le programme et vérifiez votre hypothèse.

Regardez de près le type de listOfString.

En cours, vous avez appris à distinguer les types primitifs des types objets ; observez attentivement le premier caractère.

import java.util.LinkedList;

public class Main {
  public static void main(String[] args) {

    LinkedList<String> listWithNames = new LinkedList<>();
    listWithNames.add("Fatoumata");
    listWithNames.add("Leila");
    listWithNames.add("Paul");
    listWithNames.add("ElMehdi");

    LinkedList<String> listWithSameNames = new LinkedList<>();
    listWithSameNames.add("Fatoumata");
    listWithSameNames.add("Leila");
    listWithSameNames.add("Paul");
    listWithSameNames.add("ElMehdi");

    // What does this print ? true or false ?
    System.out.println(listWithNames == listWithSameNames);

    // What does this print ? true or false ?
    System.out.println(listWithNames.equals(listWithSameNames));
  }
}