## Méthodes avec paramètres

N'êtes vous pas fatigué d'écrire encore et encore le code qui permet d'avancer ou de reculer d'un nombre prédéterminé de pas ? Oui, mais écrire les méthode `avance2()`, `avance3()`, `avance4()`, et `recule2()`, `recule3()`, `recule4()`, et ainsi de suite, ça ne constitue pas un réel gain de temps. Et puis, c'est carrément moche !

Heureusement, il est possible de donner des paramètres à vos méthodes. Il faut marquer leur type et leur nom entre les parenthèses qui suivent le nom de la méthode. Ensuite, on peut les utiliser dans le corps de la fonction comme s'il s'agissait de variables définies ici.

    [!java|c]double [/!]diviseParDeux([!java|c]double [/!]x[!scala]: Double[/!])[!scala]: Double =[/!] [!java|scala|c]{[/!][!python]:[/!]
         return x / 2[!java|c];[/!]
    [!scala|java|c]}[/!]

À l'usage, il faut indiquer les valeurs qu'elles doivent prendre entre les parenthèses de l'appel.

    [!java|c]double [/!][!scala]val [/!]resultat = diviseParDeux(3.14)[!java|c];[/!]

Si on veut avoir plusieurs paramètres, il faut les séparer par des virgules, lors de la déclaration comme lors de l'appel.

    [!java|c]double divise(double x, double y) {[/!]
    [!scala]def divise(x:Double, y:Double): Double = {[/!]
    [!python]def divise(x, y):[/!]
         return x / y[!java|c];[/!]
    [!java|scala|c]}[/!]

    [!java|c]double res = divise(3.14 , 1.5);[/!]
    [!scala]val res = divise(3.14 , 1.5)[/!]
    [!python]res = divise(3.14 , 1.5)[/!]

[!java|scala]

En [!thelang], il est possible d'avoir plusieurs méthodes du même nom, à condition qu'elles n'aient pas la même signature, c'est à dire le même nombre de paramètres et les mêmes types de paramètres.

    [!java]double max(double x, double y)[/!][!scala]def max(x:Double, y:Double): Double =[/!] {
      if (x > y) {
        return x;
      }
      return y;
    }[!java]int max(int x, int y)[/!][!scala]def max(x:Int, y:Int): Int =[/!] {
      if (x > y) {
        return x;
      }
      return y;
    }
    [!java]int max(int x, int y; int z)[/!][!scala]def max(x:Int, y:Int, z:Int): Int =[/!] {
      if (x > y && x > z) {
        return x;
      }
      if (y > z) {
        return y;
      }
      return z;
    }

Remarquez que nous avons ici laissé de coté les `else` de chaque alternative. Cela fonctionne tout de même car un `return` interrompt l'exécution de la méthode. Si on arrive à la dernière ligne de `[!java]max(int,int)[/!][!scala]max(Int,Int):Int[/!]`, on est donc sûr que `x<=y` car dans le cas contraire, le `return` de la deuxième ligne aurait arrêté l'exécution de la fonction.

[/!]

### Objectif de cet exercice

Cette fois, vous devez écrire une méthode `[!java|c]move(int nbPas,[!java]boolean[/!][!c]int[/!] versLAvant)[/!] [!scala]move(nbPas: Int,versLAvant: Boolean)[/!] [!python]move(nbPas,versLAvant)[/!]` qui se déplace de `nbPas` pas. Si `versLAvant` est vrai, il faut avancer de ce nombre de pas; dans le cas contraire, il faut reculer.

Cette fois, il y a un seul monde, et sept buggles, qui exécutent toutes le code que vous allez écrire. Cet exercice ne devrait pas vous poser de problème particulier.