Table des matières

• TD 1 : Premiers pas
  • Prise en main
  • Arguments sur la ligne de commande
• Allons sur Mars ….
  • Position
  • Robot
  • Graphisme
• Pour aller plus loin

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 :

lreveill@jc:~/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

lreveill@jc:~/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. Les tableaux s’utilisent comme en C avec la notation crochet. Le premier élément du tableau est à l’indice 0.

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.

lreveill@jc:~/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 dans un espace 2D.

Position

Le but de cet exercice est d’écrire un programme manipulant des positions dans un espace 2D.

1) Écrivez une classe  Position dans un fichier Position.java ayant comme attributs les deux coordonnées x en abscisse et y en ordonnée de type double.

2) Écrivez une classe TestPosition dans un fichier TestPosition.java dans laquelle vous définirez un main afin de tester votre classe Position. Dans un premier temps, nous utiliserons le constructeur par défaut sans argument.

3) Définissez dans la classe Position la méthode void afficher() qui affiche sur la console les coordonnées d’une position.

Information : En java, il n’est pas nécessaire de compiler l’ensemble de vos fichiers sources .java. Si chaque fichier .java ne contient qu’une seule classe et que le fichier porte le même nom que la classe, il suffit simplement de compiler le fichier qui contient la méthode public static void main(String[] args). Le compilateur compilera les fichiers nécessaires automatiquement.

4) Définissez ensuite les méthodes suivantes dans la classe Position et testez votre programme dans la classe TestPosition.

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

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

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

Remarque : Java met à disposition la méthode Math.sqrt() pour calculer la racine carrée. Cette méthode prend uniquement un nombre positif ou nul en paramètre. Vous pouvez également utiliser la méthode Math.pow pour le calcul de la puissance.

5) Définissez maintenant un constructeur prenant en paramètre les coordonnées de la position à créer.

Robot

Le but de cet exercice est d’écrire une classe modélisant notre robot d’exploration.

1) Écrivez une classe Robot dans un fichier Robot.java ayant les attributs position, energie et cout. La position du robot dans un espace 2D est de type Position. L’énergie restante du robot est de type double et le coût de déplacement du robot est de type double. Ce dernier correspond à l’énergie dépensée pour un déplacement d’une unité.

La classe Robot offrira un seul constructeur prenant en arguments les trois paramètres position, energie et cout. La position correspond au centre du robot. Dans la suite, on supposera que le robot est un carré de taille 40.

2) Écrivez une classe TestRobot dans un fichier TestRobot.java dans laquelle vous définirez un main afin de tester votre classe Robot.

3) Définissez ensuite les méthodes suivantes et testez votre programme.

// Retourne le rayon d'action du robot, c'est à dire la distance maximale que peut parcourir le robot compte tenu de son énergie disponible.
double rayonAction();

// Détermine si le robot possède siffisamment d'énergie pour atteindre la position cible. La méthode retournera `true` si le test est positif, et `false` dans le cas contraire.
boolean peutSeDeplacer(Position cible);

// Affiche les informations du robot sur la console
void afficher();

Dans le programme principal, instanciez plusieurs objets de la classe Robot, affectez des valeurs de votre choix à leurs attributs et testez vos méthodes. Vous devriez obtenir quelque chose comme ça pour un robot aux coordonnées (100,100) avec 400 d’énergie et 10 de coût de déplacement:

Robot @ (100,00 x 100,00)
Energie : 400,00
Cout : 10,00

Graphisme

Nous allons maintenant utiliser une bibliothèque graphique pour afficher notre robot sur la planète rouge. Le programme suivant affiche une fenêtre avec un robot aux coordonnées (100,100). Vous pouvez utiliser l’image du robot suivante :

import javafx.application.Application;
import javafx.scene.Scene;
import javafx.scene.image.Image;
import javafx.scene.image.ImageView;
import javafx.scene.layout.Pane;
import javafx.stage.Stage;
import javafx.scene.paint.Color;


public class Main extends Application {
    @Override
    public void start(Stage stage) {
        Pane root = new Pane();

        // Affiche le robot
        ImageView img = new ImageView(new Image("./robot.png"));
        img.setX(100);
        img.setY(100);

        // Affiche la fenetre
        root.getChildren().addAll(img);
        Scene scene = new Scene(root, 220, 220);
        scene.setFill(Color.rgb(241,199,128));
        stage.setTitle("POO - TD1");
        stage.setScene(scene);
        stage.show();
    }

    public static void main(String[] args) { launch(); }
}

lreveill@jc:~/poo/td1$ javac --module-path "chemin_javaFX/lib" --add-modules javafx.controls Main.java 
lreveill@jc:~/poo/td1$ java --module-path "chemin_javaFX/lib" --add-modules javafx.controls Main

1) Ajoutez dans la classe Robot une méthode ImageView FXRobot(); qui retourne la représentation graphique du robot. Modifiez le code précédent pour instancier un objet de type Robot et faire en sorte qu’il s’affiche à l’écran

2) Ajoutez dans la classe Robot une méthode Circle FXRayonAction(); qui retourne la représentation graphique du cercle autour du robot montrant son rayon d’action. Vous devriez obtenir quelque chose comme sur l’exemple ci-dessous.

3) Modifiez le programme de test pour instancier des robots et les afficher à l’écran.

Pour aller plus loin

Ajoutez une méthode deplacer au robot lui permettant d’atteindre une position cible et mettre à jour la quantité d’énergie restante du robot. Vous choisirez le ou les paramètres adaptés pour cette méthode

Information : Nous verrons le moyen d’animer le déplacement du robot un peu plus tard.