![]() |
![]() |
![]() |
![]() |
![]() |
![]() |
La notion de fonction et de méthode |
On appelle fonction un sous-programme qui permet d'effectuer un ensemble d'instruction par simple appel de la fonction dans le corps du programme principal. Les fonctions permettent d'exécuter dans plusieurs parties du programme une série d'instructions, cela permet une simplicité du code et donc une taille de programme minimale. D'autre part, une fonction peut faire appel à elle-même, on parle alors de fonction récursive (il ne faut pas oublier de mettre une condition de sortie au risque sinon de ne pas pouvoir arrêter le programme...).
Une méthode est une fonction faisant partie d'une classe. Elle permet d'effectuer des traitements sur (ou avec) les données membres.
La déclaration d'une méthode |
Avant d'être utilisée, une méthode doit être définie car pour l'appeler dans une classe il faut que le compilateur la connaisse, c'est-à-dire qu'il connaisse son nom, ses arguments et les instructions qu'elle contient. La définition d'une méthode s'appelle "déclaration". La déclaration d'une fonction se fait selon la syntaxe suivante:
type_de_donnee Nom_De_La_Methode(type1 argument1, type2 argument2, ...) {
liste d'instructions
}
Remarques:
![]() |
|
Appel de méthode |
Pour exécuter une méthode, il suffit de faire appel à elle en écrivant son nom (une fois de plus en respectant la casse) suivie d'une parenthèse ouverte (éventuellement des arguments) puis d'une parenthèse fermée:
Nom_De_La_méthode();
Remarques:
![]() |
Java impose qu'une fonction qui ne retourne aucune valeur soit précédée du type void! |
Les arguments d'une méthode |
Il est possible de passer des arguments (appelés aussi paramètres à une méthode, c'est-à-dire
lui fournir une valeur ou le nom d'une variable afin que la méthode puisse effectuer
des opérations sur ces arguments ou bien grâce à ces arguments.
Le passage d'arguments à une méthode se fait au moyen d'une liste
d'arguments (séparés par des virgules) entre parenthèses suivant immédiatement le nom de la méthode.
Le nombre et le type d'arguments dans la déclaration, le prototype et dans l'appel doit correspondre, au risque, sinon, de génerer une erreur lors de la compilation...
Un argument peut être:
Valeur par défaut des arguments |
Il arrive généralement que l'on ait à passer souvent une même
valeur en paramètre à une méthode. Ainsi, pour simplifier les appels de méthodes
comportant un paramètre qui varie peu, Java permet de déclarer des valeurs
par défaut dans la déclaration de la méthode, par exemple:
void methode(int parametre1, char parametre2, float parametre3 = 4.5);
public static void main() {
char c='a';
methode(8,c);
}
void methode(int parametre1, char parametre2, float parametre3){
System.out.print(parametre1+" "+parametre2+" "+parametre3);
}
(la méthode System.out.print() permet d'afficher parametre1, parametre2, et parametre3 séparés par des espaces)
![]() |
|
Renvoi d'une valeur par une méthode |
La méthode peut renvoyer une valeur (et donc se terminer) grâce au mot-clé return. Lorsque l'instruction return est rencontrée, la méthode évalue la valeur qui la suit, puis la renvoie au programme appelant (classe à partir de laquelle la méthode a été appelée).
Une méthode peut contenir plusieurs instructions return, ce sera toutefois la première instruction return rencontrée qui provoquera la fin de l'exécution de la méthode et le renvoi de la valeur qui la suit.
La syntaxe de l'instruction return est simple:
return valeur_ou_variable;
![]() |
Le type de valeur retourné doit correspondre à celui qui a été précisé dans la définition |
La surcharge de méthode |
Un des apports les plus intéressants du Java, hormis l'ajout du
concept objet, est la possibilité d'appeler plusieurs méthodes avec le même
nom, pour peu que celle-ci aient leurs arguments différents (en type et/ou en nombre).
Ce principe est appelé surcharge de méthode. Il permet de donner le même nom
à des méthodes comportant des paramètres différents et simplifie donc l'écriture
de méthodes sémantiquement similaires sur des paramètres de type différent.
En effet, une méthode est déterminé par ce que l'on appelle sa signature, c'est-à-dire:
Il est ainsi possible de définir une méthode réalisant la même opération sur des variables différentes en nombre ou en type:
int somme( int p1, int p2){
return (p1 + p2);
}
float somme( float p1, float p2){
return (p1 + p2);
}
float somme( float p1, float p2, float p3){
return (p1 + p2 + p3);
}
int somme( float p1, int p2){
return (int(p1) + p2);
}