Correction TD4

Exercice 2 - Modélisation Orientée Objet (Classes Véhicule, Voiture, Avion)

Cet exercice évalue votre compréhension de l'héritage, des classes abstraites et du polymorphisme en Java. L'énoncé d'origine (extrait du PDF) comportait plusieurs erreurs de syntaxe dues à des retours à la ligne intempestifs au milieu des chaînes de caractères et des commentaires. Ces erreurs ont été corrigées dans le code ci-dessous afin de garantir que les programmes compilent et s'exécutent correctement.

Classe Abstraite Vehicule

La classe Vehicule sert de modèle de base. Elle est déclarée abstract, ce qui signifie qu'on ne peut pas l'instancier directement (on ne peut pas faire new Vehicule()). Elle impose également à ses classes filles de définir les méthodes demarrer() et accelerer().

package Exercice2;

public abstract class Vehicule {

    private String Matricule;
    private int annee;
    private double prix;
    private double vitesse;

    // Constructeur
    public Vehicule(String Matricule, int annee, double prix) {
        this.Matricule = Matricule;
        this.annee = annee;
        this.prix = prix;
        // La vitesse initiale est toujours 0 au moment de la création
        this.vitesse = 0; 
    }

    // Méthodes abstraites que les classes filles devront obligatoirement implémenter
    public abstract void demarrer();
    public abstract void accelerer(double v);

    // Méthode pour modifier la valeur de la vitesse
    public void setVitesse(double v) {
        this.vitesse = v;
    }

    // Méthode pour retourner la vitesse
    public double getVitesse() {
        return vitesse;
    }

    // Redéfinition de la méthode toString pour l'affichage
    public String toString() {
        return "Matricule " + Matricule + ", l'année du Modèle " + annee + ", prix = " + prix;
    }
}

Classe Voiture

La classe Voiture hérite de Vehicule (mot-clé extends). Elle doit utiliser le constructeur de la classe mère via super(...) et implémenter les méthodes abstraites.

Note de correction : Les sauts de ligne qui coupaient l'instruction System.out.println dans l'énoncé source ont été réparés.

package Exercice2;

public class Voiture extends Vehicule {

    // Constructeur
    public Voiture(String Matricule, int annee, double prix) {
        // Appel au constructeur de la classe mère (Vehicule)
        super(Matricule, annee, prix);
    }

    // Développement des méthodes abstraites
    public void demarrer() {
        System.out.println("La voiture va demarrer");
    }

    public void accelerer(double v) {
        setVitesse(v);
        // L'erreur de saut de ligne du PDF a été corrigée ici
        System.out.println("La nouvelle vitesse de la voiture est : " + getVitesse());
    }
}

Classe Avion

De manière similaire à la classe Voiture, la classe Avion hérite de Vehicule, mais elle ajoute un attribut spécifique : modele.

package Exercice2;

public class Avion extends Vehicule {

    private String modele;

    // Constructeur
    public Avion(String Matricule, int annee, double prix, String modele) {
        super(Matricule, annee, prix);
        this.modele = modele;
    }

    // Développement des méthodes abstraites
    public void demarrer() {
        System.out.println("L'avion va demarrer");
    }

    public void accelerer(double v) {
        setVitesse(v);
        // L'erreur de saut de ligne du PDF a été corrigée ici
        System.out.println("La nouvelle vitesse de l'avion est : " + getVitesse());
    }
}

Classe Test - Version 1 (Données codées en dur)

Cette première version du programme principal utilise une liste (ArrayList) pour stocker un mélange de voitures et d'avions. Elle illustre le polymorphisme et l'utilisation de l'opérateur instanceof pour filtrer les objets selon leur type réel.

Note de correction : L'énoncé utilise les types bruts (Raw Types) pour ArrayList, ce qui est une ancienne pratique Java, mais le code a été conservé fidèlement à la source. Les sauts de ligne dans les commentaires de la boucle ont été réparés pour que le code compile.

package Exercice2;
import java.util.ArrayList;

public class Test {

    public static void main(String[] args) {
        ArrayList A = new ArrayList();
        
        // Ajout des voitures et des avions dans un ArrayList A
        A.add(new Voiture("1234 tun 200", 2010, 40000));
        A.add(new Avion("ts123456", 2000, 120000, "A320"));
        A.add(new Voiture("566 tun 210", 2015, 60000));
        
        // Parcours de ArrayList, affichage des voitures, puis accélération des voitures de 50
        for (int i = 0; i < A.size(); i++) {
            // On vérifie si l'élément courant est une Voiture
            if (A.get(i) instanceof Voiture) {
                System.out.println(A.get(i));
                
                // Récupération de la voiture de ArrayList vers Vt (Transtypage / Cast)
                Voiture Vt = (Voiture) A.get(i);
                Vt.demarrer();
                // Accélération par 50
                Vt.accelerer(50);
            }
        }
    }
}

Classe Test - Version 2 (Saisie des données au clavier)

Cette version modifie la méthode main pour permettre à l'utilisateur de créer dynamiquement les objets via la console en utilisant la classe Scanner.

Une technique importante à remarquer ici est l'utilisation de input.nextLine() juste après les input.nextInt() ou input.nextDouble(). Cela permet de "consommer" le caractère de retour à la ligne (Entrée) laissé dans le tampon du clavier, évitant ainsi un bug classique où la prochaine lecture de chaîne de caractères est ignorée.

package Exercice2;
import java.util.*;

public class Test {

    public static void main(String[] args) {

        Scanner input = new Scanner(System.in);
        int reponse;
        String Mat, mod;
        int an;
        double prix;

        ArrayList A = new ArrayList();

        // Boucle pour l'ajout interactif des véhicules
        do {
            System.out.println("Si vous voulez Saisir une voiture tapez 1, si Avion tapez 2, quitter tapez 0");
            reponse = input.nextInt();
            
            if (reponse == 1) {
                System.out.println("Vous allez Saisir une voiture :");
                System.out.println("Donnez la Matricule de la voiture :");
                input.nextLine(); // Vidage du buffer
                Mat = input.nextLine();
                
                System.out.println("Donnez l'année du Modèle :");
                an = input.nextInt();
                
                System.out.println("Donnez le prix de la voiture :");
                prix = input.nextDouble();
                
                A.add(new Voiture(Mat, an, prix));
                
            } else if (reponse == 2) {
                System.out.println("Vous allez Saisir un Avion :");
                System.out.println("Donnez la Matricule de l'avion :");
                input.nextLine(); // Vidage du buffer
                Mat = input.nextLine();
                
                System.out.println("Donnez l'année du Modèle :");
                an = input.nextInt();
                
                System.out.println("Donnez le prix de l'Avion :");
                prix = input.nextDouble();
                
                System.out.println("Donnez le modèle de l'avion :");
                input.nextLine(); // Vidage du buffer
                mod = input.nextLine();
                
                A.add(new Avion(Mat, an, prix, mod));
            }

        } while (reponse != 0);

        // Parcours de ArrayList, affichage des voitures, puis accélération par 50
        for (int i = 0; i < A.size(); i++) {
            if (A.get(i) instanceof Voiture) {
                System.out.println(A.get(i));

                // Récupération et transtypage (cast)
                Voiture Vt = (Voiture) A.get(i);
                Vt.demarrer();
                Vt.accelerer(50);
            }
        }
        
        input.close(); // Bonne pratique : fermer le scanner à la fin
    }
}

Méthode

Face à un exercice de modélisation orientée objet, procédez toujours en trois étapes :

1. Identifier les entités et leurs relations : Repérez la classe générale (ici Vehicule) et les classes spécialisées (Voiture, Avion). Identifiez les attributs partagés à placer dans la classe mère, et les attributs spécifiques à placer dans les classes filles.
2. Gérer les responsabilités avec l'abstraction : Lorsqu'une action s'applique à toutes les classes filles mais s'exécute différemment (comme demarrer), déclarez la méthode comme abstract dans la classe mère. Cela garantit que chaque nouvelle classe fille sera obligée d'implémenter son propre comportement.
3. Exploiter le polymorphisme : Dans la méthode principale, rassemblez vos objets dans une collection générique (une liste de véhicules, et non une liste de voitures et une liste d'avions séparément). Utilisez l'opérateur instanceof uniquement lorsque vous avez besoin d'isoler un comportement spécifique à une classe enfant lors du parcours de la collection. À noter : dans un code Java moderne, il est préférable d'utiliser les types génériques pour la collection (ArrayList<Vehicule> A = new ArrayList<>();) afin de bénéficier du typage fort dès la compilation.