Méthodes De Java

Share

|

Des méthodes sont employées pendant que les modules de votre programme, exécutant charge qui peuvent s'appeler à plusieurs reprises et en utilisant le même code pour exécuter le charger chaque fois. Les parties de base mais fondamentales de la déclaration d'une méthode sont son nom, son type de retour, signature de paramètre, et parenthèses bouclées de segment de code. Les lignes suivantes du code sont un exemple d'une déclaration de méthode.

doSomething() vide de charge statique {// ajoutent le code
ici}

Cette méthode s'appelle doSomething et a un type de retour de vide, qui indique simplement que la méthode ne renvoie pas une valeur. Nous avons déjà vu le vide de mot-clé, qui est le type de retour de la force de méthode. Si la méthode doSomething étaient ajoutées à votre classe principale de programme, alors dans la méthode principale de classe vous appelleriez la méthode doSomething en écrivant le code suivant :

doSomething() ;

Notez les besoins doSomething de méthode d'être statique à l'heure actuelle parce que la force de méthode, dont nous assumons la méthode doSomething va s'appeler, est également charge statique. La méthode doSomething n'aurait pas besoin d'être statique si nous créions un exemple de la classe à laquelle doSomething appartiendrait.

Si vous voulez une méthode qui renvoie une valeur, vous devez indiquer le type de retour de la méthode, et alors vous devez employer le retour de mot-clé dans le bloc de code de méthode pour indiquer la valeur retournée.

getFiveDoubled() interne statique {retour 10 ; }

La méthode suivante renverra simplement la valeur de 10 à partout où elle s'est appelée de. La ligne suivante du code a pu être ajoutée, par exemple, dans votre méthode principale pour assigner cette valeur à une variable :

myNumber = getFiveDoubled() internes ;

Cette ligne de code assignera la valeur de 10 au myNumber variable.

Notez juste parce que la méthode getFiveDoubled a maintenant un type de retour, il ne signifie pas qu'elle ne peut pas être invitée ses propres.

getFiveDoubled() ;

Cette méthode ne fera essentiellement rien, mais vous pouvez avoir une méthode qui exécute exigé chargent et puis renvoyez une valeur, que vous voulez ignorer.

Une méthode qui a une valeur de retour (pas vide) doit avoir un rapport de retour à chaque point possible de sortie de la méthode. Le compilateur reprendra si un chemin sans valeur de retour est possible. D'autre part, si vous avez une méthode avec le type de retour vide et puis voulez sortir hors de la méthode tôt, vous pouvez employer le retour de mot-clé seule. Par exemple, prenez le code suivant :

retour vide de doSomething() de public {if(leaveEarly == 
vrai) ; //continuent autrement le reste du code}

C'est semblable à la façon dont le rapport de coupure est employé pour sortir hors de certains blocs de code, tels que des cas de commutateur et des boucles, comme nous avons vu plus tôt. L'exemple que nous avons juste vu est un exemple très de base, mais l'utilisation du retour de mot-clé dans ce cas peut être très utile pour sortir immédiatement hors des faisceaux compliqués de code dans une méthode donnée.

Dépassement De Paramètre

La méthode précédente, getFiveDoubled, est parce qu'elle renverra seulement une valeur, 10 assez injustifiés et très incommodes. Cependant, nous pourrions créer une méthode qui prendra dans tout nombre, le doublons, et puis renvoyons la valeur doublée. Ceci peut être réalisé en utilisant le dépassement de paramètre. Le dépassement de paramètre vous permet de passer des valeurs à une méthode que la méthode peut alors manoeuvrer. La méthode suivante contient un paramètre, qui est doublé et la nouvelle valeur est retournée.

nombre interne de doubleNumber(int) {nombre * = 2 ; 
nombre de retour ; }

Comme vous pouvez voir, le paramètre est un nombre appelé variable de type interne et est indiqué entre les parenthèses qui suivent le nom de la méthode. Pour appeler cette méthode, vous pourriez, par exemple, employer le code suivant :

//double 2 du myNumber interne des égales 4 = 
doubleNumber(2) ; //doublent alors son nombre courant 4 de 
myNumber = de doubleNumber(myNumber) des égales 8 ; 
//quadruplent alors son nombre courant pour égaler le myNumber 
32 = le doubleNumber(doubleNumber(myNumber)) ;

Cette dernière ligne de code appellera le doubleNumber de méthode deux fois, d'abord renvoyant une valeur qui est la double la valeur du myNumber, qui alternativement est alors passé car un paramètre au deuxième appel au doubleNumber qui renvoie par la suite la valeur finale de 32, l'assignant au myNumber variable.

Pour réitérer ce que nous avons cité précédemment, si la valeur que vous passez pendant qu'un paramètre est d'un type de données primitif variable, la variable elle-même n'est pas passée à la méthode. Une nouvelle variable avec cette valeur est créée dans la méthode et puis employée. Ceci signifie que les changements faits à cette valeur à l'intérieur de la méthode appelée n'affecteront pas la valeur de la variable originale.

Vous pouvez également avoir plus d'un paramètre, en utilisant une virgule pour séparer des paramètres consécutifs. L'exemple simple suivant, SpidersEyes.java, contient la méthode se multiplient, qui contient deux paramètres qui sont deux du type interne et renvoie la valeur des deux paramètres multipliés ensemble. Voici le code :

classe publique SpidersEyes {valueA interne statique 
public de multiply(int, valueB interne) {valueA de retour * valueB ; 
} args[ main(String vide de charge statique publique ]) 
{numberOfSpiders internes = 10 ; eyesPerSpider interne = 8 ; 
totalEyes = multiply(numberOfSpiders, eyesPerSpider internes) ; 
System.out.println("Total observe =" + des totalEyes) ; 
}}

Il y a deux choses à noter de cet exemple. D'abord, nous avons employé la charge statique de mot-clé pour la méthode nous multiplions. C'est parce qu'il n'y a aucun exemple de la classe SpidersEyes actuellement créé, ainsi afin la force, qui est statique, à pouvoir accéder à la méthode se multiplient, il doit être statique également. La deuxième chose à la notification est que la force de méthode prend également un paramètre, qui est une rangée de cordes.

Signatures De Méthode

Il est possible d'avoir deux méthodes qui partagent le même nom. Cependant, elles doivent avoir différentes signatures parce qu'autrement quand vous souhaitez appeler une des méthodes, le compilateur n'a aucune manière de différencier un de l'autre, car l'invocation de la méthode est basée sur le compilateur identifiant la signature. Ayant des méthodes de même nom mais avec différentes signatures est connu en tant que surcharge de la méthode.

Le nom de la méthode et la signature de paramètre de cette méthode déterminent la signature d'une méthode. Le type de retour d'une méthode n'influence pas sa signature. Par conséquent vous ne pouvez pas avoir deux méthodes avec le même nom avec deux valeurs de retour différentes avec la même signature de paramètre.

Dans l'exemple précédent, SpidersEyes.java, nous avons fait appeler une méthode pour se multiplier, qui a pris deux valeurs de paramètre de type internes, renvoyant la valeur des valeurs de paramètre multipliées ensemble. Si nous également incluions une méthode qui a fait la même chose mais employions des valeurs de type double à la place, nous pourrions créer une autre méthode avec le même nom mais avec une signature différente de paramètre.

multiply(int interne statique public a, b) interne 
{renvoyez a * b ; } double a multiply(double statique public, 
double b) {renvoyez a * b ; }

La signature de paramètre est déterminée par les types de données des paramètres et donc des nombres de paramètres aussi. Disons que nous avons maintenant ajouté la méthode suivante ainsi que les deux méthodes précédentes :

long multiply(int statique public a, b) interne {retour 
(long)(a * b) ; }

Le programme ne compilerait plus parce que cette méthode et l'original multiplient la part de méthode la même signature. Ils ont le même nom et également les mêmes paramètres tous les deux—de la signature deux de paramètre du type interne. La solution la plus évidente est de changer la signature de paramètre de la dernière méthode en paramètres de la prise deux de type longs.

long multiply(long statique public a, long b) {renvoyez a 
* b ; }

Ceci fonctionnera maintenant parce que les signatures de paramètre sont différentes. Si vous ne pouvez pas changer la signature de paramètre d'une façon raisonnable, ne tracassez pas ; élasticité juste les différents noms de méthodes (par exemple, multiplyInt, multiplyDouble, multiplyLong, etc.).