Examen Programmation par objets (Java)

Ce sujet porte sur un examen de programmation orientée objet en Java, évaluant la compréhension des concepts de classes, héritage, abstraction, gestion des attributs, méthodes et logique métier dans un contexte agricole simplifié.

Exercice 1

Question 1 : Modifier l'accesseur setSection de la classe Parcelle pour qu'il n'accepte que des chaînes d'un ou deux caractères, sinon afficher un message d'erreur et affecter "zzz".

public void setSection(String section) {
    if (section != null && (section.length() == 1 || section.length() == 2)) {
        this.section = section;
    } else {
        System.out.println("Erreur : la section doit contenir un ou deux caractères.");
        this.section = "zzz";
    }
}

Explication : On vérifie la longueur de la chaîne passée en paramètre. Si elle est égale à 1 ou 2, on affecte la valeur à l'attribut. Sinon, on affiche un message d'erreur et on affecte "zzz".

Réponse : La méthode setSection modifiée est celle ci-dessus.

Question 2 : Écrire un main dans la classe Parcelle créant une parcelle p1 avec le constructeur sans paramètre, puis une parcelle p2 avec section "AB", numéro 234, superficie 3 hectares et propriétaire "Maximilien". Modifier ensuite la section de p1 en "B".

public static void main(String[] args) {
    Parcelle p1 = new Parcelle();
    Parcelle p2 = new Parcelle("AB", 234, 3.0, "Maximilien");
    p1.setSection("B");
}

Explication : On utilise le constructeur par défaut pour p1, puis le constructeur avec paramètres pour p2. Enfin, on modifie la section de p1 via l'accesseur setSection.

Réponse : Le code main ci-dessus répond à la question.

Exercice 2

Question 3 : Interdire la création d'instances propres de la classe ActiviteCulture.

Solution : Pour empêcher la création d'instances directes de la classe ActiviteCulture, il faut déclarer cette classe comme abstraite.

public abstract class ActiviteCulture {
    // reste du code
}

Explication : En Java, une classe abstraite ne peut pas être instanciée directement. Cela correspond à la demande.

Réponse : Ajouter le mot-clé abstract devant la déclaration de la classe ActiviteCulture.

Question 4 : Écrire la déclaration, attributs et constructeurs de la classe ActiviteTraitement, sous-classe de ActiviteCulture, avec un constructeur sans paramètres et un constructeur avec paramètres.

public class ActiviteTraitement extends ActiviteCulture {

    private String nomProduit;
    private boolean produitBio;
    private static double coutHebdoParHectare;
    private double quantiteHebdoParHectare;
    private double prixLitreProduit;

    public ActiviteTraitement() {
        super();
        // initialisations par défaut si nécessaire
    }

    public ActiviteTraitement(String nom, Parcelle parcelle, boolean[] calendrier, double revenuAnnuel,
                             String nomProduit, boolean produitBio, double quantiteHebdoParHectare,
                             double prixLitreProduit) {
        super(nom, parcelle, calendrier, revenuAnnuel);
        this.nomProduit = nomProduit;
        this.produitBio = produitBio;
        this.quantiteHebdoParHectare = quantiteHebdoParHectare;
        this.prixLitreProduit = prixLitreProduit;
    }
}

Explication : La classe hérite d'ActiviteCulture. On ajoute les attributs spécifiques. Le constructeur sans paramètres appelle le constructeur par défaut de la super-classe. Le constructeur complet initialise tous les attributs, y compris ceux hérités via super(...).

Réponse : Le code ci-dessus correspond à la déclaration demandée.

Question 5 : Écrire dans les classes d'activités une méthode double coutSemaineDePratique() abstraite dans ActiviteCulture, et sa version dans ActiviteTraitement calculant le coût hebdomadaire.

public abstract class ActiviteCulture {
    // autres attributs et méthodes

    public abstract double coutSemaineDePratique();
}

public class ActiviteTraitement extends ActiviteCulture {
    // attributs et constructeurs déjà définis

    @Override
    public double coutSemaineDePratique() {
        double coutBase = coutHebdoParHectare; // coût main d'oeuvre et matériel
        double coutProduit = quantiteHebdoParHectare * prixLitreProduit;
        double taxe = 0.0;
        if (!produitBio) {
            taxe = 0.5 * quantiteHebdoParHectare;
        }
        return coutBase + coutProduit + taxe;
    }
}

Explication : La méthode est abstraite dans la classe mère. Dans ActiviteTraitement, on calcule le coût hebdomadaire en sommant le coût forfaitaire, le coût du produit (quantité × prix) et une taxe si le produit n'est pas bio.

Réponse : Le code ci-dessus répond à la question.

Question 6 : Écrire dans ActiviteCulture une méthode donnant le coût de l’activité pour une semaine i donnée, valant 0 si l’activité n’est pas pratiquée cette semaine, sinon coutSemaineDePratique.

public double coutSemaine(int i) {
    if (i < 0 || i >= calendrier.length) {
        return 0.0; // semaine hors calendrier
    }
    if (calendrier[i]) {
        return coutSemaineDePratique();
    } else {
        return 0.0;
    }
}

Explication : On vérifie si la semaine i est dans le calendrier. Si oui et que l’activité est pratiquée (calendrier[i] = true), on retourne le coût de la semaine, sinon 0.

Réponse : La méthode ci-dessus répond à la question.

Question 7 : Écrire dans ActiviteCulture une méthode donnant le coût annuel de l’activité.

public double coutAnnuel() {
    double total = 0.0;
    for (int i = 0; i < calendrier.length; i++) {
        total += coutSemaine(i);
    }
    return total;
}

Explication : On cumule le coût de chaque semaine où l’activité est pratiquée sur les 52 semaines.

Réponse : La méthode ci-dessus répond à la question.

Question 8 : Écrire dans ActiviteCulture une méthode boolean rentable() retournant vrai si le coût annuel est inférieur au revenu annuel.

public boolean rentable() {
    return coutAnnuel() < revenuAnnuel;
}

Explication : La rentabilité est définie par un revenu annuel supérieur au coût annuel.

Réponse : La méthode ci-dessus répond à la question.

Exercice 3

Question 9 : Écrire la déclaration, attributs et constructeur sans paramètres de la classe Exploitation, qui possède un nom et une liste d’activités initialement vide.

import java.util.ArrayList;
import java.util.List;

public class Exploitation {

    private String nom;
    private List<ActiviteCulture> activites;

    public Exploitation() {
        this.nom = "";
        this.activites = new ArrayList<>();
    }
}

Explication : La liste d’activités est initialisée vide dans le constructeur. Le nom est initialisé à une chaîne vide.

Réponse : Le code ci-dessus répond à la question.

Question 10 : Écrire une méthode dans Exploitation pour ajouter une activité passée en paramètre si elle n’est pas déjà présente.

public void ajouterActivite(ActiviteCulture activite) {
    if (!activites.contains(activite)) {
        activites.add(activite);
    }
}

Explication : On utilise la méthode contains pour vérifier la présence avant d’ajouter.

Réponse : La méthode ci-dessus répond à la question.

Question 11 : Écrire dans Exploitation une méthode coutAnnuel() retournant le coût annuel total de toutes les activités.

public double coutAnnuel() {
    double total = 0.0;
    for (ActiviteCulture activite : activites) {
        total += activite.coutAnnuel();
    }
    return total;
}

Explication : On cumule le coût annuel de chaque activité de la liste.

Réponse : La méthode ci-dessus répond à la question.

Question 12 : Écrire dans Exploitation une méthode activitesRentables() retournant la liste des activités rentables.

public List<ActiviteCulture> activitesRentables() {
    List<ActiviteCulture> rentables = new ArrayList<>();
    for (ActiviteCulture activite : activites) {
        if (activite.rentable()) {
            rentables.add(activite);
        }
    }
    return rentables;
}

Explication : On filtre la liste des activités selon la méthode rentable() et on retourne la liste filtrée.

Réponse : La méthode ci-dessus répond à la question.

Exercice 4

Question 13 : Déterminer l’affichage produit par le main de la classe LiaisonDynamique.

Analyse du code :

• Classe A : méthode m1 affiche "m1 dans A" puis appelle m2() abstraite.
• Classe B étend A, implémente m2() affichant "m2 dans B".
• Classe C étend B, redéfinit m1() affichant "m1 dans C" puis appelle super.m1() (m1 de A).
• Classe D étend C, redéfinit m2() affichant "m2 dans D" puis appelle super.m2() (m2 de B).
• Dans main, on crée une instance D et on appelle m1() sur cette instance.

Déroulement de l’exécution :

1. Appel de instD.m1() → méthode m1() de D n’existe pas, donc celle de C est appelée.
2. Dans m1() de C : affichage "m1 dans C".
3. Appel de super.m1() dans C → méthode m1() de A.
4. Dans m1() de A : affichage "m1 dans A".
5. Appel de m2() dans A. Comme l’objet est de type D, liaison dynamique appelle m2() de D.
6. Dans m2() de D : affichage "m2 dans D".
7. Appel de super.m2() dans D → m2() de B.
8. Dans m2() de B : affichage "m2 dans B".

Affichage final :

m1 dans C
m1 dans A
m2 dans D
m2 dans B

Réponse : Le programme affiche successivement :

• m1 dans C
• m1 dans A
• m2 dans D
• m2 dans B

Méthode

Ce sujet récompense la maîtrise des concepts fondamentaux de la programmation orientée objet en Java : définition et modification d'accesseurs, constructeurs, classes abstraites, héritage, redéfinition de méthodes, gestion des collections, et compréhension de la liaison dynamique.

Il est important de respecter les conventions données (notamment les noms d'attributs et méthodes) et de toujours justifier les étapes de raisonnement, notamment pour les calculs et la logique métier.

Les erreurs fréquentes à éviter sont :

• Ne pas vérifier la validité des paramètres dans les accesseurs.
• Oublier de déclarer une classe abstraite pour interdire l'instanciation.
• Ne pas appeler correctement les constructeurs des super-classes.
• Confondre liaison statique et liaison dynamique dans l'héritage.
• Ne pas gérer correctement les collections (ajout sans vérification de doublons).
• Omettre les cas limites (index hors bornes pour le calendrier).

Enfin, la rédaction claire et complète des méthodes avec les étapes intermédiaires est essentielle pour démontrer la compréhension.