|
|
- 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
Ce que vous allez apprendre dans cette leçon - Concepts de la Programmation Orientée Objet.
- Exemples de déclaration d'objet.
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. 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.
- Nous allons tout d'abord créer la classe CProduit :
- Sous le volet "Accueil", dans le groupe "Général", cliquez sur "Nouveau".
- Dans la fenêtre qui s'affiche, cliquez sur "Code" puis sur "Classe".
- Indiquez le nom de la classe à créer, CProduit dans notre exemple.
- Validez. Le code WLangage de la classe est affiché. Il est composé de trois sections :
- Déclaration
- Constructeur
- Destructeur
- 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.
- 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_Référence" :
- 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".
- Positionnez-vous sur le membre "m_Référence".
- 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.
- Saisissez le nom de la propriété "Référence" et validez.
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. - 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_Libellé,
- la propriété Stock associée au membre m_Stock.
- 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 :
- Dans le volet "Explorateur de projet", sélectionnez la classe CProduit.
- 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. |
- 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 :
- Dans la barre des éléments ouverts, faites un clic droit sur le bouton "P". Le menu contextuel s'affiche.
- Sélectionnez l'option "Code de l'élément".
- L'éditeur de code affiche les différents événements associés au projet.
- 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
- 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
- Testons immédiatement ce code : cliquez sur
 parmi les boutons d'accès rapide. - 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".
- 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.
- 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.
- Testons nos modifications (Cliquez sur l'icône "GO" parmi les icônes d'accès rapide).
- Le volet "Trace du débogueur" affiche les informations suivantes :
REF-123 Mon produit 10
Le stock est insuffisant
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. |
|
|
|
|
|
|