Table des matières

TD 1 : Premiers pas

Dans cette première séance nous allons voir comment compiler et exécuter un fichier de code source Java, et effectuer des manipulations basiques sur les objets.

Prise en main

Commencez par recopier le code source suivant dans un fichier nommé Main.java. Vous pouvez utiliser l’éditeur de texte de votre choix comme VScode, Emacs ou Atom par exemple. Placez ce fichier dans un répertoire vide créé pour l’occasion (exemple: poo/td1)

// Définition de classe, obligatoire dans chaque fichier Java.
// Le nom de la classe doit être égal au nom du fichier.
class Main {

	// Point d'entrée des programmes Java. Le tableau de String args correspond
	// aux paramètres passés sur la ligne de commande.
	public static void main(String[] args) {
		// Affichage du message.
		System.out.println("Hello World!");
	}
}

1) Pour compiler ce fichier il faut faire appel au compilateur Java : javac. Vous pouvez compiler le fichier avec la commande suivante :

reveillere:~/poo/td1$ javac Main.java

2) Si tout se passe bien, vous devriez obtenir un fichier nommé Main.class. Il contient le code précédent sous forme de bytecode. Pour lancer l’exécution du programme, il faut cette fois lancer la machine virtuelle Java, avec la commande

reveillere:~/poo/td1$ java Main

Normalement, l’exécution du programme devrait afficher la chaîne Hello World! sur votre console.

Arguments sur la ligne de commande

L’unique argument de la fonction main est un tableau de chaînes de caractères.

1) Modifiez le programme précédent pour que la chaîne de caractères à afficher soit passée en argument.

2) Faire en sorte que le programme affiche les arguments de la ligne de commande à l’envers, comme sur l’exemple ci-dessous.

reveillere:~/poo/td1$ java Main un deux trois quatre
Inverse = quatre trois deux un

Allons sur Mars ….

Dans cette deuxième partie, nous allons mettre en oeuvre les opérations élémentaires d’un robot sur la surface de Mars.

Position

Le but de cet exercice est de pouvoir manipuler des objets de type Position représentant des coordonnées dans un espace euclidien entier (chaque point a des coordonnées (x,y) où x et y sont des entiers.

1) Implémentez une classe  Position dans un fichier Position.java pour représenter une coordonnée dans un tel espace. Assurez-vous que l’objet représentant une position est correctement initialisé dès de sa création.

2) Implémentez dans la classe Position la méthode void afficher() qui affiche dans le terminal les coordonnées d’une position sous la forme (2,4) pour une position d’abscisse 2 et d’ordonnée 4.

3) Implémentez une classe PositionTest dans un fichier PositionTest.java afin de tester votre classe Position. Cette classe contiendra une méthode main permettant d’instancier un objet Position et d’afficher les coordonnées de la position.

4) Implémentez les méthodes suivantes dans la classe Position.

// Deplace une position par rapport à son origine
void deplacement(int dx, int dy);

// meme deplacement en x et en y
void deplacement(int delta);

Ajoutez une méthode testDeplacementDxDyPositif dans la classe PositionTest pour vérifier le bon fonctionnement de la méthode déplacement avec des valeurs de dx et dy strictement supérieures à zéro. Cette méthode doit instancier un objet Position avec des coordonnées fixées, appeler la méthode déplacement sur cet objet, puis vérifier que ses coordonnées ont bien été mises à jour correctement. Si le test réussit, affichez testDeplacementDxDyPositif [OK] ; en cas d’échec, affichez testDeplacementDxDyPositif [FAILED]. Modifiez la méthode main pour appler la méthode de test testDeplacementDxDyPositif. Complétez votre jeu de test en ajoutant quelques cas de tests représentatatifs.

5) Nous souhaitons ajouter une méthode pour calculer la distance euclidienne entre deux positions. Commencez par écrire les méthodes de tests avant de coder la méthode elle-même. On pourra, par exemple, écrire testDistanceEntreDeuxPointsDistincts et testDistanceMemePosition.

// Calcul la distance euclidienne entre deux positions
double distance(Position cible);

Robot

L’objectif de cet exercice est de concevoir et manipuler des objets représentants des robots d’exploration à la surface de la planète Mars. Nos robots peuvent évoluer dans toutes les directions.

1) Implémentez une classe Robot dans un fichier Robot.java, qui contient les attributs nom (de type String), position (de type Position pour représenter la position 2D du robot), energie (de type double pour l’énergie restante du robot) et cout (de type double pour le coût en énergie d’un déplacement d’une unité). On doit pouvoir définir les valeurs de tous les attributs d’un robot au moment de son instanciation.

2) Implémentez les méthodes suivantes dans la classe Robot.

Robot curiosity
    Position : (80, 100)
    Energie : 400,00
    Cout : 10,00

3) Implémentez une classe RobotTest dans un fichier RobotTest.java afin de tester votre classe Robot. Vous devrez mettre en place une série de scénarios de test pour évaluer toutes les fonctionnalités de la classe Robot, en créant plusieurs instances de robots avec des attributs variés et en assignant à chaque robot un scénario de test spécifique.

Mondialisation

Les standards de codage recommandent l’utilisation de l’anglais afin de faciliter la compréhension et la relecture du code par un plus grand nombre de personnes.

Pour la suite, il est demandé d’écrire directement votre code en anglais, commentaires inclus.

Espace géométrique discret

Nous supposons maintenant que la surface de la planète Mars est divisée en tuiles carrées, formant ainsi un quadrillage. Le robot peut se déplacer uniquement horizontalement ou verticalement, d’une case à l’autre. Il n’est pas capable de se déplacer en diagonale, ce qui signifie que son déplacement respecte une connexité-4. La position du robot est représentée par le numéro de colonne et le numéro de ligne dans le quadrillage. Dans le prochain TD, nous explorerons comment représenter graphiquement notre robot.

  1. Le calcul de la distance effectué par l’objet Position est trop restrictif car il correspond à une distance euclidienne, ne prenant pas en compte les spécificités de l’espace dans lequel le robot évolue. Supprimez donc ce calcul de la classe Position.

  2. Implémentez la méthode distance au sein de la classe Robot afin de calculer la distance de Manhattan entre la position actuelle du robot et la cible à atteindre, en considérant un espace géométrique discret.

  3. Assurez-vous de tester votre code.

Pour préparer la suite

Dans les séances à venir, nous allons utiliser IntelliJ IDEA, un Environnement de Développement Intégré (IDE) pour Java. Cet IDE offre des fonctionnalités avancées telles que le refactoring et une intégration transparente avec des outils de versionnage comme Git. Nous utiliserons également Gradle, un système de gestion et d’automatisation de build pour Java qui permet de gérer les dépendances et de compiler le code.

Il est fortement recommandé de suivre ce tutoriel pour se familiariser avec IntelliJ et Gradle. Cette initiation est cruciale pour le bon déroulement du TD2 et devra être réalisée au début de cette session si elle n’a pas été effectuée auparavant. Se familiariser avec ces outils dès maintenant vous permettra de tirer le meilleur parti des fonctionnalités qu’ils offrent pour le développement de vos applications Java.