Discussion :

[Ziginou]

Bonjour à tous,

J'aurais besoin de quelques précisions sur l'utilisation des objets sous Delphi.

J'ai fait des essais et il y a des trucs qui me semblent bizarres...

Je définis deux unités, dans lesquels 2 objets sont déclarés:

Dans objet.pas

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
TMyObjet=Class(TObject)
Private
  fNom: String;
  fValeur: String;
  Function getNom: String;
  Procedure setNom(ANom: String);
  Function getValeur: String;
  Procedure setValeur(AValeur: String);
Protected
  {Virtual obligatoire, sinon, compilation ne marche pas...}
  Function DonneTout: String; Virtual;
Public
  {Overload obligatoire pour multi-déclaration d'une procédure}
  Constructor Create; Overload;
  Constructor Create(Valeur: String); Overload;
  Constructor Create(Nom, Valeur: String); Overload;
  Destructor Destroy; Override;
  Property Nom: String
    Read getNom
    Write setNom;
  Property Valeur: String
    Read getValeur
    Write setValeur;
End;

Dans fils.pas

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
{Objet fils}
TMyFils=Class(TMyObjet)
Private
  fNomSup: String;
  fValeurSup: String;
  Function getNomSup: String;
  Procedure setNomSup(ANom: String);
  Function getValeurSup: String;
  Procedure setValeurSup(AValeur: String);
Public
  {Overload obligatoire pour multi-déclaration d'une procédure}
  Constructor Create; Overload;
  Constructor Create(Valeur: String); Overload;
  Constructor Create(Nom, Valeur: String); Overload;
  Destructor Destroy; Override;
  Property Nom: String
    Read getNomSup
    Write setNomSup;
  Property Valeur: String
    Read getValeurSup
    Write setValeurSup;
  {Ne peut être déclarée en private car ne peut avoir une portée inférieure}
  {par rapport à la classe de base
  Doit être définie en public pour être accessible dans un programme
  Ne comprends pas pourquoi on n'a pas besoin d'avoir override...}
  Function DonneTout: String; Override;
End;

Ce que je trouve bizarre :

1. Quand je définis 'DonneTout' en Public, à la fois dans la classe père et dans la classe fils, le compilateur me laisse faire même si j'oublie les mots clés Virtual/override.
Est-ce normal ? A quoi sert-il de les déclarer en virtual/override alors ? Lisibilité du code uniquement (c'est déjà beaucoup ).
2. Quand je définis 'DonneTout' en Protected dans la classe père, elle n'est pas accessible dans le programme principal (à priori, c'est normal puisque le protected ne sert, à ce que j'ai compris que dans l'héritage). Par contre, si je veux utiliser 'DonneTout' de la classe fils, je n'ai pas besoin, là non plus, d'utiliser le mot clé override : le compilateur me laisse faire. Donc, même question que précédemment, à quoi ça sert de le définir hormis pour des questions de lisibilité ?
3. Y'a-t-il des cas, du coup, où le mot clé override est obligatoire ?

Merci des précisions que vous voudrez bien m'apporter

Thierry.

[ShaiLeTroll]

As-tu au moins tester la différence toi même entre avec ou sans virtual\override !

Prenons Function DonneTout: String; non virtuelle

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
Function TMyObjet.DonneTout: String;
begin
  Result := 'TMyObjet';
end;
 
Function TMyFils.DonneTout: String;
begin
  Result := 'TMyFils';
end;

code de test

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
var
  ObjetObjet: TMyObjet;
  ObjetFils: TMyObjet;
  FilsFils: TMyFils;
begin
  ObjetObjet := TMyObjet.Create();
  ShowMessage(ObjetObjet.DonneTout()); // Affiche TMyObjet
 
  ObjetFils:= TMyFils.Create(); // Note la différence variable du type TMyObjet instancié via TMyFils
  ShowMessage(ObjetFils.DonneTout()); // Affiche TMyObjet
 
  FilsFils:= TMyFils.Create();
  ShowMessage(FilsFils.DonneTout()); // Affiche TMyFils
end;

Pour résumer, on verra TMyObjet, TMyObjet, TMyFils

ajoute virtual et override;

cela affichera TMyObjet, TMyFils, TMyFils

Oh !!!!

Le mot clé virtual permet de trouver la méthode en fonction du type réel à l'exécution et non en fonction du type de la variable connue à la compilation !

[Andnotor]

Virtual/override concerne le polymorphisme. Les mettre ou pas dépend du comportement souhaité

Le but est de pouvoir définir une variable de type générique TMyObjet tout en l'instanciant avec un type TMyFils et exécuter (ou pas) les méthodes de TMyFils.

Le compilateur râle si override est défini sans que la méthode ancêtre soit virtual

[Ziginou]

@ShaiLeTroll
J'avais fait des tests, bien sûr, mais pas ceux-là
C'est très rare quand je ponds du code et que je ne le teste pas en allant directement sur devt.com pour avoir des soluces (les lendemains de cuite à la rigueur...)
En tous cas, j'ai compris
Merci !

@Andnotor
Compris
Thanks.

Thierry.