Blog de dsr57 - Windev » Windev 17 https://blog.developpez.com/dsr57 Blog sur l'edi windev Thu, 04 Jun 2015 11:46:25 +0000 fr-FR hourly 1 https://wordpress.org/?v=4.1.42 Classes abstraites en Windev (version 18 et antérieur) https://blog.developpez.com/dsr57/p12601/windev/wd-18-classes-abstaites https://blog.developpez.com/dsr57/p12601/windev/wd-18-classes-abstaites#comments Wed, 30 Apr 2014 20:07:43 +0000 http://blog.developpez.com/dsr57/?p=270 Avant la version 19 (annoncée sur le site officiel le 04.10.2013), WinDev ne gérait pas explicitement les classes abstraites. Il était possible de les utiliser en modifiant l’accessibilité du constructeur de la classe de base. Cet article explique étapes par étapes comment déclarer une classe abstraite. Cela vous permettra d’utiliser cette notion de POO sans forcément upgrader votre version de WinDev.

Un article expliquant comment mettre en place cette possibilité est disponible sur le site developpez.com : classes abstraites en WinDev (version antérieure à 19)

]]> 0 Héritage en WinDev : BUG ou subtilité du W-langage??? https://blog.developpez.com/dsr57/p12254/windev/heritage-en-windev-bug https://blog.developpez.com/dsr57/p12254/windev/heritage-en-windev-bug#comments Thu, 26 Sep 2013 19:48:47 +0000 http://blog.developpez.com/dsr57/?p=139 Dans ce billet, je vais évoquer la notion d’héritage sur l’EDI WinDev. Dans un premier temps je vais faire un rappel , pour ensuite construire un exemple simple, faire évoluer cet exemple dans les paragraphes qui suivent, et finaliser sur un … ou une ….

Modification apportée le 11.12.2013 grâce à une précision de zechatdoc.

L’Héritage c’est quoi ?

L’héritage est un principe propre à la programmation orientée objet, permettant de créer une nouvelle classe à partir d’une classe existante. Une relation d’héritage doit être utilisée lorsque la relation « est une sorte de » peut être appliquée entre deux classes. En WinDev, la mise est œuvre est simple au niveau du code puisque dans la déclaration de la classe il suffit de saisir « Hérite de » suivi du nom de la classe dont on souhaite hériter. A l’intérieur de la nouvelle classe vous pouvez :

  • Utiliser les champs hérités de la classe de base ( selon leur visibilité).
  • Ajouter des nouveaux champs.
  • Utiliser une méthode héritée ( selon la visibilité).
  • Redéfinir une méthodes en la créant avec la même signature.
  • Surcharger une méthode en la créant avec un signature différente.
  • Ajouter une nouvelle méthode.
  • Ajouter un ou plusieurs constructeur.

L’héritage par Windev par l’exemple

Pour évoquer la notion d’héritage en WinDev, je vais construire un exemple. Un exemple bien construit permet d’allier les explications théoriques et la pratique. Ce qui sera à mon avis, plus bénéfique, plus efficace que de longue phrase.

  • Définition de l’exemple
      • Pour évoquer la notion d’héritage en Windev, je vais créer deux classes
      ac_voiture : Classes pseudo abstraite (Cf un futur article sur les classes abstraites en windev) représentant une voiture.
      pc_peugeot : Classes héritant de ac_voiture représentant une voiture de marque « Peugeot ».

    Membres de la classe ac_voiture

      PROTÉGÉE 
          ls_marque est une chaîne
          ls_modele est une chaîne
      GLOBALE
          li_nbVoiture est un entier

    Les membres ont des propriétés en lecture/éciture

      //----->Propriété
      PROCEDURE Marque() //Lecture
      RENVOYER :ls_marque

      PROCEDURE Marque(ps_marque est une chaîne) //Ecriture
      :ls_marque = ps_marque

      PROCEDURE Modele() //Lecture
      RENVOYER :ls_modele

      PROCEDURE Modele(ps_modele est une chaîne) //Ecriture
      :ls_modele = ps_modele

    Membres de la classe pc_peugeot

      hérite de ac_voiture
      PRIVÉE
          lb_moteurHdi est un booléen

    Le membre a des propriétés en lecture/écriture

      PROCEDURE moteurHdi() //Lecture
      RENVOYER :lb_moteurHdi

      PROCEDURE moteurHdi(pb_moteurHdi est un booléen) //Ecriture
      :lb_moteurHdi = pb_moteurHdi
  • Constructeur sans paramètre
    • Pour continuer notre exemple, nous allons créer le constructeur par défaut (Constructeur sans paramètre) pour chacune des classes.

    Constructeur ac_voiture

    PROCEDURE PROTÉGÉ Constructeur()
    //---->Pas de code

    Constructeur pc_peugeot

    PROCEDURE Constructeur()
    Ancêtre:Constructeur()
    La première ligne fait appel au constructeur de la classe de base, WinDev n’oblige pas cet appel et ne l’effectue pas automatiquement (Cf langage JAVA), mais pour des questions de maintenance, de lisibilité et de compréhension, j’effectue toujours cet appel.

  • Programme principale

    • Dans le code d’initialisation de la fenêtre je vais instancier un objet de type pc_peugeot.

    lo_peugeot est un pc_peugeot()
  • Constructeur avec paramètres.
    • Dans cette étape je supprime les constructeurs par défaut et supprime l’accès en écriture des membres. Je re-code des constructeurs en passant en paramètre les valeurs initialisation des membres. De cette façon, je force l’initialisation des membres de la classe par le constructeur.

    Constructeur de la classe ac_voiure

    PROCEDURE PROTÉGÉE  Constructeur(ps_marque est une chaîne,ps_modele est une chaîne)

    :ls_marque=ps_marque
    :ls_modele=ps_modele

    Constructeur de la classe pc_peugeot

    PROCEDURE Constructeur(ps_marque est une chaîne,ps_modele est une chaîne, pb_hdi est un booléen)

    Ancêtre:Constructeur(ps_marque,ps_modele)
    :lb_moteurHdi=pb_hdi

    Au niveau de mon code principal, j’effectue certaines modification :

    lo_peugeot est un pc_peugeot("Peugeot","308",Vrai)

    Le code se compile, mais j’ai une erreur lors de l’exécution.

    Erreur à la ligne 0 du traitement Constructeur de la classe pc_peugeot.
    Les paramètres d’appel du code ‘Constructeur de la classe ac_voiture’ sont incorrects : on attendait 2 paramètres et on en a reçu 0.

    Apres quelques recherches, j’ai isolé la ligne de code qui posait problème

    hérite de ac_voiture

    Si je traduis l’erreur de WinDev, à cette ligne de code, WinDev attend les 2 paramètres du constructeur de la classe ac_voiture. Cela veut dire que quand je déclare un objet de type pc_peugeot. Avant même que le constructeur de la classe instanciée soit appelé, le constructeur de la classe de base est appelé. Pour vérifier cette hypothèse, je vais ajouter une ligne trace dans le constructeur de la classe ac_voiture et recréer le constructeur par défaut (Pour ne pas avoir l’erreur d’exécution).
    PROCEDURE PROTÉGÉE  Constructeur(ps_marque est une chaîne,ps_modele est une chaîne)

    :ls_marque=ps_marque
    :ls_modele=ps_modele

    Trace("Marque : "+:ls_marque+" - Modele : "+:ls_modele)

    PROCEDURE PROTÉGÉE Constructeur()

    Trace("Marque : "+:ls_marque+" - Modele : "+:ls_modele)

    Le résultat de la trace

    Marque : – Modele :
    Marque : Peugeot – Modele : 308

    Mon hypothèse est validée, lors de l’instanciation d’un objet héritant d’une classe de base, Windev appelle automatiquement le constructeur de la classe de base. Ce qui me pose problème, c’est que cet appel n’est pas effectué dans le constructeur, mais lors de la liaison d’héritage : Hérite de ac_voiture.

Conséquences …

A première vue, on pourrait conclure que cet appel prématuré n’a pas de conséquence sur le bon déroulement d’une application. Pour simplifier la compréhension et les conséquences, nous reprenons notre exemple à l’étape des constructeurs par défaut (Cf Paragraphe Constructeur sans paramètre), cela évite la multiplication des constructeurs. Nous avons donc un constructeur pour chaque classe

Constructeur ac_voiture

PROCEDURE PROTÉGÉ Constructeur()
//---->Pas de code
Constructeur pc_peugeot

PROCEDURE Constructeur()
Ancêtre:Constructeur()
Après le rappel de ces constructeurs nous allons ajouter pour chacune des classes un membre statique permettant de connaître le nombre de voitures et le nombre de Peugeots dans notre application.

Rappel : Les membres statiques sont des champs ou méthodes qui sont accessibles par la classe elle même ou par toutes les instances de la classe. on parle également de membres partagés. Ils son très utiles lorsque vous avez à gérer dans une classe des informations qui ne sont pas spécifique à une instance de classe mais à la classe elle même.

Classe ac_voiture

Ajout du membre statique li_nbvoiture, déclaration de la classe

ac_voiture est une Classe
PROTÉGÉE 
    ls_marque est une chaîne
    ls_modele est une chaîne
GLOBALE
    li_nbVoiture est un entier
FIN

Propriété en lecture pour le membre li_nbVoiture

PROCEDURE GLOBALE NbVoiture()

RENVOYER ::li_nbVoiture

Modification du constructeur (Par défaut) pour incrémenter le membre statique

PROCEDURE PROTÉGÉE Constructeur()

::li_nbVoiture++

Classe pc_peugeot

Ajout du membre statique li_nbPeugeot

Déclaration de la classe

pc_peugeot est une Classe
hérite de ac_voiture
PRIVÉE
    lb_moteurHdi est un booléen
GLOBALE
    li_nbPeugeot est un entier
FIN

Propriété en lecture pour le membre li_nbPeugeot

PROCEDURE GLOBALE NbPeugeot

RENVOYER ::li_nbPeugeot

Modification du constructeur (Par défaut) pour incrémenter le membre statique

PROCEDURE Constructeur()

Ancêtre:Constructeur()
::li_nbPeugeot++

Nous venons de terminer l’ajout des membres statiques à nos classes, maintenant nous allons modifier le code principale pour avoir afficher dans une trace le nombre de voiture et le nombre de peugeot instancié.

lo_peugeot est un pc_peugeot()

Trace("Voiture : "+pc_peugeot.NbVoiture+"   -  Peugeot : "+pc_peugeot.nbPeugeot)

Résultat de la trace :

Voiture : 2 – Peugeot : 1

J’obtiens 2 voitures dont une Peugeot alors que je n’ai instancier qu’un seul objet.

Voila une des conséquences des appels prématurés automatiques, les données du programme sont erronées.
Ensuite je vais aussi insister sur le faite que nous sommes obligés d’avoir un constructeur par défaut dans la classe de base pour pouvoir mettre en place un héritage.

La subtilité

Dans les lignes de code que je viens de vous soumettre, je n’ai pas utilisé grand chose en concept : héritage, variable statique, et appel d’un constructeur de la classe parent. C’est dans ce dernier qu’intervient la subtilité pour ne pas avoir les conséquences il ne faut pas utiliser le mot ancêtre. Il faut remplacer la ligne (classe pc_voiture)

ancetre:constructeur(ps_marque,ps_modele)

par

Constructeur ac_voiture(ps_marque,ps_modele)

et supprimer le constructeur par défaut de ac_coiture

Merci zechatdoc pour m’avoir donner cette précision, même si pour moi la programmation est exactement la même en therme d’approche mais le résultat diffère et devient juste.

Conclusion

Nous venons de voir la notion d’héritage en Windev avec un subtilité windevienne, comme PC-SOFT sait le faire. Je trouve cela dommage car cela nuit à son image et impacte par liaison directe les développeurs Windev. Je comprend que Windev veuille mettre à la porter de plus de personne la programmation, mais s’il vous plait, esssayer de respecter quand même une certaine logique et arrêter les tours de passe passe.
]]> 4