Les méthodes peuvent accepter des données provenant de l'extérieur par l'intermédiaire des paramètres, lesquels sont listés entre des parenthèses suivant l'identificateur de la méthode.

modif type méthode([liste_des_paramètres])
{ ... }

Les paramètres sont séparés par des virgules et énoncent pour chacun d'eux, un type et un identificateur.

type méthode(type id, ..., type idN)
{ ... }

Subséquemment, des arguments peuvent être passés si nécessaire à la méthode, lors de son appel dans un programme.

méthode(arg, ..., argN);

Le passage d'arguments devra respecter le sens de l'élargissement des types de données.

class Calculatrice {
  static short arg_a = 10;
  static short arg_b = 25;

  public static void main(String[] args){
    Calculatrice obj = new Calculatrice();
    // appel de la méthode avec passage d'arguments
    //respectant le sens de l'élargissement short -> int
    int res = obj.addition(arg_a, arg_b);
    System.out.println(res);
  }

  // définition de la méthode avec paramètres
  public int addition(int param_a, int param_b){
    return (param_a + param_b);
  }
}

Dans ce cas de figure, les méthodes peuvent recueillir des données de deux façons différentes :

  • Passage par valeur,
  • Passage par référence.

Toutes les données de type primitif (byte, short, char, int, long, float et double) sont passées à une méthode par valeur, c'est-à-dire qu'une copie de la donnée est mise à disposition de la méthode et non l'original.

class Arg {
  int a = 10;
  int b = 20;

  public static void main(String[] args){
    Arg obj = new Arg();
    int resultat = obj.uneMethode(a, b);
    // a vaut toujours 10
    // b vaut toujours 20
  }

  int uneMethode(int x, int y){
    // x vaut 10
    // y vaut 20
    return (++x - ++y);
    // x vaut 11
    // y vaut 21
  }
}

Par conséquent, une méthode ne peut modifier que la copie d'une donnée, sans pour autant affecter la valeur de l'original.

Pour le passage par référence, la méthode reçoit dans ce cas, une copie d'une référence vers un objet.
Mais, cette copie de la référence originale pointe précisément sur le même objet. De cette manière, toutes les opérations produites par la méthode réceptrice, affecte l'objet référencé également par l'argument transmis. Cela peut, donc, conduire à la modification potentielle d'une ou plusieurs valeurs d'attribut de l'objet en cours par la méthode réceptrice.

class Arg {
  String ch = new String("Un texte");
  String ch2 = new String("très bien présenté !");

  public static void main(String[] args){
    Arg obj = new Arg();
    System.out.println("Valeur de l'objet original (avant) : " + obj.ch);
    concatener(obj);
    // ch vaut "Un texte très bien présenté !"
    // ch2 vaut toujours "très bien présenté !"
    System.out.println("Valeur de l'objet original (après) : " + obj.ch);
  }

  static void concatener(Arg objet){
    objet.ch += " " + objet.ch2;
    // objet.ch vaut "Un texte très bien présenté !"
    // objet.ch2 vaut toujours "très bien présenté !"
    System.out.println("Copie d'objet : "+ objet.ch);
  }
}

Toutes les modifications apportées à l'objet passé en argument à une méthode sont permanentes et se répercutent donc dans le reste du programme et cela même si la méthode en question a cessé son activité.

En outre, des méthodes peuvent utiliser des variables définies dans une classe.

Les variables publiques, protégées, privées et par défaut peuvent être accédées de façon directe par n'importe quel méthode, à l'exception des méthodes statiques.

Les variables statiques peuvent être utilisées directement par toutes les méthodes et en particulier par les méthodes statiques.

Toutes les variables accédées de cette manière peuvent subir des modifications directes et permanentes depuis le bloc d'instructions des méthodes.