FAQ PascalConsultez toutes les FAQ

Une méthode décrit des opérations applicables grâce à une classe. Elle est soit une procédure soit une fonction encapsulée dans une classe. L'accès à une méthode suit le schéma suivant :

NomDeLObjet.NomDeLaMethode

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
  
interface 
  
type 
  TMyClass = class 
    private 
       fMyInt: Integer; 
   public 
      function DoubleInt: Integer; 
      property MyInt: Integer read fMyInt write fMyInt; 
  end; 
  
implementation 
  
function TMyClass.DoubleInt; 
begin 
  Result := MyInt * 2; 
end; 
  
[...] 
  
var 
  MyObject: TMyClass; 
  I: Integer; 
  
[...] 
  MyObject := TMyClass.Create; 
  MyObject.MyInt := 4; 
  I := MyObject.DoubleInt; // I vaut 2 fois 4 = 8 
[...] 
  MyObject.Free;

Les méthodes comme Free et Create ne sont pas déclarées par vous et vous pouvez cependant les utiliser. Ce phénomène paraît contredire le principe pascalien qui veut que tout identificateur doit être déclaré avant de pouvoir être utilisé.

En fait, toute classe déclarée hérite d'une classe racine baptisée TObject. C'est cette dernière qui déclare et implémente ces méthodes mystérieuses.

Ainsi :

1
2
3
4
type 
  TMyClass = class 
  [...] 
  end;

1
2
3
4
type 
  TMyClass = class(TObject) 
  [...] 
  end;

Les méthodes statiques se comportent comme des procédures ou des fonctions ordinaires à ceci près qu’elles ont besoin d’un objet pour être invoquées. Elles sont dites statiques parce que le compilateur crée les liens nécessaires à leur accès dès la compilation : elles sont ainsi particulièrement rapides, mais manquent de souplesse en se refusant à tout polymorphisme. Pour les utiliser, il suffit de les déclarer, sans autre précision.

Une méthode statique peut être redéfinie dans les classes qui en héritent.

Dans l'exemple suivant, la méthode DoSomething sera statique :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
type 
  TMyClass = class 
  public 
    procedure DoSomething; 
  end; 
  
[...] 
  
implementation 
  
procedure TMyClass.DoSomething; 
begin 
  Beep; 
  Sleep(200); 
  Beep; 
end;

Contrairement aux méthodes statiques dont le compilateur détermine directement les adresses au moment de la compilation, les méthodes virtuelles sont accessibles via une table qui porte le nom de VMT (Virtual Method Table, soit table des méthodes virtuelles). C'est elle qui permet de retrouver à l’exécution l'adresse de chacune des méthodes dont la classe a hérité et de celles qu’elle a elle-même définies.

Une méthode virtuelle autorise la mise en œuvre du polymorphisme. Pour la déclarer, il faut faire suivre sa déclaration de la directive virtual. Pour la redéclarer dans une sous-classe, il faut faire suivre sa déclaration de la directive override.

1
2
3
4
5
6
7
8
9
10
type 
  TMyClass = class 
  public 
    MyProc(AValue: string); virtual; 
  end; 
  
  TMySubClass = class(TMyClass) 
  public 
    MyProc(AValue: string); override; 
  end;

Le mot réservé inherited permet d’hériter du comportement d'une méthode d’un parent tout en autorisant des compléments.

Dans l'exemple suivant, si TChien descend de TAnimal, l'appel à la méthode Manger de TChien affichera 'Je mange... mais principalement de la viande !' :

1
2
3
4
5
6
7
8
9
10
procedure TAnimal.Manger; 
begin 
  writeln('Je mange.'); 
end; 
  
procedure TChien.Manger; 
begin 
  inherited Manger; // on hérite de la méthode du parent 
  writeln('.. mais principalement de la viande !'); 
end;

La directive override définit une méthode de classe comme surchargeant la même méthode nommée dans une classe parente. L'ancienne méthode est toujours accessible grâce à inherited.

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
  
type 
  TMyClass = class 
    procedure MyProc; virtual; 
  end; 
  
  TMySubClass = class(TMyClass) 
    procedure MyProc; override; 
  end; 
  
[...] 
  
implementation 
  
  procedure TMyClass.MyProc; 
  begin 
    Width := 50; 
    Height := 60; 
  end; 
  
  procedure TMySubClass.MyProc; 
  begin 
    inherited; // on reprend ce que fait la méthode de l'ancêtre 
    Top := 100; // nouvelle valeur 
  end;

Avec Free Pascal, une méthode marquée dynamic n'est rien d'autre qu'une méthode virtuelle. dynamic est par conséquent équivalent à virtual.

La directive dynamic existe pour la compatibilité avec Delphi.

La directive reintroduce signifie au compilateur que l'écrasement de la méthode virtuelle de l'ancêtre est volontaire.
Redéfinir complètement une méthode virtuelle par une méthode statique provoque un avertissement du compilateur : faire suivre la redéfinition de la méthode virtuelle par la directive reintroduce évite cet avertissement.

1
2
3
4
5
6
7
8
// méthode du parent 
TMyClass = class 
  procedure MyProc; // la méthode est virtuelle 
end; 
  
// méthode du descendant 
TMySubClass = class(TMyClass) 
procedure MyProc; reintroduce; // la méthode virtuelle est écrasée

Une méthode abstraite est un squelette de méthode déclarée dans une classe, mais non implémentée. Ce sont les descendants de la classe où la déclaration a eu lieu qui l'implémenteront en temps voulu.

1
2
3
4
5
6
7
8
9
10
type 
  TMyClass = class 
  public 
    procedure DoSomething;  virtual; abstract; 
 end; 
  
  TMySubClass = class(TMyClass) 
  public 
    procedure DoSomething; override; 
  end;

L'intérêt de la directive abstract est d'unifier les déclarations et le comportement des classes tout en bénéficiant totalement du polymorphisme si nécessaire.

Par exemple, les descendants de TStrings procéderont à l'implémentation de ses méthodes abstraites tandis qu'en tant qu’ancêtre, TStrings sera d’une grande polyvalence puisque n'importe quel descendant pourra prendre sa forme.

Comparez :

1
2
3
4
5
6
7
procedure Afficher(Sts: TStringList); 
var 
  LItem: string; // variable locale pour récupérer les chaînes une à une 
begin 
  for LItem in Sts do // on balaie la liste 
    writeln(LItem); // et on affiche l’élément en cours 
end;

1
2
3
4
5
6
7
procedure Afficher(Sts: TStrings); // <= seul changement 
var 
  LItem: string; 
begin 
  for LItem in Sts do 
    writeln(LItem); 
end;

Avec les méthodes de classe, vous ne vous intéresserez plus à l’instanciation, mais à la manipulation directe de la classe. Dans d’autres domaines, on parlerait de métadonnées. Il est par conséquent inutile d’instancier une classe pour accéder à ces méthodes particulières, même si cela reste possible.

La déclaration d’une méthode de classe se fait en plaçant le mot-clé class avant de préciser s’il s’agit d’une procédure ou d’une fonction.

Par exemple, voici comment déclarer une fonction qui renverrait le copyright associé à un programme :

1
2
3
4
5
6
  
type 
  TMyClass = class 
  public 
     class function Copyright: string; 
  end;

1
2
3
4
class function TMyClass.Copyright: string; 
begin 
  Result := 'www.developpez.com 2016'; 
end;

MyLabel.Caption := TMyClass.Copyright;

En ajoutant la directive static à la fin de la déclaration d’une méthode de classe, vous obtenez une méthode statique de classe.

Une méthode statique de classe ne connaît ni le paramètre Self ni la virtualité. En fait, une méthode de ce type se comporte en tout point comme procédure ou fonction ordinaires.

1
2
3
4
5
6
7
8
9
10
11
type 
  
  TMyClass = class 
    private 
      class var fMyValue: string; 
    protected 
      class procedure SetMyValue(const AValue: string); static; 
      class function GetMyValue: string; static; 
    public 
      class property MyValue: string read GetMyValue write SetMyValue; 
  end;