Une méthode Java est une combinaison de certaines déclarations pour effectuer une opération. Par exemple, lorsque vous appelez la méthode System.out.println, le système exécutera en fait de nombreuses instructions pour sortir des informations sur la console.
Vous apprendrez maintenant à créer vos propres méthodes. Ils peuvent avoir des valeurs de retour ou aucune valeur de retour, peuvent avoir des paramètres ou aucun paramètre. Les méthodes de surcharge doivent utiliser le même nom de méthode et utiliser des méthodes abstraites dans la programmation.
Méthode de création
Utilisons l'exemple suivant pour expliquer la syntaxe de la méthode:
public static int funcname (int a, int b) {// body}Ici
Les méthodes contiennent également des procédures ou des fonctions.
La définition d'une méthode comprend un en-tête de méthode et un corps de méthode. Comme indiqué ci-dessous:
Modificier returnType NameofMethod (Liste des paramètres) {// Méthode Body}La syntaxe ci-dessus comprend
Exemple
Il s'agit de la méthode Max () définie ci-dessus, qui accepte deux paramètres num1 et num2 pour renvoyer la valeur maximale entre les deux.
/ ** L'extrait renvoie le minimum entre deux nombres * / public static int minfunction (int n1, int n2) {int min; if (n1> n2) min = n2; else min = n1; retourne min; } Appel de méthode
Pour utiliser une méthode, la méthode doit être appelée. Il existe deux façons d'appeler la méthode, l'une a une valeur de retour et l'autre n'a pas de valeur de retour.
Appeler une méthode est très simple. Lorsqu'un programme doit appeler une méthode, le programme de contrôle transfère à la méthode appelée. La méthode renverra deux conditions à l'appelant:
Prenez la méthode qui renvoie vide en tant qu'énoncé d'appel, permettez-moi de voir l'exemple suivant:
System.out.println ("wiki.jikexueyuan.com!");La valeur de retour de cette méthode peut être comprise par l'exemple suivant:
INT Result = sum (6, 9);
Exemple
L'exemple suivant montre comment définir une méthode et comment l'appeler:
classe publique exampleMinnumber {public static void main (String [] args) {int a = 11; int b = 6; int c = minfunction (a, b); System.out.println ("Minimum Value =" + C); } / ** Renvoie le minimum de deux nombres * / public static int minFunction (int n1, int n2) {int min; if (n1> n2) min = n2; else min = n1; retourne min; }}Les résultats suivants seront produits
Valeur minimale = 6
Mot-clé vide
Le mot-clé void nous permet de créer une méthode sans valeur de retour. Ici, nous créons une méthode vide méthodeRankpoints dans l'exemple suivant. Cette méthode n'a pas de type de valeur de retour. L'appel de la méthode vide doit déclarer MethodRankpoints (255.7); La déclaration Java se termine par un point-virgule, comme indiqué ci-dessous:
classe publique ExempleVoid {public static void main (String [] args) {MethodRankpoints (255.7); } public static void MethodRankpoints (doubles points) {if (Points> = 202.5) {System.out.println ("Rank: A1"); } else if (Points> = 122.4) {System.out.println ("Rank: A2"); } else {System.out.println ("Rank: A3"); }}}Cela produira les résultats suivants:
Rang: A1
Passer les paramètres par des valeurs
Les paramètres doivent être passés lors de l'appel d'une fonction. Et leur ordre doit être le même que l'ordre des paramètres lorsqu'ils ont été créés. Les paramètres peuvent être transmis par des valeurs ou des références.
Passer des paramètres à travers des valeurs signifie appeler le paramètre de la méthode, transmis au paramètre via la valeur du paramètre.
Exemple
Le programme suivant donne un exemple pour montrer que les paramètres sont passés par des valeurs. La valeur du paramètre ne changera pas après avoir appelé la méthode.
classe publique swappingExample {public static void main (String [] args) {int a = 30; int b = 45; System.out.println ("Avant d'échanger, a =" + a + "et b =" + b); // invoque la méthode d'échange swapfunction (a, b); System.out.println ("/ n ** maintenant, avant et après les valeurs d'échange seront les mêmes ici **:"); System.out.println ("après échange, a =" + a + "et b est" + b); } public static void swapFunction (int a, int b) {System.out.println ("avant d'échanger (à l'intérieur), a =" + a + "b =" + b); // échange n1 avec n2 int c = a; a = b; b = c; System.out.println ("après échange (à l'intérieur), a =" + a + "b =" + b); }}Cela produira les résultats suivants:
Avant d'échanger, a = 30 et b = 45 avant d'échanger (à l'intérieur), a = 30 b = 45 après l'échange (à l'intérieur), a = 45 b = 30 ** maintenant, avant et après les valeurs d'échange seront les mêmes ici **: après l'échange, a = 30 et b est 45
Surcharge de méthode
Lorsqu'une méthode a deux méthodes ou plus, leurs noms sont les mêmes mais les paramètres sont différents, il est appelé surcharge de méthode. C'est différent de la couverture. Le remplacement fait référence au nombre de méthodes avec le même nom, type et paramètres.
Prenons l'exemple précédent de trouver le numéro entier minimum. Si nous demandons de trouver le plus petit nombre dans un type de point flottant, nous devons utiliser la surcharge de la méthode pour créer deux ou plusieurs méthodes avec le même nom de fonction mais différents paramètres.
Les exemples suivants sont expliqués:
classe publique ExempleOverloading {public static void main (String [] args) {int a = 11; int b = 6; Double C = 7,3; Double D = 9,4; Int result1 = minFunction (a, b); // Nom de la même fonction avec différents paramètres Double Result2 = minFonction (C, D); System.out.println ("Minimum Value =" + Result1); System.out.println ("Minimum Value =" + Result2); } // pour entier public static int Minfunction (int n1, int n2) {int min; if (n1> n2) min = n2; else min = n1; retourne min; } // pour le double public statique Double Minfunction (double n1, double n2) {double min; if (n1> n2) min = n2; else min = n1; retourne min; }}Cela produira les résultats suivants:
Valeur minimale = 6 valeur minimale = 7,3
Les méthodes de surcharge rendent le programme facile à lire. Ici, les deux méthodes ont le même nom mais des paramètres différents. Génère le nombre minimum de types entiers et de points flottants à la suite de l'exécution du programme.
Utiliser les paramètres de ligne de commande
Parfois, vous voulez transmettre des paramètres avant l'exécution du programme. Cela peut être réalisé en passant par les paramètres de ligne de commande à la fonction principale.
Sur la ligne de commande, lorsque vous souhaitez exécuter un fichier de programme, un paramètre de ligne de commande apparaît immédiatement après le nom du fichier. Il est très facile d'accepter les paramètres de ligne de commande dans les programmes Java. Ils sont transmis dans le tableau principal de caractères de fonction.
Exemple
L'exemple suivant montre un programme qui publie tous les paramètres de ligne de commande:
classe publique Commandline {public static void main (String args []) {for (int i = 0; i <args.length; i ++) {System.out.println ("args [" + i + "]:" + args [i]); }}}Exécuter le programme par:
ligne de commande Java Ceci est une ligne de commande 200 -100
Cela produira les résultats suivants:
args [0]: thisargs [1]: isargs [2]: aargs [3]: commandargs [4]: lineargs [5]: 200args [6]: -100
Constructeur
Voici un exemple simple d'utilisation des constructeurs:
// un constructeur simple.class myClass {int x; // suivant est le constructeur myClass () {x = 10; }}Vous pouvez instancier un objet en appelant le constructeur:
classe publique Consdemo {public static void main (String args []) {myClass t1 = new myClass (); MyClass t2 = new myClass (); System.out.println (t1.x + "" + t2.x); }}En règle générale, vous devrez utiliser un constructeur pour accepter un ou plusieurs paramètres. Le paramètre passant est le même que le paramètre passant de la méthode ordinaire introduite ci-dessus, qui est de répertorier la liste des paramètres après le nom du constructeur.
Exemple
Voici un exemple simple d'utilisation des constructeurs:
// un constructeur simple.class myClass {int x; // suivant est le constructeur myClass (int i) {x = i; }}Vous pouvez instancier un objet en appelant le constructeur:
classe publique Consdemo {public static void main (String args []) {myClass t1 = new myClass (10); MyClass t2 = new myClass (20); System.out.println (t1.x + "" + t2.x); }}Cela produira les résultats suivants:
10 20
Paramètres de longueur variable
JDK1.5 peut vous permettre de transmettre des paramètres de longueur variable du même type. Déclarez-le en utilisant la méthode suivante:
typename ... parametername
Lorsque vous déclarez une méthode, vous devez spécifier le type de paramètre avant l'ellipsis, et il ne peut y avoir qu'un seul paramètre de longueur variable, et le paramètre de longueur variable doit être le dernier de tous les paramètres.
Exemple
classe publique Varargsdemo {public static void main (String args []) {// Call Méthode avec variable args printmax (34, 3, 3, 2, 56.5); printmax (nouveau double [] {1, 2, 3}); } public static void printmax (double ... nombres) {if (nombres.length == 0) {System.out.println ("Aucun argument passé"); retour; } double résultat = nombres [0]; for (int i = 1; i <nombres.length; i ++) if (nombres [i]> result) result = nombres [i]; System.out.println ("La valeur maximale est" + résultat); }}Cela produira les résultats suivants:
La valeur maximale est de 56,5 La valeur maximale est de 3,0
Méthode finaliser ()
Vous pouvez définir une méthode qui ne sera appelée qu'avant d'être détruite par le collecteur des ordures. Cette méthode est appelée méthode finaliser (), qui peut également être utilisée pour garantir qu'un objet est nettoyé.
Par exemple, vous pouvez utiliser Finalize () pour vous assurer que le fichier ouvert par un objet a été fermé.
Pour ajouter un finalizer à la classe, il vous suffit de définir la méthode finaliser (). Lorsque Java veut recycler un objet de cette classe, la méthode sera appelée.
Dans la méthode finaliser (), vous spécifierez un comportement qui doit être effectué avant que l'objet ne soit détruit.
La méthode finaliser () est généralement similaire à ce qui suit:
protégé void finalize () {// Code de finalisation ici}Ici, le mot-clé protégé est de s'assurer que le code en dehors de la classe ne peut pas accéder à la méthode finaliser ().
Cela signifie que vous ne pouvez pas savoir quand finaliser () est exécuté. Par exemple, si votre programme se termine avant que le collecteur des ordures ne se produise, la méthode finaliser () ne sera pas exécutée.
Méthodes génériques:
Les méthodes génériques Java sont largement utilisées lorsque la méthode renvoie une valeur qui est un objet de classe de conteneur.
Liste statique publique <T> Find (class <T> Clazz, String Userid) {....}De manière générale, lors de l'écriture d'une méthode générique Java, le type de valeur de retour et au moins un type de paramètre doivent être génériques, et le type devrait être le même. Si un seul du type de valeur de retour ou du type de paramètre utilise un générique, l'utilisation de cette méthode générique sera grandement restreinte, essentiellement au même niveau que si vous n'utilisez pas de génériques.
Ce qui suit introduit principalement l'utilisation de deux méthodes génériques Java très similaires et les différences entre elles.
Le premier type:
Le public statique <T étend CommonService> t getService (classe <T> Clazz) {t Service = (t) ServiceMap.get (Clazz.getName ()); if (service == null) {service = (t) ServiceLocator.getService (Clazz.getName ()); ServiceMap.put (Clazz.getName (), service); } service de retour; } Le deuxième type:
public static <t> t getService (classe <? étend CommonService> Clazz) {t Service = (t) ServiceMap.get (Clazz.getName ()); if (service == null) {service = (t) ServiceLocator.getService (Clazz.getName ()); ServiceMap.put (Clazz.getName (), service); } service de retour; } Voici la classe où réside la méthode générique:
CLASSE DE RÉSUMÉ PUBLIC COMMONSERVICE {private static hashmap <String, commonsService> ServiceMap = new HashMap <String, CommonService> (); // Voici la définition de la méthode générique. . } Ces deux méthodes génériques n'ont que des signatures de méthodes différentes et les corps de méthode sont exactement les mêmes. Alors, quelle est la différence?
Utilisons-les et vous saurez la différence.
Utilisez la première méthode générique:
classe publique main {public static void main (String [] args) {noviceservice noticeservice = commonservice.getService (noviceservice.class); // utilise correctement la première méthode générique sans compilation d'erreurs. NOVICESERVICE NOTICEVICE = commonservice.getService (userService.class); // Si vous utilisez la première méthode générique incorrectement, une erreur de compilation se produira. }} Utilisez la deuxième méthode générique:
classe publique Main {public static void main (String [] args) {noviceService noviceService = commonservice.getService (noviceservice.class); // utiliser correctement la deuxième méthode générique, il n'y aura pas d'erreurs de compilation, la logique est correcte, et il n'y aura pas d'exceptions pendant le temps d'exécution. NoviceService noviceService = commonService.getService (userService.class); // Si vous utilisez la deuxième méthode générique incorrectement, il n'y aura pas d'erreurs de compilation, mais la logique est incorrecte et une exception se produira pendant l'exécution, ce qui est dangereux! }}Maintenant, je connais la différence entre ces deux méthodes génériques extrêmement similaires?