Système de Transport de Véhicules

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

classDiagram
    class Vehicule {
        <<abstract>>
        -int engine
        #String brand
        +Vehicule(String brand, int engine)
        +start()* void
        +stop()* void
    }
    class Plane {
        -boolean trainAtterissageActif
        +Plane(String brand, int engine)
        +start() void
        +stop() void
        +sortirTrainAtterissage() void
        +rentrerTrainAtterissage() void
        +fly() void
    }
    class Car {
        -int nbDoor
        +Car(String brand, int engine, int nbDoor)
        +start() void
        +stop() void
    }
    class Parking {
        -String name
        -List~Vehicule~ vehicles
        +Parking(String name)
        +add(Vehicule v) void
        +startAllVehicles() void
    }
    class Boat {
        +Boat(String brand, int engine)
        +start() void
        +stop() void
        +sail() void
    }
    Car --|> Vehicule
    Plane --|> Vehicule
    Boat --|> Vehicule
    Parking "1" --> "0..*" Vehicule

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:

Créer la classe de base abstraite Vehicule avec des méthodes abstraites
Implémenter les trois classes de véhicules (Car, Plane, Boat) étendant Vehicule
Surcharger les méthodes abstraites avec un comportement spécifique pour chaque type de véhicule
Implémenter la classe Parking qui gère une collection de véhicules
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(...))