Révision de Gestion d'Agence de Location de Voitures

Ce matériel couvre la conception et l'implémentation d'une solution de gestion pour une agence de location de voitures. Il s'adresse aux étudiants en informatique ou en génie logiciel souhaitant apprendre à modéliser un système orienté objet avec des classes, interfaces, collections et méthodes de tri.

Modélisation des classes principales

Le système comprend trois classes principales : Voiture, Client et Agence.

Classe Voiture

Une voiture est caractérisée par :

• un numéro d'immatriculation (int)
• une marque (String)
• un prix de location (float)

Deux voitures sont considérées égales si elles ont la même immatriculation et la même marque.

public class Voiture {
    private int immatriculation;
    private String marque;
    private float prixLocation;

    public Voiture(int immatriculation, String marque, float prixLocation) {
        this.immatriculation = immatriculation;
        this.marque = marque;
        this.prixLocation = prixLocation;
    }

    public int getImmatriculation() {
        return immatriculation;
    }

    public void setImmatriculation(int immatriculation) {
        this.immatriculation = immatriculation;
    }

    public String getMarque() {
        return marque;
    }

    public void setMarque(String marque) {
        this.marque = marque;
    }

    public float getPrixLocation() {
        return prixLocation;
    }

    public void setPrixLocation(float prixLocation) {
        this.prixLocation = prixLocation;
    }

    @Override
    public int hashCode() {
        return immatriculation * 31 + (marque == null ? 0 : marque.hashCode());
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (obj == null || getClass() != obj.getClass()) return false;
        Voiture other = (Voiture) obj;
        return immatriculation == other.immatriculation &&
               (marque == null ? other.marque == null : marque.equals(other.marque));
    }

    @Override
    public String toString() {
        return "Voiture{" +
               "immatriculation=" + immatriculation +
               ", marque='" + marque + '\'' +
               ", prixLocation=" + prixLocation +
               '}';
    }
}

Classe Client

Un client est défini par :

• un code (int)
• un nom (String)
• un prénom (String)

Deux clients sont égaux s'ils ont le même code.

public class Client {
    private int code;
    private String nom;
    private String prenom;

    public Client(int code, String nom, String prenom) {
        this.code = code;
        this.nom = nom;
        this.prenom = prenom;
    }

    public int getCode() {
        return code;
    }

    public void setCode(int code) {
        this.code = code;
    }

    public String getNom() {
        return nom;
    }

    public void setNom(String nom) {
        this.nom = nom;
    }

    public String getPrenom() {
        return prenom;
    }

    public void setPrenom(String prenom) {
        this.prenom = prenom;
    }

    @Override
    public int hashCode() {
        return code;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (obj == null || getClass() != obj.getClass()) return false;
        Client other = (Client) obj;
        return code == other.code;
    }

    @Override
    public String toString() {
        return "Client{" +
               "code=" + code +
               ", nom='" + nom + '\'' +
               ", prenom='" + prenom + '\'' +
               '}';
    }
}

Gestion des collections de voitures

Classe ListVoitures

Cette classe permet de gérer une liste de voitures. Elle offre des méthodes pour :

• ajouter une voiture
• supprimer une voiture
• afficher la liste des voitures

public class ListVoitures {
    private List<Voiture> voitures;

    public ListVoitures() {
        voitures = new ArrayList<>();
    }

    public ListVoitures(List<Voiture> voitures) {
        this.voitures = voitures;
    }

    public List<Voiture> getVoitures() {
        return voitures;
    }

    public void setVoitures(List<Voiture> voitures) {
        this.voitures = voitures;
    }

    public void ajouterVoiture(Voiture v) {
        if (!voitures.contains(v)) {
            voitures.add(v);
        }
    }

    public void supprimerVoiture(Voiture v) {
        voitures.remove(v);
    }

    public void afficher() {
        for (Voiture v : voitures) {
            System.out.println(v);
        }
    }
}

Sélection des voitures selon des critères

Pour permettre aux clients de choisir des voitures selon différents critères, on définit une interface Critere :

public interface Critere {
    boolean estSatisfaitPar(Voiture v);
}

Critère selon la marque

public class CritereMarque implements Critere {
    private String marque;

    public CritereMarque(String marque) {
        this.marque = marque;
    }

    @Override
    public boolean estSatisfaitPar(Voiture v) {
        return v.getMarque().equalsIgnoreCase(marque);
    }
}

Critère selon le prix

public class CriterePrix implements Critere {
    private float prix;

    public CriterePrix(float prix) {
        this.prix = prix;
    }

    @Override
    public boolean estSatisfaitPar(Voiture v) {
        return v.getPrixLocation() <= prix;
    }
}

Exemple d'utilisation des critères

Supposons que l'on souhaite sélectionner toutes les voitures de marque "Toyota" dont le prix est inférieur ou égal à 50.0 :

ListVoitures toutesVoitures = new ListVoitures();
// ... ajout de voitures dans toutesVoitures ...

Critere critereMarque = new CritereMarque("Toyota");
Critere criterePrix = new CriterePrix(50.0f);

ListVoitures selectionMarque = new ListVoitures();
for (Voiture v : toutesVoitures.getVoitures()) {
    if (critereMarque.estSatisfaitPar(v)) {
        selectionMarque.ajouterVoiture(v);
    }
}

ListVoitures selectionPrix = new ListVoitures();
for (Voiture v : selectionMarque.getVoitures()) {
    if (criterePrix.estSatisfaitPar(v)) {
        selectionPrix.ajouterVoiture(v);
    }
}

selectionPrix.afficher();

Classe Agence

L'agence est caractérisée par :

• un nom (String)
• un parking de type ListVoitures pour stocker les voitures disponibles
• une map ClientVoitureLoue de type Map<Client, ListVoitures> pour enregistrer les voitures louées par chaque client

Les principales fonctionnalités sont :

• louer une voiture à un client
• retourner une voiture louée par un client
• retourner la liste des voitures selon un critère
• retourner l'ensemble des clients ayant loué une ou plusieurs voitures
• afficher les clients et leurs voitures louées
• trier les clients selon leur code ou leur nom

public class Agence {
    private String nom;
    private ListVoitures vs; // voitures disponibles
    private Map<Client, ListVoitures> ClientVoitureLoue;

    public Agence(String nom) {
        this.nom = nom;
        this.vs = new ListVoitures();
        this.ClientVoitureLoue = new HashMap<>();
    }

    public void ajoutVoiture(Voiture v) throws VoitureException {
        if (vs.getVoitures().contains(v)) {
            throw new VoitureException("Voiture déjà présente");
        }
        vs.ajouterVoiture(v);
    }

    public void suppVoiture(Voiture v) throws VoitureException {
        if (!vs.getVoitures().contains(v)) {
            throw new VoitureException("Voiture non trouvée");
        }
        vs.supprimerVoiture(v);
    }

    public void loueClientVoiture(Client cl, Voiture v) throws VoitureException {
        if (!vs.getVoitures().contains(v)) {
            throw new VoitureException("Voiture non disponible");
        }
        vs.supprimerVoiture(v);
        ListVoitures voituresLouees = ClientVoitureLoue.getOrDefault(cl, new ListVoitures());
        voituresLouees.ajouterVoiture(v);
        ClientVoitureLoue.put(cl, voituresLouees);
    }

    public void retourClientVoiture(Client cl, Voiture v) throws VoitureException {
        ListVoitures voituresLouees = ClientVoitureLoue.get(cl);
        if (voituresLouees == null || !voituresLouees.getVoitures().contains(v)) {
            throw new VoitureException("Voiture non louée par ce client");
        }
        voituresLouees.supprimerVoiture(v);
        if (voituresLouees.getVoitures().isEmpty()) {
            ClientVoitureLoue.remove(cl);
        } else {
            ClientVoitureLoue.put(cl, voituresLouees);
        }
        vs.ajouterVoiture(v);
    }

    public List<Voiture> selectVoitureSelonCritere(Critere c) {
        List<Voiture> selection = new ArrayList<>();
        for (Voiture v : vs.getVoitures()) {
            if (c.estSatisfaitPar(v)) {
                selection.add(v);
            }
        }
        return selection;
    }

    public Set<Client> ensembleClientsLoueurs() {
        return ClientVoitureLoue.keySet();
    }

    public Collection<ListVoitures> collectionVoituresLouees() {
        return ClientVoitureLoue.values();
    }

    public void afficheLesClientsEtLeursListesVoitures() {
        for (Map.Entry<Client, ListVoitures> entry : ClientVoitureLoue.entrySet()) {
            System.out.println(entry.getKey());
            entry.getValue().afficher();
        }
    }

    public Map<Client, ListVoitures> triCodeCroissant() {
        Map<Client, ListVoitures> tri = new TreeMap<>(Comparator.comparingInt(Client::getCode));
        tri.putAll(ClientVoitureLoue);
        return tri;
    }

    public Map<Client, ListVoitures> triNomCroissant() {
        Map<Client, ListVoitures> tri = new TreeMap<>(Comparator.comparing(Client::getNom));
        tri.putAll(ClientVoitureLoue);
        return tri;
    }
}

Exemple d'utilisation de la classe Agence

Agence agence = new Agence("Agence Centrale");

// Ajout de voitures
agence.ajoutVoiture(new Voiture(1234, "Toyota", 45.0f));
agence.ajoutVoiture(new Voiture(5678, "Ford", 50.0f));

// Création d'un client
Client client1 = new Client(1, "Dupont", "Jean");

// Location d'une voiture
agence.loueClientVoiture(client1, new Voiture(1234, "Toyota", 45.0f));

// Affichage des clients et leurs voitures louées
agence.afficheLesClientsEtLeursListesVoitures();

Glossaire des termes clés

• Voiture : Entité représentant un véhicule avec immatriculation, marque et prix de location.
• Client : Personne caractérisée par un code unique, un nom et un prénom.
• ListVoitures : Classe gérant une collection de voitures avec ajout, suppression et affichage.
• Critere : Interface définissant un critère de sélection de voitures.
• CritereMarque : Critère de sélection basé sur la marque d'une voiture.
• CriterePrix : Critère de sélection basé sur le prix de location d'une voiture.
• Agence : Classe représentant l'agence de location, gérant les voitures disponibles et les locations par client.
• Map<Client, ListVoitures> : Structure associant chaque client à la liste des voitures qu'il loue.
• VoitureException : Exception levée en cas d'erreur liée à la gestion des voitures.

Points clés à retenir

• La modélisation orientée objet permet de structurer clairement les entités et leurs relations dans une agence de location.
• La gestion des collections est facilitée par des classes dédiées comme ListVoitures et l'utilisation de Map pour associer clients et voitures louées.
• L'interface Critere permet de définir des filtres flexibles pour la sélection des voitures.
• Les méthodes de tri permettent d'organiser les données clients selon différents attributs (code, nom).
• La gestion des exceptions est importante pour garantir la cohérence des opérations de location et retour de voitures.