Correction TD5 : Implémentation des interfaces VendableKilo et vendablePiece en Java

Implémentation des Interfaces

Les interfaces définissent un contrat que les classes devront respecter. Ici, le sujet demande de distinguer la vente au kilogramme et la vente à la pièce. Chaque interface déclare une méthode abstraite vendre avec une signature adaptée au type de quantité (un entier pour les pièces, un décimal pour les kilos).

Remarque : Comme précisé dans l'énoncé, dans un vrai projet Java, chaque interface et classe publique doit être dans un fichier séparé.

public interface VendableKilo {
    // cette méthode retourne le revenu de la vente
    public abstract double vendre(double qte);
}

public interface vendablePiece {
    // cette méthode retourne le revenu de la vente
    public abstract double vendre(int qte);
}

La Classe de Base : Article

La classe Article est la superclasse qui contient les attributs et méthodes communs à tous les produits du magasin. On y trouve le prix d'achat, le prix de vente, le nom et le fournisseur.

Notez la présence de la méthode rendement() qui calcule la marge bénéficiaire selon la formule : (prixVente - prixAchat) ÷ prixAchat. L'encapsulation est respectée grâce aux attributs private et aux méthodes "Getter". (L'OCR avait coupé la signature du constructeur, elle a été réunifiée ici pour garantir une compilation correcte).

public class Article {

    private double prixAchat;
    private double prixVente;
    private String Nom;
    private String Fournisseur;

    // Constructeur
    public Article(double prixAchat, double prixVente, String Nom, String Fournisseur) {
        this.prixAchat = prixAchat;
        this.prixVente = prixVente;
        this.Nom = Nom;
        this.Fournisseur = Fournisseur;
    }

    // Les methodes Getter
    public double GetprixAchat() {
        return prixAchat;
    }

    public double GetprixVente() {
        return prixVente;
    }

    // Méthodes
    public double rendement() {
        return (prixVente - prixAchat) / prixAchat;
    }

    public void info() {
        System.out.println("Nom du produit:" + Nom);
        System.out.println("Fournisseur: " + Fournisseur);
        System.out.println("Prix d'achat: " + prixAchat);
        System.out.println("Prix de vente: " + prixVente);
    }
}

Les Classes Spécifiques

Ces deux classes héritent de la classe Article (mot-clé extends) et implémentent chacune l'interface appropriée (mot-clé implements). Elles ajoutent la gestion du stock spécifique à leur type.

La Classe ArticleElectromenager

Cette classe gère un stock sous forme d'entier (pièces). L'appel super(pA, pV, n, f) dans le constructeur est indispensable pour initialiser les attributs hérités de la classe parente.

Note du correcteur sur la logique métier : L'implémentation de la méthode vendre utilise la condition stricte qte < stock. Bien que nous reproduisions le code source tel quel, gardez à l'esprit que dans une situation réelle, il serait plus logique d'utiliser qte <= stock afin de pouvoir vendre la totalité du stock disponible.

public class ArticleElectromenager extends Article implements vendablePiece {
    public int stock;

    // Constructeur
    public ArticleElectromenager(double pA, double pV, String n, String f) {
        super(pA, pV, n, f);
        stock = 0;
    }

    // Nouvelles méthodes
    public double RemplirStock(int qte) {
        stock = stock + qte;
        return GetprixAchat() * qte;
    }

    // Méthode surécrite
    public void info() {
        super.info();
        System.out.println("Le stock du produit est " + stock + " pièce(s).");
    }

    // Implementation de l'interface vendablePiece
    public double vendre(int qte) {
        if (qte < stock) {
            stock = stock - qte;
            return qte * GetprixVente();
        } else {
            System.out.println(" Stock insuffisant!!! ");
            return 0;
        }
    }
}

La Classe ArticlePrimeur

La structure est identique à ArticleElectromenager, mais adaptée pour des quantités décimales (double).

public class ArticlePrimeur extends Article implements VendableKilo {
    public double stock;

    // Constructeur
    public ArticlePrimeur(double pA, double pV, String n, String f) {
        super(pA, pV, n, f);
        stock = 0.0;
    }

    // Nouvelles méthodes
    public double RemplirStock(double qte) {
        stock = stock + qte;
        return GetprixAchat() * qte;
    }

    // Méthode surécrite
    public void info() {
        super.info();
        System.out.println("Le stock du produit est " + stock + " kilogramme(s).");
    }

    // Implementation de l'interface vendableKilo
    public double vendre(double qte) {
        if (qte < stock) {
            stock = stock - qte;
            return qte * GetprixVente();
        } else {
            System.out.println(" Stock insuffisant!!! ");
            return 0;
        }
    }
}

Gestion Globale avec la Classe Magasin

La classe Magasin agrège les articles dans deux tableaux distincts. Elle maintient les revenus et les dépenses globales. Remarquez que la méthode RemplirStock des articles est conçue pour renvoyer le coût d'achat total de la quantité ajoutée, ce qui permet à Magasin d'incrémenter ses dépenses facilement.

public class Magasin {
    public static int choixE = 2; // choixE est la taille du tableau Ae
    public static int choixP = 2; // choixP est la taille du tableau Ap

    public double Revenu;
    public double Depense;
    public ArticleElectromenager[] Ae;
    public ArticlePrimeur[] Ap;

    // Constructeur
    public Magasin() {
        Ae = new ArticleElectromenager[choixE];
        Ap = new ArticlePrimeur[choixP];
        Revenu = 0;
        Depense = 0;
    }

    // Méthodes
    public double rendement() {
        return (Revenu - Depense) / Depense;
    }

    public void info() {
        System.out.println("=======Informations Générales ======");
        System.out.println("Les depenses du magasin: " + Depense);
        System.out.println("Les revenus du magasin: " + Revenu);
        System.out.println("Le rendement: " + rendement());
        System.out.println("====================================");
        System.out.println("======= Liste des produits ======");
        System.out.println("====================================");
        
        for (int i = 0; i < choixE; i++) {
            System.out.println("***Produit Electromenager n°" + (i + 1) + "***");
            Ae[i].info();
            System.out.println("****************************************");
        }
        
        for (int i = 0; i < choixP; i++) {
            System.out.println("***Produit Primeur n°" + (i + 1) + "***");
            Ap[i].info();
            System.out.println("****************************************");
        }
    }
}

Le Programme Principal : testMagasin

Cette classe sert de point d'entrée pour tester notre architecture. Attention : Dans cet exemple précis, le programme instancie les objets, remplit les stocks et met à jour les dépenses du magasin, mais aucune méthode vendre n'est appelée. Par conséquent, lors de l'exécution, les revenus du magasin resteront à 0 et le rendement calculé sera de -1 (soit -100%, puisque seules les dépenses sont comptabilisées).

public class testMagasin {
    public static void main(String[] args) {
        Magasin M1 = new Magasin();
        
        // Les produits a vendre
        M1.Ae[0] = new ArticleElectromenager(27000, 35000, "télé", "Samsung");
        M1.Ae[1] = new ArticleElectromenager(5000, 15000, "radio", "Sony");
        
        M1.Ap[0] = new ArticlePrimeur(100, 200, "tomate", "Abdi, Tunisie");
        M1.Ap[1] = new ArticlePrimeur(300, 500, "Poivre", "Abdi, Tunisie");
        
        // Remplir les stocks
        for (int i = 0; i < M1.choixE; i++) { 
            M1.Depense += M1.Ae[i].RemplirStock(50);
        }

        for (int i = 0; i < M1.choixP; i++) { 
            M1.Depense += M1.Ap[i].RemplirStock(100);
        }
        
        // Avoir les info
        M1.info();
    }
}

Méthode

Face à un tel exercice d'implémentation de la Programmation Orientée Objet (POO), voici la marche à suivre recommandée :

1. Identifier les entités et contrats : Repérez d'abord ce qui relève de l'héritage (relation "est un", ex: un ArticlePrimeur est un Article) et ce qui relève des interfaces (relation "sait faire", ex: est vendable au kilo).
2. Respecter l'encapsulation : Les attributs d'une classe parente (prixAchat, prixVente) doivent idéalement être private. Les classes enfants doivent obligatoirement utiliser les méthodes get...() pour y accéder.
3. Appel au constructeur parent : N'oubliez jamais d'utiliser super(...) à la toute première ligne du constructeur de la classe fille si la classe mère ne possède pas de constructeur par défaut (sans arguments).
4. Polymorphisme avec super.methode() : Lors de la redéfinition (override) de la méthode info(), l'utilisation de super.info() permet d'éviter de réécrire le code d'affichage des attributs de base. C'est une excellente pratique de factorisation du code.
5. Tester la logique : Vérifiez vos conditions (comme le qte < stock abordé plus haut) et assurez-vous que les types de données correspondent (on n'ajoute pas des kilos flottants dans un stock défini comme un entier).