DOCUMENTATION EN LIGNE
DE WINDEVWEBDEV ET WINDEV MOBILE

Nouveauté WINDEV 2024 !
Aide / Tuto WINDEV / Tuto - Les bases du WLangage
  • Leçon 8 - La POO
  • Concepts
  • Rappels des concepts de la POO
  • Un exemple simple
  • Création de la classe
  • Création des propriétés
  • Création des méthodes
  • Déclarer et manipuler les objets
  • Utilisation du constructeur
  • En résumé

Tuto - Les bases du WLangage

Leçon 8 - La POO
Ce que vous allez apprendre :
  • Concepts de la Programmation Orientée Objet.
  • Exemples de déclaration d'objet.
Durée de la leçon 30 mn
Concepts
La Programmation Orientée Objet (P.O.O.) a pour but de permettre une meilleure réutilisabilité du code. Les programmes développés en POO sont structurés : ils sont décomposés en modules gérant chacun une fonctionnalité du logiciel. Les modules développés peuvent être facilement réutilisés dans d'autres logiciels. Ils vont regrouper un ensemble de procédures (appelées méthodes) et encapsuler la structure de données sur laquelle les méthodes vont agir.
Pour programmer "en objet", il faut déclarer des classes, les membres et les méthodes associés.
Tout d'abord, voici un rappel des concepts de la POO.

Rappels des concepts de la POO

Classe
Une classe rassemble la description d'une structure de données (les membres) et les procédures (méthodes) qui manipulent les membres.
Une classe définit donc un type de données et son comportement.
Objet
Une classe permet de créer des objets. Chaque objet créé possède des membres décrits dans sa classe et peut être manipulé par l'intermédiaire des méthodes de sa classe. On dit qu'un objet est une instance de la classe.
Lorsque la classe est déclarée, il suffit d'associer un objet à une classe pour que l'objet puisse être manipulé par toutes les méthodes de cette classe.
Les membres
Un membre est une donnée (ou un paramètre) de l'objet.
Les méthodes
Une méthode permet d'agir sur l'objet, pour modifier ses membres par exemple.
Une méthode est une procédure. Son fonctionnement est identique à celui des procédures classiques du WLangage.
Notion d'héritage
L'héritage permet d'inclure les caractéristiques d'une classe existante (classe de base) dans une nouvelle classe (classe dérivée). L'héritage permet de créer un nouveau type de données à partir d'un type connu, dans le but de lui ajouter des fonctionnalités, ou d'en modifier le comportement. La classe de base ne sera donc pas modifiée. Une classe peut hériter d'une classe dont elle devient une sous-classe.
Une classe dérivée permet à ses objets d'accéder à toutes les méthodes, à tous les membres et à toutes les propriétés de ses classes ancêtres ; tout se passe comme si les méthodes, les membres et les propriétés des classes ancêtres faisaient partie de la classe dérivée.
Constructeur et Destructeur
Les notions de Constructeur et Destructeur sont importantes puisqu'elles permettent un appel automatique de méthodes d'initialisation lors de la création (instanciation) d'un objet représentant cette classe et lors de la destruction de ce même objet (libération). Ces méthodes sont automatiquement créées lors de la création de la classe. Le code de ces méthodes est vide par défaut.
  • La méthode Constructeur appartenant à la classe est automatiquement appelée lors de la déclaration (instanciation) de l'objet du type de cette même classe.
  • La méthode Destructeur appartenant à la classe est automatiquement appelée lors de la destruction (libération) de l'objet du type de cette même classe. Cette exécution de la méthode Destructeur est dépendante de la durée de vie de l'objet selon comme l'objet a été déclaré (global ou local),
Encapsulation de données
L'encapsulation des données permet de garantir que les données membres de l'objet ne seront pas modifiées à tort par des fonctions (méthodes) extérieures à l'objet.
Il est ainsi possible d'interdire à l'utilisateur d'un objet l'accès à certains ou à tous ses membres. Les membres dont l'accès est interdit sont appelés membres privés.
Il n'est possible d'accéder à ces membres privés qu'à partir des méthodes prévues à cet effet dans la classe.
Un exemple simple

Création de la classe

Nous allons réaliser un exemple simple de classe représentant un produit et contenant des membres et des méthodes. Cette classe sera instanciée et manipulée par une procédure.
Pour réaliser les manipulations de cette leçon, nous allons reprendre le projet "WLangage" que nous avons utilisé dans la leçon précédente.
Ouvrez si nécessaire le projet "WLangage" que vous avez créé dans la première leçon de ce tuto (consultez le paragraphe Un projet pour découvrir le WLangage de la leçon 1).
Nous allons tout d'abord créer la classe CProduit :
  1. Sous le volet "Accueil", dans le groupe "Général", cliquez sur "Nouveau".
  2. Dans la fenêtre qui s'affiche, cliquez sur "Code" puis sur "Classe".
  3. Indiquez le nom de la classe à créer, CProduit dans notre exemple.
  4. Validez. Le code WLangage de la classe est affiché. Il est composé de trois sections :
    • Déclaration
    • Constructeur
    • Destructeur
  5. Dans l'événement "Déclaration", saisissez le code suivant :
    CProduit est une Classe

    PUBLIC
    mg_SeuilAlerteStock est un entier = 20

    PRIVÉ
    m_Référence est une chaîne
    m_Libellé est une chaîne
    m_Stock est un entier
    FIN

    // État du stock
    EtatStock est une Enumération
    STOCK_VIDE 
    STOCK_ALERTE
    STOCK_OK
    FIN
    Ce code de déclaration contient :
    • La déclaration de la classe. Cette classe contient :
      • un membre public qui correspond au seuil d'alerte du stock. Ce membre est public car cette information est la même pour tous les produits.
      • trois membres privés, la référence du produit, son libellé et son stock.
    • La déclaration d'une énumération. Cette énumération permet de gérer l'état du stock. Pour que cette énumération puisse être manipulée par une des méthodes de la classe, il est nécessaire qu'elle soit déclarée dans le code de déclaration de la classe.
  6. Enregistrez votre classe (Ctrl + S).

Création des propriétés

Pour pouvoir manipuler les membres privés depuis l'extérieur de la classe, ils doivent être associés à des propriétés (Getter et Setter). Nous allons créer ces propriétés.
Pour créer les propriétés liées au membre "m_Référence" :
  1. Dans le volet "Explorateur de projet" (affiché à gauche de l'environnement) :
    • Déroulez "Classes", puis déroulez "CProduit". Les différents éléments de la classe apparaissent dans le volet "Explorateur de projet".
    • Déroulez "Membres".
  2. Positionnez-vous sur le membre "m_Référence".
  3. Affichez le menu contextuel (clic droit) et sélectionnez "Générer la propriété". La fenêtre qui s'affiche permet de définir toutes les caractéristiques de la propriété :
    • Le nom de la propriété.
    • La visibilité de la propriété. Plusieurs options sont combinables. La propriété peut être :
      • Publique, protégée, restreinte, protégée restreinte ou privée.
      • Abstraite ou globale.
    • Le mode d'accès à la propriété (Lecture et/ou écriture).
    • Le rôle de la propriété : Non défini, Métier ou UI.
  4. Saisissez le nom de la propriété "Référence" et validez.
  5. Les propriétés permettant la lecture et l'écriture sont automatiquement créées avec le code WLangage correspondant.
Remarque : Pour plus de détails sur la création et la déclaration des méthodes de classe, consultez Création d'une méthode de classe.
Répétez ces opérations pour générer :
  • la propriété Libellé associée au membre m_Libellé,
  • la propriété Stock associée au membre m_Stock.

Création des méthodes

Nous allons maintenant créer les méthodes associées à la classe. Dans notre exemple, nous allons créer 2 méthodes :
  • Une méthode permettant d'ajouter des produits au stock courant : AjouteStock.
  • Une méthode permettant de connaître l'état du stock : EtatDuStock.
Pour créer la méthode AjouteStock :
  1. Dans le volet "Explorateur de projet", sélectionnez la classe CProduit.
  2. Affichez le menu contextuel (clic droit) et sélectionnez "Nouvelle méthode". La fenêtre qui s'affiche permet de définir toutes les caractéristiques de la méthode. Saisissez le nom de la méthode "AjouteStock" et validez.
    La syntaxe des méthodes de classes est la même que celle des procédures.
  3. L'éditeur de code affiche la méthode. Saisissez le code suivant :
    PROCÉDURE AjouteStock(LOCAL StockSupplémentaire est un entier) : booléen

    // Le stock fourni en paramètre doit être valide
    SI StockSupplémentaire < 0 ALORS
    // Impossible d'ajouter un stock négatif
    RENVOYER Faux
    FIN

    // Incrémente le stock actuel avec le stock supplémentaire
    m_Stock += StockSupplémentaire

    // L'ajout est effectif
    RENVOYER Vrai
    Examinons ce code WLangage :
    • La méthode AjouteStock attend en paramètre un entier et renvoie un booléen.
    • Un test sur la valeur du stock indiquée est réalisé. Si le stock est négatif, la méthode renvoie Faux : le stock de l'élément n'a pas été mis à jour.
    • Si la valeur du stock est positive, le stock de l'élément est incrémenté.
Vous pouvez renouveler les manipulations pour créer la méthode EtatDuStock. Le code de cette méthode est le suivant :
PROCÉDURE EtatDuStock() : EtatStock 

// Si le stock est vide
SI m_Stock = 0 ALORS
RENVOYER STOCK_VIDE
FIN

// Si le stock est sous le seuil d'alerte
SI m_Stock <= mg_SeuilAlerteStock ALORS
RENVOYER STOCK_ALERTE
FIN

// Le stock est OK
RENVOYER STOCK_OK
Ce code utilise l'énumération EtatStock que nous avons déclarée dans le code de déclaration de la classe.
Notre classe est terminée. Nous allons maintenant l'utiliser.

Déclarer et manipuler les objets

Un objet est déclaré en même temps que les autres variables. Pour notre exemple, nous allons déclarer un objet dans le code d'initialisation du projet.
Pour afficher le code d'initialisation du projet :
  1. Dans la barre des éléments ouverts, faites un clic droit sur le bouton "P". Le menu contextuel s'affiche.
  2. Sélectionnez l'option "Code de l'élément".
  3. L'éditeur de code affiche les différents événements associés au projet.
  4. Supprimez le code existant dans le code d'initialisation du projet et saisissez le code suivant :
    UnProduit est un CProduit

    UnProduit.Référence = "REF-123"
    UnProduit.Libellé = "Mon produit"

    Ce code permet de déclarer un objet et de l'instancier. Les propriétés sont renseignées via la syntaxe :
    <Nom de l'objet>.<Nom de la propriété> = Valeur
  5. Ajoutons dans ce code les lignes suivantes :
    • Appel de la méthode AjouteStock :
      UnProduit.AjouteStock(500)
    • Lecture des propriétés :
      Trace(UnProduit.Référence + " " + UnProduit.Libellé + " " + UnProduit.Stock)
    • Utilisation de l'énumération :
      SI UnProduit.EtatDuStock() = CProduit.STOCK_OK ALORS
      Trace("Le stock est correct")
      SINON
      Trace("Le stock est insuffisant")
      FIN
  6. Testons immédiatement ce code : cliquez sur Tester le projet parmi les boutons d'accès rapide.
  7. Affichez si nécessaire le volet "Trace du débogueur" pour voir le résultat : sous le volet "Accueil", dans le groupe "Environnement", déroulez "Volets" et sélectionnez "Volets" puis "Trace du débogueur".
  8. Le volet "Trace du débogueur" affiche les informations suivantes :
    REF-123 Mon produit 500
    Le stock est correct
    Nous retrouvons bien les informations concernant le produit et l'état du stock.

Utilisation du constructeur

Pour finir cette présentation rapide de la POO avec WINDEV, nous allons modifier notre code pour utiliser le constructeur. Ce constructeur va nous permettre d'initialiser le seuil d'alerte.

Affichez le code de la classe : double-cliquez sur CProduit dans le volet "Explorateur de projet" par exemple.
Modifiez la déclaration de la classe en remplaçant la ligne de code suivante :
mg_SeuilAlerteStock est un entier = 20
par
mg_SeuilAlerteStock est un entier
Modifiez le constructeur de la classe.
PROCÉDURE Constructeur(SeuilAlerteStock est un entier)
mg_SeuilAlerteStock = SeuilAlerteStock
Affichez le code d'initialisation du projet.
  1. Nous allons modifier :
    • le code d'instanciation de la classe. Remplacez la ligne de code suivante :
      UnProduit est un CProduit
      par :
      UnProduit est un CProduit(20)
      En effet, comme nous l'avons vu précédemment, la méthode Constructeur est appelée automatiquement lors de la déclaration (instanciation) de la classe. Le constructeur attend maintenant un paramètre : il faut donc rajouter le passage de la valeur du paramètre lors de l'instanciation. Dans cet exemple, la quantité limite est de 20.
    • le code d'appel de la méthode. Remplacez la ligne de code suivante :
      UnProduit.AjouteStock(500)
      par :
      UnProduit.AjouteStock(10)
      La quantité en stock est de 10.
  2. Testons nos modifications (Cliquez sur l'icône "GO" parmi les icônes d'accès rapide).
  3. Le volet "Trace du débogueur" affiche les informations suivantes :
    REF-123 Mon produit 10
    Le stock est insuffisant
En résumé
Dans cette leçon, vous avez découvert comment créer une classe, ses membres, et comment les utiliser.
Pour aller plus loin dans la découverte de la POO, vous pouvez consulter les pages suivantes :
Leçon précédenteSommaire
Version minimum requise
  • Version 2024
Commentaires
Cliquez sur [Ajouter] pour publier un commentaire

Dernière modification : 16/11/2023

Signaler une erreur ou faire une suggestion | Aide en ligne locale