PC SOFT

DOCUMENTATION EN LIGNE
DE WINDEVWEBDEV ET WINDEV MOBILE

Nouveauté WINDEV Mobile 26 !
  • Ce que vous allez apprendre dans cette leçon
  • Concepts
  • Rappels des concepts de la POO
  • Un exemple simple
  • Création de la classe
  • Déclarer et manipuler les objets
  • Utilisation du constructeur
  • Conclusion
Leçon 3.9. La POO
Ce que vous allez apprendre dans cette leçon
  • Concepts de la Programmation Orientée Objet.
  • Exemples de déclaration d'objet.
Durée de la leçon

Durée estimée : 40 mn
Leçon précédenteSommaireLeçon suivante
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 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épendant 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 cette partie (consultez le paragraphe Un projet pour découvrir le WLangage de la leçon 3.2).
  • 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_nSeuilAlerteStock est un entier = 20
       
      PRIVÉ
      m_sRéférence est une chaîne
      m_sLibellé est une chaîne
      m_nStock est un entier
      FIN
       
      // État du stock
      EEtatStock est une Énumé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).
  • 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_sRé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".
    2. Positionnez-vous sur le membre "m_sRé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é. Saisissez le nom de la propriété "Référence" et validez.
    4. Les propriétés permettant la lecture et l'écriture sont automatiquement créées avec le code WLangage correspondant.
  • Répétez ces opérations pour générer :
    • la propriété Libellé associée au membre m_sLibellé,
    • la propriété Stock associée au membre m_nStock.
  • 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.

      Note

      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 nStockSupplémentaire est un entier) : booléen
       
      // Le stock fourni en paramètre doit être valide
      SI nStockSupplémentaire < 0 ALORS
      // Impossible d'ajouter un stock négatif
      RENVOYER Faux
      FIN
       
      // Incrémente le stock actuel avec le stock supplémentaire
      m_nStock += nStockSupplé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() : EEtatStock
     
    // Si le stock est vide
    SI m_nStock = 0 ALORS
    RENVOYER STOCK_VIDE
    FIN
     
    // Si le stock est sous le seuil d'alerte
    SI m_nStock <= mg_nSeuilAlerteStock ALORS
    RENVOYER STOCK_ALERTE
    FIN
     
    // Le stock est OK
    RENVOYER STOCK_OK
    Ce code utilise l'énumération EEtatStock que nous avons déclaré 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 :
      gclUnProduit est un CProduit
       
      gclUnProduit.Référence = "REF-123"
      gclUnProduit.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 :
        gclUnProduit.AjouteStock(500)
      • Lecture des propriétés :
        Trace(gclUnProduit.Référence +" "+ gclUnProduit.Libellé +" "+ gclUnProduit.Stock)
      • Utilisation de l'énumération :
        SI gclUnProduit.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 "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_nSeuilAlerteStock est un entier = 20
    par
    mg_nSeuilAlerteStock est un entier
  • Modifiez le constructeur de la classe.
    PROCÉDURE Constructeur(nSeuilAlerteStock est un entier)
    mg_nSeuilAlerteStock = nSeuilAlerteStock
  • Affichez le code d'initialisation du projet.
    1. Nous allons modifier :
      • le code d'instanciation de la classe. Remplacez la ligne de code suivante :
        gclUnProduit est un CProduit
        par :
        gclUnProduit 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 :
        gclUnProduit.AjouteStock(500)
        par :
        gclUnProduit.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
Conclusion
Dans cette leçon, vous avez découvert comment créer une classe, ses membres, et comment les utiliser.
La leçon suivante vous présente quelques astuces de manipulations de l'éditeur de code.
Leçon précédenteSommaireLeçon suivante
Version minimum requise
  • Version 26
Documentation également disponible pour…
Commentaires
Cliquez sur [Ajouter] pour publier un commentaire