Méthode Java

Dans les chapitres précédents, nous avons souvent utilisé System.out.println(), alors qu'est-ce que c'est ?

println() est une méthode (Method), et System est une classe système (Class), et out est un objet de sortie standard (Object). L'utilisation de cette phrase consiste à appeler la méthode println() dans l'objet de sortie standard de la classe système System.

Alors quelle est la méthode ?

Une méthode Java est un ensemble d’instructions qui exécutent ensemble une fonction.

• Une méthode est une combinaison ordonnée d’étapes pour résoudre un type de problème

• Méthodes contenues dans des classes ou des objets

• Les méthodes sont créées dans le programme et référencées ailleurs

définition de la méthode

Généralement, la définition d'une méthode inclut la syntaxe suivante :

 Nom de la méthode du type de valeur de retour du modificateur (nom du paramètre du type de paramètre) {
...
Corps de la méthode...
retourner la valeur de retour ;
}

Une méthode contient un en-tête de méthode et un corps de méthode. Voici toutes les parties d’une méthode :

• Modificateurs : les modificateurs, qui sont facultatifs, indiquent au compilateur comment appeler la méthode. Définit le type d'accès pour cette méthode.

• Type de valeur de retour : les méthodes peuvent renvoyer des valeurs. returnValueType est le type de données de la valeur de retour de la méthode. Certaines méthodes effectuent l'opération requise mais ne renvoient pas de valeur. Dans ce cas, returnValueType est le mot-clé void .

• Nom de la méthode : est le nom réel de la méthode. Le nom de la méthode et la liste des paramètres forment ensemble la signature de la méthode.

• Type de paramètre : le paramètre est comme un espace réservé. Lorsque la méthode est appelée, les valeurs sont transmises aux paramètres. Cette valeur est appelée paramètre ou variable réel. La liste des paramètres fait référence au type de paramètre, à l'ordre et au nombre de paramètres de la méthode. Les paramètres sont facultatifs et les méthodes ne peuvent contenir aucun paramètre.

• Corps de la méthode : le corps de la méthode contient des instructions spécifiques qui définissent la fonction de la méthode.

comme:

 publicstaticintage(intanniversaire){...}

Il peut y avoir plusieurs paramètres :

 staticfloatinterest(floatprincipal,intyear){...}

Remarque : Dans certaines autres langues, les méthodes font référence à des procédures et des fonctions. Une méthode qui renvoie une valeur de retour non vide est appelée une fonction ; une méthode qui renvoie une valeur de retour vide est appelée une procédure.

Exemple

La méthode ci-dessous contient 2 paramètres num1 et num2 et renvoie la valeur maximale de ces deux paramètres.

 /**Renvoie la plus grande valeur des deux données variables entières*/
publicstaticintmax(intnum1,intnum2){
Intérêt ;
si(num1>num2){
résultat=num1 ;
}autre{
résultat=num2 ;
}
retourner le résultat ;
}

appel de méthode

Java prend en charge deux manières d'appeler des méthodes, selon que la méthode renvoie ou non une valeur.

Lorsqu'un programme appelle une méthode, le contrôle du programme est transféré à la méthode appelée. Le contrôle est renvoyé au programme lorsque l'instruction return de la méthode appelée est exécutée ou que la parenthèse fermante du corps de la méthode est atteinte.

Lorsqu'une méthode renvoie une valeur, l'appel de méthode est généralement traité comme une valeur. Par exemple:

 intlarger=max(30,40);

Si la valeur de retour de la méthode est nulle, l'appel de méthode doit être une instruction. Par exemple, la méthode println renvoie void. L'appel suivant est une déclaration :

 System.out.println("Bienvenue sur Java !");

Exemple

L'exemple suivant montre comment définir une méthode et comment l'appeler :

 publicclassTestMax{
/**Méthode principale*/
publicstaticvoidmain(String[]args){
inti=5;
intj=2;
intk=max(je,j);
System.out.println("Le maximum entre"+i+
"et"+j+"est"+k);
}

/**Renvoie la plus grande valeur des deux variables entières*/
publicstaticintmax(intnum1,intnum2){
Intérêt ;
si(num1>num2){
résultat=num1 ;
}autre{
résultat=num2 ;
}
retourner le résultat ;
}
}

Les résultats de compilation et d'exécution de l'exemple ci-dessus sont les suivants :

 Le maximum entre 5 et 2 est de 5

Ce programme contient la méthode principale et la méthode max. La méthode Main est appelée par la JVM. En dehors de cela, la méthode main n'est pas différente des autres méthodes.

L'en-tête de la méthode main reste inchangé, comme le montre l'exemple, avec les modificateurs public et static, renvoie une valeur de type void, le nom de la méthode est main et prend un paramètre de type String[]. String[] indique que le paramètre est un tableau de chaînes.

mot-clé vide

Cette section explique comment déclarer et appeler une méthode void.

L'exemple suivant déclare une méthode nommée printGrade et l'appelle pour imprimer la note donnée.

Exemple

 publicclassTestVoidMethod{

publicstaticvoidmain(String[]args){
printGrade(78,5);
}

publicstaticvoidprintGrade(double score){
si(score>=90,0){
System.out.println('A');
}
sinon(score>=80,0){
System.out.println('B');
}
sinon(score>=70,0){
System.out.println('C');
}
sinon(score>=60,0){
System.out.println('D');
}
autre{
System.out.println('F');
}
}
}

Les résultats de compilation et d'exécution de l'exemple ci-dessus sont les suivants :

 C

La méthode printGrade ici est une méthode de type void et elle ne renvoie pas de valeur.

Un appel à une méthode void doit être une instruction. Par conséquent, il est appelé comme instruction sur la troisième ligne de la méthode principale. Comme toute instruction se terminant par un point-virgule.

Passer les paramètres par valeur

Lorsque vous appelez une méthode, vous devez fournir des paramètres et vous devez les fournir dans l'ordre spécifié dans la liste des paramètres.

Par exemple, la méthode suivante imprime un message n fois de suite :

 publicstaticvoidnPrintln(Stringmessage,intn){
pour(inti=0;i<n;i++)
System.out.println(message);
}

Exemple

L’exemple suivant montre l’effet du passage par valeur.

Ce programme crée une méthode qui échange deux variables.

 publicclassTestPassByValue{

publicstaticvoidmain(String[]args){
numéroint1=1 ;
numéroint2=2 ;

System.out.println("Avant la méthode d'échange,num1is"+
num1+"etnum2est"+num2);

//Appelle la méthode swap swap(num1,num2);
System.out.println("Afterswapmethod,num1is"+
num1+"etnum2est"+num2);
}
/**Méthode pour échanger deux variables*/
publicstaticvoidswap(intn1,intn2){
System.out.println("tInsidetheswapmethod");
System.out.println("ttAvant l'échangen1is"+n1
+"n2est"+n2);
//Échangez les valeurs de n1 et n2 inttemp=n1;
n1 = n2 ;
n2=température ;

System.out.println("ttAfterswappingn1is"+n1
+"n2est"+n2);
}
}

Les résultats de compilation et d'exécution de l'exemple ci-dessus sont les suivants :

 Avant la méthode d'échange, num1is1 et num2is2
À l'intérieur de la méthode d'échange
Avant d'échangern1is1n2is2
Après échangen1is2n2is1
Méthode d'échange après, num1is1 et num2is2

Appelez la méthode swap en passant deux paramètres. Fait intéressant, les valeurs des paramètres réels ne changent pas après l'appel de la méthode.

Surcharge de méthode

La méthode max utilisée ci-dessus s'applique uniquement aux données de type int. Mais que se passe-t-il si vous souhaitez obtenir la valeur maximale de deux types de données à virgule flottante ?

La solution consiste à créer une autre méthode avec le même nom mais des paramètres différents, comme indiqué dans le code suivant :

 publicstaticdoublemax(doublenum1,doublenum2){
si(num1>num2){
returnnum1 ;
}autre{
returnnum2;
}
}

Si vous passez un paramètre int lors de l'appel de la méthode max, la méthode max du paramètre int sera appelée ;

Si un paramètre double est passé, le corps de la méthode max du type double sera appelé. C'est ce qu'on appelle la surcharge de méthode ;

Autrement dit, deux méthodes d’une classe ont le même nom, mais des listes de paramètres différentes.

Le compilateur Java détermine quelle méthode doit être appelée en fonction de la signature de la méthode.

La surcharge de méthodes peut rendre le programme plus clair et plus facile à lire. Les méthodes qui effectuent des tâches étroitement liées doivent utiliser le même nom.

Les méthodes surchargées doivent avoir des listes de paramètres différentes. Vous ne pouvez pas surcharger les méthodes basées uniquement sur des modificateurs ou des types de retour.

portée variable

La portée d'une variable est la partie du programme à partir de laquelle la variable peut être référencée.

Les variables définies dans une méthode sont appelées variables locales.

La portée d'une variable locale commence à sa déclaration et se termine à la fin du bloc qui la contient.

Les variables locales doivent être déclarées avant de pouvoir être utilisées.

La portée des paramètres d’une méthode couvre l’ensemble de la méthode. Le paramètre est en fait une variable locale.

Les variables déclarées dans la partie initialisation de la boucle for ont une portée tout au long de la boucle.

Mais le champ d'application de la variable déclarée dans le corps de la boucle s'étend de sa déclaration jusqu'à la fin du corps de la boucle. Il contient des déclarations de variables comme indiqué ci-dessous :

Vous pouvez déclarer une variable locale portant le même nom plusieurs fois au sein d'une méthode, dans différents blocs non imbriqués, mais vous ne pouvez pas déclarer une variable locale deux fois dans un bloc imbriqué.

Utilisation des paramètres de ligne de commande

Parfois, vous souhaitez transmettre des messages à un programme pendant son exécution. Ceci est accompli en passant des arguments de ligne de commande à la fonction main().

Les paramètres de ligne de commande sont les informations qui suivent immédiatement le nom du programme lors de l'exécution du programme.

Exemple

Le programme suivant imprime tous les arguments de la ligne de commande :

 publicclassCommandLine{
publicstaticvoidmain(Stringargs[]){
pour(inti=0;i<args.length;i++){
System.out.println("args ["+i+"]:"+args[i]);
}
}
}

Exécutez le programme comme indiqué ci-dessous :

 javaCommandLinethisisacommandline200-100

Les résultats en cours d'exécution sont les suivants :

 arguments[0] : ceci
arguments[1]:est
arguments[2] : un
arguments[3] : commande
arguments[4]:ligne
arguments[5]:200
arguments[6] : -100

Constructeur

Lorsqu'un objet est créé, les constructeurs sont utilisés pour initialiser l'objet. Le constructeur porte le même nom que la classe à laquelle il appartient, mais le constructeur n'a aucune valeur de retour.

Les constructeurs sont généralement utilisés pour attribuer des valeurs initiales aux variables d'instance d'une classe ou pour effectuer d'autres étapes nécessaires pour créer un objet complet.

Que vous personnalisiez ou non le constructeur, toutes les classes ont des constructeurs car Java fournit automatiquement un constructeur par défaut qui initialise tous les membres à 0.

Une fois que vous avez défini votre propre constructeur, le constructeur par défaut devient invalide.

Exemple

Voici un exemple utilisant les méthodes du constructeur :

 //Un constructeur simple classMyClass statique{
intx;

//Ce qui suit est le constructeur MyClass(){
x=10 ;
}
}

Vous pouvez initialiser un objet en appelant le constructeur comme ceci :

 publicclassConsDemo{
publicstaticvoidmain(Stringargs[]){
MaClasse1=nouvelleMaClasse();
MaClasse2=nouvelleMaClasse();
System.out.println(t1.x+""+t2.x);
}
}

La plupart du temps, un constructeur avec des paramètres est nécessaire.

Exemple

Voici un exemple utilisant les méthodes du constructeur :

 //Un constructeur simple classMyClass{
intx;

//Ce qui suit est le constructeur MyClass(inti){
x = je;
}
}

Vous pouvez initialiser un objet en appelant le constructeur comme ceci :

 publicclassConsDemo{
publicstaticvoidmain(Stringargs[]){
MaClasse1=nouvelleMaClasse(10);
MaClasse2=nouvelleMaClasse(20);
System.out.println(t1.x+""+t2.x);
}
}

Les résultats en cours d'exécution sont les suivants :

 1020

Paramètres variables

À partir du JDK 1.5, Java prend en charge la transmission de paramètres variables du même type à une méthode.

La déclaration des paramètres variadiques de la méthode ressemble à ceci :

 typeName...parameterName

Dans une déclaration de méthode, ajoutez des points de suspension (...) après avoir spécifié le type de paramètre.

Un seul paramètre variable peut être spécifié dans une méthode et il doit s'agir du dernier paramètre de la méthode. Tous les paramètres ordinaires doivent être déclarés avant celui-ci.

Exemple

 publicclassVarargsDemo{

publicstaticvoidmain(Stringargs[]){
//Appelle la méthode du paramètre variable printMax(34,3,3,2,56.5);
printMax(nouveaudouble[]{1,2,3});
}

publicstaticvoidprintMax(double...nombres){
si(nombres.longueur==0){
System.out.println("Noargumentpassed");
retour;
}

doubleresult=nombres[0];

pour(inti=1;i<nombres.longueur;i++)
si(nombres[i]>résultat){
résultat=nombres[i];
}
System.out.println("Themaxvalueis"+result);
}
}

Les résultats de compilation et d'exécution de l'exemple ci-dessus sont les suivants :

 La valeur maximale est de 56,5.
La valeur maximale est 3,0

méthode finaliser()

Java permet la définition d'une telle méthode, qui est appelée avant que l'objet ne soit détruit (recyclé) par le garbage collector. Cette méthode est appelée finalize(), qui est utilisée pour effacer l'objet recyclé.

Par exemple, vous pouvez utiliser finalize() pour garantir qu'un fichier ouvert par un objet est fermé.

Dans la méthode finalize(), vous devez spécifier les opérations à effectuer lors de la destruction de l'objet.

Le format général de finalize() est :

 protégévoidfinalize()
{
//Code du terminal ici}

Le mot-clé protected est un qualificatif qui garantit que la méthode finalize() ne sera pas appelée par du code extérieur à la classe.

Bien entendu, le recyclage de la mémoire Java peut être automatiquement effectué par la JVM. Si vous l'utilisez manuellement, vous pouvez utiliser la méthode ci-dessus.

Exemple

 publicclassFinalizationDemo{
publicstaticvoidmain(String[]args){
Gâteauc1=nouveauCake(1);
Cakec2=nouveauCake(2);
Cakec3=nouveauCake(3);

c2=c3=nul ;
System.gc();//Appel du garbage collector Java}
}

classCakeextendsObject{
identificateur privé ;
publicCake(intid){
this.id=id;
System.out.println("CakeObject"+id+"iscreated");
}

protectedvoidfinalize()throwsjava.lang.Throwable{
super.finalize();
System.out.println("CakeObject"+id+"isdisposed");
}
}

En exécutant le code ci-dessus, les résultats de sortie sont les suivants :

 C:1>javaFinalizationDemo
CakeObject1 est créé
CakeObject2 est créé
CakeObject3 est créé
CakeObject3 est éliminé
CakeObject2 est supprimé