• Une méthode d'instance est accessible uniquement lorsqu'une instance est créée.
  
  
• Une méthode statique est accessible même si aucune instance de la classe n'a été créée.
  
  
• Une méthode statique est déclarée en utilisant le mot clé static.
  

class ClassA { public void instanceMethod() { } public static void staticMethod() { } public void doSomeThing() { // Accès aux méthodes d'instance (new ClassA()).instanceMethod(); // OK (new ClassA()).staticMethod(); // OK - Avertissement : The static method staticMethod() from the type ClassA should be accessed in a static way // Accès aux méthodes statiques ClassA.staticMethod(); // OK ClassA.instanceMethod(); // compiler error: Cannot make a static reference to the non-static method instanceMethod() from the type ClassA } }

• Le code d'une méthode d'instance peut accéder à tous les attributs (d'instance ou statiques) et invoquer toutes les méthodes (d'instance ou statiques).
  
  
• Le code d'une méthode statique peut accéder uniquement aux attributs statiques et invoquer uniquement les méthodes statiques.
  

class ClassA { int var1 = 1; static int var2 = 1; public Integer instanceMethod() { return var1 * var2; // OK } public static Integer staticMethod() { Integer localVar1 = var2; // OK Integer localVar2 = instanceMethod(); // compiler error: Cannot make a static reference to the non-static method instanceMethod() from the type ClassA return var1; // compiler error: Cannot make a static reference to the non-static field var1 } }

• Le type de retour peut être un type primitif ou référence (incluant les classes, interfaces, et tableaux).
  La valeur (ou la variable) retournée doit être de même type que celui déclaré pour la méthode.
  int doReturnPrimitiveType() { int var1 = 0; return var1; }
  Object doReturnReferenceType() { Object obj = new Object(); return obj; }
  
• Il est possible de retourner une valeur (ou une variable) qui peut être convertie implicitement au type de retour spécifié dans la déclaration de la méthode.
  int doImplicitCastPrimitiveType() { return 'c'; }
  Object doImplicitCastReferenceType() { return Integer.valueOf(10); }
  
• Il est possible de retourner une valeur (ou une variable) qui peut être convertie explicitement au type de retour spécifié dans la déclaration de la méthode.
  int doExplicitCastPrimitiveType() { double var1 = 12.5; return (int) var1; }
  Integer doExplicitCastReferenceType() { Integer temp = Integer.valueOf(10); Object obj = temp; return (Integer) obj; }
  
• Il est possible de retourner null, mais uniquement si la déclaration de la méthode spécifie un type de retour référence.
  Object doReturnNullValue() { return null; }
  
• Le type void indique que la méthode ne retourne aucune valeur.
  void doReturnVoid() { }
  Vous pouvez aussi utiliser le mot clé return pour expliciter que la méthode ne retourne pas de valeur :
  void doReturnVoid() { return; }

Une méthode peut déclarer plusieurs paramètres chacun a son propre type.
Le type du paramètre peut être un type primitif ou référence (incluant les classes, interfaces, et tableaux).

Notes :

• Paramètres : Noms des identificateurs faisant partie de la déclaration de la méthode (signature de la méthode) et qui servent lors de l'invocation de la méthode à correspondre les valeurs envoyées avec ces identificateurs.
  
  
• Arguments : les valeurs (ou variables) utilisées (placées entre les parenthèses et séparées par des virgules) lors de l'invocation des méthodes.
  

public class MyClass { void foo(int param1, Integer param2, Object param3) { } void bar() { int arg1 = 0; Integer arg2 = 1; Object arg3 = this; foo(arg1, arg2, arg3); } }
Ci-dessous est la liste des règles qui s'appliquent sur ces arguments pour que le code soit accepté par le compilateur:

• Le nombre des arguments utilisé lors de l'appel de la méthode doit correspondre à celui des paramètres.
  void bar() { int arg1 = 0; Integer arg2 = 1; foo(arg1, arg2); // Compiler error : The method foo(int, Integer, Object) in the type MyClass is not applicable for the arguments (int, Integer) }
  
• Le type de chaque argument doit être de même type que celui du paramètre correspondant.
  void bar() { String arg1 = "0"; Integer arg2 = 1; Object arg3 = this; foo(arg1, arg2, arg3); // Compiler error : The method foo(int, Integer, Object) in the type MyClass is not applicable for the arguments (String, Integer, Object) }
  
• Le type de l'argument peut être différent de celui du paramètre à condition qu'il soit possible de le convertir implicitement au type du paramètre correspondant.
  void bar() { Integer arg1 = 0; // OK : Integer --> int int arg2 = 1; // OK : int --> Integer String arg3 = "my String"; // OK : String est une sous classe de Object foo(arg1, arg2, arg3); }

Dans certains cas, on a besoin qu'une méthode accepte un nombre variable d'arguments.
Par exemple, une méthode qui fait la somme de toutes les valeurs passées en argument.
Pour le faire, il suffit de suivre le type du paramètre par trois points (...)

public class MyClass { static int doSumArgs(int... varParams) { // la méthode accepte un nombre variable d'arguments de type int int total = 0; for (int param : varParams) { // boucler sur l'ensemble des arguments total += param; } return total; } public static void main(String[] args) { System.out.println(doSumArgs(1, 2)); // Invocation de la méthode avec deux arguments. System.out.println(doSumArgs(1, 2, 3)); // Invocation de la méthode avec trois arguments. } }
Il est possible de mélanger les paramètres ordinaires avec les Varargs.
Cependant, il faut que la déclaration des Varargs vienne en dernier.
Il est aussi interdit d'avoir plus d'un Vararg pour une méthode.
void foo(String param1, Integer param2, int... varParams) { // OK } void bar(String param1, int... varParams, Integer param2) { // Compiler error : The variable argument type int of the method bar must be the last parameter } void multiVarArgs(int... varParams1, int... varParams2) { // Compiler error : The variable argument type int of the method multiVarArgs must be the last parameter }
Note :
Il faut savoir que la syntaxe pour la déclaration des Varargs (ainsi que celle pour invoquer les méthodes avec multiple arguments) ne font pas partie du langage Java lui-même : il s'agit simplement du "sucre syntaxique" ; ce qui veut dire que le compilateur va transformer le code par un autre lors de la génération du bytecode de la classe.

Par exemple, le code suivant :
public class MyClass { void foo(int... varParams) { } void bar() { foo(1, 2, 3); } }
Va être transformé par le compilateur par :
public class MyClass { void foo(int[] varParams) { } void bar() { foo(new int[] { 1, 2, 3 }); } }
Vous remarquez que la déclaration du Vararg int... varParams a été remplacée par la déclaration d'un tableau int[] varParams.
Et la liste des arguments 1, 2, 3 a été remplacée par un tableau anonyme new int[] { 1, 2, 3 }.

En fait, la chose la plus importante à retenir lors de l'utilisation des Varargs est qu'il s'agit des variables de type Tableau.

TODO ...