Invocation

La seule opération que l'on peut faire sur une méthode est de l'invoquer, ou de l'appeler avec des arguments. Nous considérons d'abord le cas des méthodes d'instance, et nous verrons plus loin le cas des méthodes de classe. Une invocation, ou appel de méthode, est une expression formée à partir d'une expression cible, d'un << . >>, du nom de la méthode invoquée et d'une liste d'arguments placés entre << ( >> et << ) >>, par exemple p.translater(1,1). L'expression cible peut être un nom (par exemple, p), et en particulier this  ; l'invocation this.m(...) peut être simplifiée en m(...) à l'intérieur de la classe qui définit la méthode m. Signalons bien qu'une méthode f sans argument doit être invoquée par p.f() et non par p.f, notation qui confondrait invocation de méthode sans argument et accès à un champ. Le nombre des arguments (dans l'expression d'invocation) et le nombre des paramètres (dans la définition de la méthode) doivent être identiques : une invocation de p.translater(1, 2, 3) est illégale.

Le type d'un argument doit être égal au type du paramètre correspondant ou doit en être un sous-type ; par exemple, une méthode dont la déclaration comporte un paramètre de type int pourra être invoquée avec un argument de type byte, car byte est un sous-type de int, mais ne pourra pas être invoqué par un argument de type long, ni de type String, car long et String ne sont pas des sous-types de int.

L'évaluation d'une invocation de méthode, de la forme cible.m(arg₁, ...), se fait en plusieurs étapes que nous préciserons au § 1.9. Certaines étapes, fondées uniquement sur le type de l'expression cible et sur les types des arguments sont effectuées à la compilation. D'autres étapes nécessitent la connaissance de l'objet cible, et ne peuvent se faire qu'à l'exécution. Plusieurs traits importants sont mis en uvre dans ces diverses étapes : la résolution de la surcharge, la liaison tardive, le passage des arguments par valeur. On représentera une invocation par le symbole $\to$ : par exemple, main() $\to$calculAire(1000000) exprime que main() invoque calculAire(), avec l'argument 1000000. Il y a alors création en mémoire d'un cadre d'invocation   de la méthode invoquée, qui a pour but l'exécution du corps de cette méthode, et dont le contenu sera détaillé un peu plus loin.

Quand l'exécution du corps de la méthode invoquée est terminée, la méthode invoquée retourne. Si le type du résultat de la méthode invoquée est différent de void, la méthode retourne une valeur, qui est son résultat. La valeur retournée est celle de l'expression figurant dans l'instruction return exécutée (le corps de la méthode peut contenir plusieurs return, mais une seule sera exécutée, puisque la méthode retourne aussitôt après). Le type de cette expression doit être égal au type de retour de la méthode, ou en être un sous-type ; notamment, si ces types sont numériques, il y a conversion implicite de la valeur de l'expression de retour vers le type de retour quand cela est possible : par exemple un << return 3; >> dans une méthode déclarée retourner un double ne retournera pas l'entier 3, mais le double 3.0. On notera le retour d'une valeur v par le symbole $\stackrel{v}{\to}$ou par $\stackrel{v}{\gets}$ : calculAire(1000000) $\stackrel{3.14}{\to}$ main(), ou main() $\stackrel{3.14}{\gets}$ calculAire(1000000). Une méthode dont le type du résultat est void, retourne, mais ne retourne pas de valeur. On notera ces deux usages du verbe << retourner >>, intransitif en général, et transitif dans le cas d'une valeur.

L'invocation d'une méthode implique la création d'un cadre d'invocation, lequel a une existence dans la mémoire de la Machine Virtuelle Java et une durée de vie. La zone mémoire qui lui est attribuée comporte, entre autres, les informations suivants :

 
• les paramètres, initialisés par la valeur des arguments ;
• les variables locales ;
• la variable de retour, qui est initialisée par la valeur de l'expression E quand une instruction << return E; >> est exécutée par la méthode invoquée ;
• le point de retour, c'est-à-dire la désignation, dans le code du programme, de l'instruction qui sera exécutée juste après le retour de la méthode invoquée.

       Ce cadre d'invocation est placé dans une partie de la mémoire appelée la pile. La durée de vie de ce cadre est déterminée par l'exécution du corps de la méthode : il est empilé à l'invocation, c'est-à-dire placé au sommet de la pile, et il est dépilé au retour, c'est-à-dire retiré du sommet de la pile. Quand une méthode retourne, le cadre d'invocation qui avait été créé lors de son invocation est détruit, et les données qu'il contenait cessent d'être utilisables. Ce mode d'allocation de la mémoire est appelé allocation automatique, ou allocation sur la pile ; la plupart des langages disposent de ce mode d'allocation, à l'exception notable de Fortran 77.