Aller au contenu principal

Système de Transport de Véhicules

Hiérarchie d'héritage pour différents types de véhicules avec gestion de parking

Vehicule (Classe de Base Abstraite)​

La classe parente abstraite pour tous les types de véhicules.

  • engine: Taille ou puissance du moteur (privé)
  • brand: Nom de la marque du véhicule (protégé - accessible aux sous-classes)
  • Vehicule(String brand, int engine): Constructeur pour initialiser la marque et le moteur
  • start(): Méthode abstraite - doit être implémentée par les sous-classes
  • stop(): Méthode abstraite - doit être implémentée par les sous-classes
  • La marque protégée permet aux sous-classes d'accéder aux informations de la marque
  • Ne peut pas être instanciée directement - sert de modèle pour les types de véhicules concrets

Car​

Véhicule automobile avec portes.

  • nbDoor: Nombre de portes (attribut privé)
  • Car(String brand, int engine, int nbDoor): Constructeur acceptant la marque, le moteur et le nombre de portes
  • Hérite de Vehicule
  • Surcharge start() et stop() pour un comportement spécifique aux voitures (ex: "Démarrage du moteur de la voiture...")

Plane​

Aéronef avec mécanisme de train d'atterrissage.

  • trainAtterissageActif: Statut actif du train d'atterrissage (booléen privé)
  • Plane(String brand, int engine): Constructeur qui appelle super() et initialise le train d'atterrissage à false
  • start(): Surcharge pour vérifier si le train d'atterrissage est déployé avant le démarrage
  • stop(): Surcharge pour assurer des procédures d'atterrissage sûres
  • sortirTrainAtterissage(): Déployer le train d'atterrissage (met trainAtterissageActif à true)
  • rentrerTrainAtterissage(): Rétracter le train d'atterrissage (met trainAtterissageActif à false)
  • fly(): Méthode de vol spécifique à l'avion (ne peut voler que si le train d'atterrissage est rétracté)
  • Hérite de Vehicule

Boat​

Embarcation avec capacité de navigation.

  • Boat(String brand, int engine): Constructeur qui appelle super() avec la marque et le moteur
  • start(): Surcharge pour démarrer le moteur du bateau
  • stop(): Surcharge pour arrêter le moteur du bateau
  • sail(): Méthode de navigation spécifique au bateau pour la navigation sur l'eau
  • Hérite de Vehicule

Parking​

Gère une collection de véhicules.

  • name: Nom du parking (attribut privé)
  • vehicles: Liste des véhicules dans le parking (List<Vehicule> privée)
  • Peut contenir zéro ou plusieurs véhicules (relation un-à-plusieurs avec Vehicule)
  • Parking(String name): Constructeur pour initialiser le nom du parking et la liste vide de véhicules
  • add(Vehicule v): Ajouter un véhicule au parking
  • startAllVehicles(): Parcourir tous les véhicules garés et appeler leur méthode start()
  • Démontre le polymorphisme - peut stocker tout type de Vehicule (Car, Plane, Boat)

Exercice Pratique : Implémenter le Système de Véhicules​

Objectif: Implémenter le système de transport de véhicules complet avec classe de base abstraite et polymorphisme.

Exigences:

  1. Créer la classe de base abstraite Vehicule avec des méthodes abstraites
  2. Implémenter les trois classes de véhicules (Car, Plane, Boat) étendant Vehicule
  3. Surcharger les méthodes abstraites avec un comportement spécifique pour chaque type de véhicule
  4. Implémenter la classe Parking qui gère une collection de véhicules
  5. Démontrer le polymorphisme en stockant différents types de véhicules dans le même parking
💡 Cliquer pour voir l'implémentation suggérée
// Classe de base abstraite
public abstract class Vehicule {
    private int engine;
    protected String brand;

    public Vehicule(String brand, int engine) {
        this.brand = brand;
        this.engine = engine;
    }

    // Méthodes abstraites - doivent être implémentées par les sous-classes
    public abstract void start();
    public abstract void stop();

    public int getEngine() { return engine; }
    public String getBrand() { return brand; }
}

// Classe Car
public class Car extends Vehicule {
    private int nbDoor;

    public Car(String brand, int engine, int nbDoor) {
        super(brand, engine);
        this.nbDoor = nbDoor;
    }

    @Override
    public void start() {
        System.out.println("Voiture " + brand + " avec " + nbDoor + " portes: Démarrage du moteur...");
    }

    @Override
    public void stop() {
        System.out.println("Voiture " + brand + ": Arrêt du moteur...");
    }

    public int getNbDoor() { return nbDoor; }
}

// Classe Plane
public class Plane extends Vehicule {
    private boolean trainAtterissageActif;

    public Plane(String brand, int engine) {
        super(brand, engine);
        this.trainAtterissageActif = false;  // Rétracté par défaut
    }

    @Override
    public void start() {
        if (trainAtterissageActif) {
            System.out.println("Avion " + brand + ": Moteurs démarrés. Train d'atterrissage déployé.");
        } else {
            System.out.println("ATTENTION: Train d'atterrissage non déployé!");
        }
    }

    @Override
    public void stop() {
        System.out.println("Avion " + brand + ": Moteurs arrêtés. Préparation pour l'atterrissage.");
    }

    public void sortirTrainAtterissage() {
        trainAtterissageActif = true;
        System.out.println("Avion " + brand + ": Train d'atterrissage déployé.");
    }

    public void rentrerTrainAtterissage() {
        trainAtterissageActif = false;
        System.out.println("Avion " + brand + ": Train d'atterrissage rétracté.");
    }

    public void fly() {
        if (!trainAtterissageActif) {
            System.out.println("Avion " + brand + ": En vol!");
        } else {
            System.out.println("ERREUR: Impossible de voler avec le train d'atterrissage déployé!");
        }
    }
}

// Classe Boat
public class Boat extends Vehicule {

    public Boat(String brand, int engine) {
        super(brand, engine);
    }

    @Override
    public void start() {
        System.out.println("Bateau " + brand + ": Moteur démarré pour la navigation...");
    }

    @Override
    public void stop() {
        System.out.println("Bateau " + brand + ": Moteur arrêté. Ancre jetée...");
    }

    public void sail() {
        System.out.println("Bateau " + brand + ": Navigation sur l'eau!");
    }
}

// Classe Parking
import java.util.ArrayList;
import java.util.List;

public class Parking {
    private String name;
    private List<Vehicule> vehicles;

    public Parking(String name) {
        this.name = name;
        this.vehicles = new ArrayList<>();
    }

    public void add(Vehicule v) {
        vehicles.add(v);
        System.out.println("Véhicule ajouté au parking " + name + ".");
    }

    public void startAllVehicles() {
        System.out.println("\n=== Démarrage de tous les véhicules dans " + name + " ===");
        for (Vehicule v : vehicles) {
            v.start();  // Polymorphisme - appelle la méthode start() appropriée
        }
    }

    public String getName() { return name; }
    public int getVehicleCount() { return vehicles.size(); }
}

// Exemple d'utilisation
public class VehiculeDemo {
    public static void main(String[] args) {
        // Créer un parking
        Parking parking = new Parking("Parking Centre-Ville");

        // Créer différents types de véhicules
        Car car1 = new Car("Toyota", 2000, 4);
        Car car2 = new Car("BMW", 3000, 2);
        Plane plane = new Plane("Boeing", 50000);
        Boat boat = new Boat("Yamaha", 500);

        // Ajouter des véhicules au parking (polymorphisme)
        parking.add(car1);
        parking.add(car2);
        parking.add(plane);
        parking.add(boat);

        // Démarrer tous les véhicules en utilisant le polymorphisme
        parking.startAllVehicles();

        System.out.println("\n=== Opérations spécifiques à l'avion ===");
        plane.sortirTrainAtterissage();
        plane.fly();  // Ne fonctionnera pas avec le train déployé
        plane.rentrerTrainAtterissage();
        plane.fly();  // Maintenant ça fonctionne

        System.out.println("\n=== Opérations spécifiques au bateau ===");
        boat.sail();
    }
}

Points Clés d'Implémentation:

  • Utiliser le mot-clé abstract pour la classe Vehicule et ses méthodes
  • Toutes les sous-classes DOIVENT implémenter les méthodes abstraites start() et stop()
  • Utiliser l'annotation @Override lors de la surcharge des méthodes
  • Appeler super(brand, engine) dans les constructeurs des sous-classes
  • Parking utilise List<Vehicule> pour démontrer le polymorphisme
  • Les classes abstraites ne peuvent pas être instanciées directement (impossible de faire new Vehicule(...))