Discussion :

[helmis]

Bonjour

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
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
 
type
  Tvoiture = class
  porte,vitre: integer;
  vitesse : extended;
  conducteur : string ;
  function changerconducteur(conducteur : string): string;  Virtual
  constructor create;
  destructor destroy;
  end;
 
  TLimosine = class(Tvoiture)
  Picine : integer;
  nomdepicine : string;
  function changerconducteur(conducteur : string) : string; override;
  constructor create;
  destructor destroy;
 
  end;
 
implementation
  Constructor Tlimosine.create;
  begin
  end;
  destructor Tlimosine.destroy;
  begin
  end;
   function Tlimosine.changerconducteur(conducteur : string): string;
   begin
   showmessage('la fonction Mere est exécute');
   result := conducteur;
   end;
 
  function Tvoiture.changerconducteur(conducteur : string): string;
  begin
  showmessage('la fonction Mere Fille est exécute');
  result := conducteur;
 
  end;
 
procedure TForm1.Button1Click(Sender: TObject);
var
c:TLimosine ;
begin
c := TLimosine.create;
C.conducteur('Helmi');
end;

Quand je suprimme les directive "Virtual" & "Override" rien ne change dans le programme, j'aimerai savoir à qui servent ces dernieres.

merci

[Aka Guymelef]

Bonjour,

une méthode de classe avec la directive virtual indique que cette méthode est virtuelle et peut donc être redéfinie dans une classe héritée. Effectivement dans ton exemple l'utilité ne se voit pas car tu ne fais pas appel au traitement hérité. Je te propose ceci pour mieux voir.

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
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
 
type
  TVoiture = class( TObject )
  protected
   FConducteur: String;
  public
   Constructor Create;
   procedure ChangerConducteur( const AConducteur: String ); virtual;
  end;
 
  TLimousine = class( TVoiture )
  public
   procedure ChangerConducteur( const AConducteur: String ); override;
  end;
 
implementation
 
Constructor TVoiture.Create;
begin
  FConducteur := 'Inconnu';
end;
 
procedure TVoiture.ChangerConducteur( const AConducteur: String );
begin
  FConducteur := AConducteur;
  ShowMessage( 'Mère : ' + FConducteur );
end;
 
procedure TLimousine.ChangerConducteur( const AConducteur: String );
begin
  ShowMessage( 'Fille avant inherited : ' + FConducteur );
  inherited;
  ShowMessage( 'Fille après inherited : ' + FConducteur );
end;
 
procedure Main()
var
 v: TLimousine;
begin
  v := TLimousine.Create;
  try
   v.ChangerConducteur( 'Aka' );
 
  finally
   v.Free;
  end;
end;

[helmis]

Merci

si on supprime les directives "Virtual" & "Override" rien ne change dans le programme non plus dans le 2 ème Code(on a le même résultat avec ou sans ces derniers).

[Aka Guymelef]

Effectivement tel qu'est fait mon exemple ça ne change rien de mettre ou non les virtual & override. Mais cela est dû au fait qu'il n'utilise pas la notion de polymorphisme qui est une notion très importante en POO.

Maintenant reprend mon exemple en changeant

Code :

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

1
2
var
 v: TLimousine;

par

Code :

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

1
2
var
 v: TVoiture;

Tu pourras voir qu'avec les virtual & override on obtient bien le résultat attendu mais sans patatras.