Programmation Orientée Objet et Langage Java TP N° 3

Ce TP de Programmation Orientée Objet en Java vous guide dans la création d'une hiérarchie de classes représentant des véhicules, avec des calculs spécifiques de leur valeur actuelle. Vous apprendrez à définir des classes avec héritage, à redéfinir des méthodes, et à gérer des conversions de types en Java. Pour réaliser ce TP, vous devez disposer d'un environnement Java fonctionnel et connaître les bases de la programmation orientée objet.

Objectifs

• Définir des classes Java avec héritage.
• Implémenter des constructeurs et redéfinir la méthode toString.
• Écrire des méthodes pour calculer des valeurs spécifiques selon le type d'objet.
• Comprendre et appliquer les conversions de types (cast) en Java.
• Identifier les erreurs de compilation et d'exécution liées aux types.

Prérequis et configuration

• Un environnement de développement Java (JDK installé).
• Connaissances de base en programmation orientée objet : classes, héritage, méthodes.
• Notions sur les conversions de types et exceptions en Java.
• Un éditeur de texte ou un IDE pour écrire et compiler les fichiers .java.

Définition de la classe Vehicule

Commencez par créer un fichier nommé GestionVehicules.java. Dans ce fichier, définissez la classe Vehicule avec les attributs suivants :

• marque (String)
• date d'achat (int)
• prix d'achat (double)
• prix courant (double)

Le constructeur doit initialiser la marque, la date d'achat et le prix d'achat. Le prix courant sera calculé ultérieurement.

Redéfinissez la méthode toString pour afficher l'état complet de l'objet, c'est-à-dire la valeur de tous ses attributs.

Cette étape permet de poser la base commune à tous les types de véhicules.

public class Vehicule {
    protected String marque;
    protected int dateAchat;
    protected double prixAchat;
    protected double prixCourant;

    public Vehicule(String marque, int dateAchat, double prixAchat) {
        this.marque = marque;
        this.dateAchat = dateAchat;
        this.prixAchat = prixAchat;
    }

    @Override
    public String toString() {
        return "Marque : " + marque + ", Date d'achat : " + dateAchat +
               ", Prix d'achat : " + prixAchat + ", Prix courant : " + prixCourant;
    }
}

Définition des classes Voiture et Avion

Créez deux classes Voiture et Avion qui héritent de Vehicule.

Ajoutez les attributs spécifiques :

• Voiture : cylindrée (int), nombre de portes (int), puissance (int), kilométrage (int)
• Avion : type (String : "hélices" ou "réaction"), nombre d'heures de vol (int)

Chaque classe doit avoir un constructeur initialisant tous les attributs, y compris ceux hérités. Redéfinissez aussi la méthode toString pour afficher toutes les informations, en appelant la méthode parente.

Cette étape illustre l'héritage et la spécialisation des classes.

public class Voiture extends Vehicule {
    private int cylindree;
    private int nbPortes;
    private int puissance;
    private int kilometrage;

    public Voiture(String marque, int dateAchat, double prixAchat,
                   int cylindree, int nbPortes, int puissance, int kilometrage) {
        super(marque, dateAchat, prixAchat);
        this.cylindree = cylindree;
        this.nbPortes = nbPortes;
        this.puissance = puissance;
        this.kilometrage = kilometrage;
    }

    @Override
    public String toString() {
        return super.toString() + ", Cylindrée : " + cylindree + " cm3, Portes : " + nbPortes +
               ", Puissance : " + puissance + " CV, Kilométrage : " + kilometrage + " km";
    }
}

public class Avion extends Vehicule {
    private String type; // "hélices" ou "réaction"
    private int nbHeuresVol;

    public Avion(String marque, int dateAchat, double prixAchat,
                 String type, int nbHeuresVol) {
        super(marque, dateAchat, prixAchat);
        this.type = type;
        this.nbHeuresVol = nbHeuresVol;
    }

    @Override
    public String toString() {
        return super.toString() + ", Type : " + type + ", Heures de vol : " + nbHeuresVol;
    }
}

Implémentation de la méthode calculePrix

Ajoutez dans la classe Vehicule la méthode void calculePrix(int anneeActuelle) qui calcule le prix courant en appliquant une dépréciation simple de 1% par année écoulée depuis la date d'achat :

prixCourant = prixAchat - (prixAchat * 0.01 * (anneeActuelle - dateAchat))

Redéfinissez cette méthode dans Voiture et Avion pour appliquer des règles spécifiques :

• Voiture :
  • 2% de dépréciation par année
  • 5% de dépréciation par tranche de 10 000 km parcourus
  • 10% de dépréciation supplémentaire si la marque est "Renault" ou "Fiat"
  • 20% de dépréciation supplémentaire si la marque est "Ferrari" ou "Porsche"
• Avion :
  • Si avion à réaction : 10% de dépréciation par tranche de 1000 heures de vol
  • Si avion à hélices : 10% de dépréciation par tranche de 100 heures de vol

Le prix courant ne doit jamais être négatif. S'il l'est, il faut le fixer à 0.

Cette étape montre la surcharge de méthodes et l'adaptation du comportement selon le type d'objet.

@Override
public void calculePrix(int anneeActuelle) {
    int age = anneeActuelle - dateAchat;
    prixCourant = prixAchat - (prixAchat * 0.01 * age);
    if (prixCourant < 0) prixCourant = 0;
}

@Override
public void calculePrix(int anneeActuelle) {
    int age = anneeActuelle - dateAchat;
    double prix = prixAchat;
    prix -= prixAchat * 0.02 * age;
    prix -= prixAchat * 0.05 * (kilometrage / 10000);
    if (marque.equals("Renault") || marque.equals("Fiat")) {
        prix -= prixAchat * 0.10;
    } else if (marque.equals("Ferrari") || marque.equals("Porsche")) {
        prix -= prixAchat * 0.20;
    }
    prixCourant = prix > 0 ? prix : 0;
}

@Override
public void calculePrix(int anneeActuelle) {
    double prix = prixAchat;
    if (type.equals("réaction")) {
        prix -= prixAchat * 0.10 * (nbHeuresVol / 1000);
    } else if (type.equals("hélices")) {
        prix -= prixAchat * 0.10 * (nbHeuresVol / 100);
    }
    prixCourant = prix > 0 ? prix : 0;
}

Analyse des instructions de la classe Test

Examinez la classe Test suivante et déterminez si les instructions 1 à 8 sont valides. En cas d'erreur, précisez s'il s'agit d'une erreur de compilation ou d'exécution.

class Test {
    public static void main(String[] args) {
        C1 o1 = new C1();       // V
        C1 o2 = new C11();      // V
        C111 o3 = new C111();   // V
        C11 o4 = new C111();    // V
        C1 o5 = new C111();     // V

        o1 = o2;                // instruction1 : valide
        o1 = o3;                // instruction2 : valide
        o3 = o1;                // instruction3 : erreur de compilation
                                // car o1 est de type C1, plus général que C111
        o4 = o5;                // instruction4 : erreur de compilation
                                // o5 est C1, on attend un C11 ou C111
        o3 = (C111) o1;         // instruction5 : valide (cast explicite)
        o4 = (C11) o5;          // instruction6 : valide (cast explicite)
        o4 = (C111) o2;         // instruction7 : erreur d'exécution (ClassCastException)
                                // o2 est C1 mais pas forcément C111
        o3 = (C11) o5;          // instruction8 : erreur de compilation
                                // on attend un C111, pas un C11
    }
}

class C1 {}
class C11 extends C1 {}
class C111 extends C11 {}

Cette analyse vous permet de comprendre les règles de typage et les conversions en Java, ainsi que les erreurs possibles.

Résultats attendus

• Les classes Vehicule, Voiture et Avion doivent être correctement définies avec leurs attributs et constructeurs.
• La méthode toString doit afficher toutes les informations des objets.
• La méthode calculePrix doit mettre à jour l'attribut prixCourant selon les règles données, sans jamais être négative.
• Les instructions valides dans la classe Test compilent et s'exécutent sans erreur.
• Les instructions invalides provoquent soit une erreur de compilation, soit une erreur d'exécution (ClassCastException) comme indiqué.

Erreurs fréquentes

• Oublier d'appeler le constructeur de la classe parente dans les sous-classes.
• Ne pas redéfinir correctement la méthode toString pour afficher les attributs hérités.
• Ne pas vérifier que le prix courant reste positif après calcul.
• Confondre les types lors des conversions, ce qui entraîne des erreurs de compilation ou d'exécution.
• Ne pas respecter les règles de dépréciation spécifiques à chaque type de véhicule.