Gestion de Stock pour Magasin

Ce TP propose de développer un programme de gestion de stock pour un magasin en utilisant la programmation orientée objet. Il permet d'apprendre les notions d'héritage, de classe abstraite et d'interface. Le travail consiste à coder des interfaces et des classes représentant des articles vendus au magasin, puis à simuler la gestion des stocks et des ventes. Pour réaliser ce TP, il est nécessaire de maîtriser les concepts de base de la programmation orientée objet en Java ou un langage similaire.

Objectifs

• Comprendre et implémenter des interfaces en programmation orientée objet.
• Utiliser l'héritage pour créer des classes dérivées à partir d'une classe générale.
• Gérer un stock de produits avec des méthodes adaptées à la nature des articles.
• Simuler des ventes et calculer les revenus et dépenses du magasin.
• Afficher des descriptions détaillées des produits et de l'état du magasin.

Prérequis et installation

• Connaissances en programmation orientée objet (classes, héritage, interfaces).
• Un environnement de développement Java ou équivalent.
• Compréhension des concepts de classes abstraites et interfaces.
• Pas de matériel spécifique requis, uniquement un ordinateur avec un compilateur Java.

Étape 1 : Comprendre la hiérarchie des classes et interfaces

Avant de coder, il est essentiel de bien comprendre la structure des classes et interfaces qui modélisent le problème.

• Interfaces : Deux interfaces sont définies pour les produits vendus :
• VendableParKilogramme : pour les produits vendus au kilogramme.
• VendableParPiece : pour les produits vendus à l'unité.

Chaque interface contient une méthode vendre qui reçoit la quantité vendue, retourne le revenu généré et met à jour le stock.

Classe Article : classe générale représentant un produit avec les propriétés suivantes :

• prix d'achat
• prix de vente
• nom
• fournisseur

Elle contient des méthodes pour calculer le taux de rendement et afficher la description du produit.

Cette classe n'implémente aucune interface.

Classes dérivées : Deux classes héritent d'Article :

• ArticlesElectromenagers : avec une propriété supplémentaire nombre de pièces en stock et des méthodes pour remplir le stock et afficher la description complète (incluant le stock).
• Primeurs : avec une propriété supplémentaire quantité en stock et des méthodes similaires à celles des électroménagers.

Chaque classe dérivée doit implémenter l'interface correspondante (par pièce ou par kilogramme).

Au moment de la création d'un objet dérivé, le stock est initialisé à vide.

Étape 2 : Coder les interfaces et les classes

Il faut d'abord coder les deux interfaces VendableParKilogramme et VendableParPiece avec la méthode vendre.

public interface VendableParKilogramme {
    double vendre(double quantite);
}

public interface VendableParPiece {
    double vendre(int quantite);
}

Ensuite, coder la classe générale Article avec ses propriétés et méthodes :

public abstract class Article {
    protected double prixAchat;
    protected double prixVente;
    protected String nom;
    protected String fournisseur;

    public Article(double prixAchat, double prixVente, String nom, String fournisseur) {
        this.prixAchat = prixAchat;
        this.prixVente = prixVente;
        this.nom = nom;
        this.fournisseur = fournisseur;
    }

    public double calculerTauxRendement() {
        return (prixVente - prixAchat) / prixAchat;
    }

    public void afficherDescription() {
        System.out.println("Nom : " + nom);
        System.out.println("Fournisseur : " + fournisseur);
        System.out.println("Prix achat : " + prixAchat);
        System.out.println("Prix vente : " + prixVente);
        System.out.println("Taux rendement : " + calculerTauxRendement());
    }
}

Puis, coder les classes dérivées :

public class ArticlesElectromenagers extends Article implements VendableParPiece {
    private int stock;

    public ArticlesElectromenagers(double prixAchat, double prixVente, String nom, String fournisseur) {
        super(prixAchat, prixVente, nom, fournisseur);
        this.stock = 0;
    }

    public void remplirStock(int quantite) {
        stock += quantite;
    }

    @Override
    public double vendre(int quantite) {
        if (quantite > stock) {
            quantite = stock; // vendre tout ce qui reste
        }
        stock -= quantite;
        return quantite * prixVente;
    }

    @Override
    public void afficherDescription() {
        super.afficherDescription();
        System.out.println("Stock (pièces) : " + stock);
    }
}

public class Primeurs extends Article implements VendableParKilogramme {
    private double stock;

    public Primeurs(double prixAchat, double prixVente, String nom, String fournisseur) {
        super(prixAchat, prixVente, nom, fournisseur);
        this.stock = 0.0;
    }

    public void remplirStock(double quantite) {
        stock += quantite;
    }

    @Override
    public double vendre(double quantite) {
        if (quantite > stock) {
            quantite = stock; // vendre tout ce qui reste
        }
        stock -= quantite;
        return quantite * prixVente;
    }

    @Override
    public void afficherDescription() {
        super.afficherDescription();
        System.out.println("Stock (kg) : " + stock);
    }
}

Étape 3 : Coder la classe Magasin

La classe Magasin gère les produits, les dépenses et les revenus.

public class Magasin {
    private double depenses;
    private double revenus;
    private ArticlesElectromenagers[] electromenagers;
    private Primeurs[] primeurs;

    public Magasin(int tailleElectromenagers, int taillePrimeurs) {
        depenses = 0.0;
        revenus = 0.0;
        electromenagers = new ArticlesElectromenagers[tailleElectromenagers];
        primeurs = new Primeurs[taillePrimeurs];
    }

    public void ajouterElectromenager(ArticlesElectromenagers article, int index) {
        electromenagers[index] = article;
    }

    public void ajouterPrimeur(Primeurs article, int index) {
        primeurs[index] = article;
    }

    public void acheterElectromenager(int index, int quantite) {
        ArticlesElectromenagers article = electromenagers[index];
        article.remplirStock(quantite);
        depenses += quantite * article.prixAchat;
    }

    public void acheterPrimeur(int index, double quantite) {
        Primeurs article = primeurs[index];
        article.remplirStock(quantite);
        depenses += quantite * article.prixAchat;
    }

    public void vendreElectromenager(int index, int quantite) {
        ArticlesElectromenagers article = electromenagers[index];
        double revenuVente = article.vendre(quantite);
        revenus += revenuVente;
    }

    public void vendrePrimeur(int index, double quantite) {
        Primeurs article = primeurs[index];
        double revenuVente = article.vendre(quantite);
        revenus += revenuVente;
    }

    public void afficherEtat() {
        System.out.println("État du magasin :");
        System.out.println("Dépenses : " + depenses);
        System.out.println("Revenus : " + revenus);
        System.out.println("Articles électroménagers :");
        for (ArticlesElectromenagers a : electromenagers) {
            if (a != null) a.afficherDescription();
        }
        System.out.println("Primeurs :");
        for (Primeurs p : primeurs) {
            if (p != null) p.afficherDescription();
        }
    }

    public double calculerTauxRendement() {
        if (depenses == 0) return 0;
        return (revenus - depenses) / depenses;
    }
}

Étape 4 : Créer la méthode main et simuler les opérations

La méthode main crée un magasin, définit les articles, remplit le stock et simule des ventes.

public class Main {
    public static void main(String[] args) {
        Magasin magasin = new Magasin(2, 2);

        // Création des articles électroménagers
        ArticlesElectromenagers tv = new ArticlesElectromenagers(200, 350, "Télévision", "Fournisseur A");
        ArticlesElectromenagers frigo = new ArticlesElectromenagers(500, 800, "Réfrigérateur", "Fournisseur B");
        magasin.ajouterElectromenager(tv, 0);
        magasin.ajouterElectromenager(frigo, 1);

        // Création des primeurs
        Primeurs pommes = new Primeurs(1, 2, "Pommes", "Fournisseur C");
        Primeurs bananes = new Primeurs(0.8, 1.5, "Bananes", "Fournisseur D");
        magasin.ajouterPrimeur(pommes, 0);
        magasin.ajouterPrimeur(bananes, 1);

        // Remplissage du stock
        magasin.acheterElectromenager(0, 10); // 10 télévisions
        magasin.acheterElectromenager(1, 5);  // 5 réfrigérateurs
        magasin.acheterPrimeur(0, 100.0);     // 100 kg de pommes
        magasin.acheterPrimeur(1, 150.0);     // 150 kg de bananes

        // Simuler des ventes
        magasin.vendreElectromenager(0, 3);  // vendre 3 télévisions
        magasin.vendreElectromenager(1, 2);  // vendre 2 réfrigérateurs
        magasin.vendrePrimeur(0, 20.0);       // vendre 20 kg de pommes
        magasin.vendrePrimeur(1, 50.0);       // vendre 50 kg de bananes

        // Afficher l'état final du magasin
        magasin.afficherEtat();

        // Afficher le taux de rendement
        System.out.println("Taux de rendement du magasin : " + magasin.calculerTauxRendement());
    }
}

Résultats attendus

Après exécution, on doit observer :

• Le stock initial est vide pour chaque article, puis rempli avec les quantités achetées.
• Les ventes diminuent le stock en conséquence.
• Les dépenses correspondent au coût d'achat total des articles achetés.
• Les revenus correspondent au total des ventes réalisées.
• La description des articles affiche correctement les prix, le fournisseur, le taux de rendement et le stock restant.
• Le taux de rendement du magasin est calculé par la formule :

taux de rendement = (revenus - dépenses) / dépenses

Ce taux doit être positif si les ventes sont rentables.

Pièges courants

• Ne pas initialiser le stock à zéro lors de la création d'un article dérivé.
• Oublier d'implémenter la méthode vendre dans les classes dérivées.
• Vendre une quantité supérieure au stock disponible : la méthode doit ajuster la quantité vendue au stock restant.
• Confondre les types de quantités : pièces pour les électroménagers, kilogrammes pour les primeurs.
• Ne pas mettre à jour correctement les dépenses et les revenus dans la classe Magasin.
• Ne pas afficher toutes les informations dans la méthode afficherDescription.
• Ne pas vérifier que les tableaux de produits ne contiennent pas de valeurs nulles avant d'afficher.