Avez-vous une question? (216) 97 656 803 hajjriadh@gmail.com
JSP

Les fonctions en JAVA

Cette leçon présente les fonctions en Java, appelées méthodes. Elle détaille l'anatomie d'une méthode : modificateurs, type de retour, nom, paramètres et corps, ainsi que la différence entre void et u...

0 chapitres 0 QCM Accès gratuit
Dans cet article

À propos de ce cours

Cette leçon présente les fonctions en Java, appelées méthodes. Elle détaille l'anatomie d'une méthode : modificateurs, type de retour, nom, paramètres et corps, ainsi que la différence entre void et une méthode qui renvoie une valeur. Un exemple complet calcule une moyenne et affiche une mention. La leçon explique aussi le passage des paramètres par valeur, la surcharge et la récursivité. Trois activités corrigées permettent de s'entraîner.
  1. Objectifs

  • Déclarer et appeler une méthode statique en Java.
  • Utiliser des paramètres et une valeur de retour ; distinguer void et les méthodes qui renvoient une valeur.
  • Comprendre le passage des paramètres par valeur.
  • Utiliser la surcharge et écrire une méthode récursive simple.
  1. Situation de départ

  1. Définition

En Java, une fonction s’appelle une méthode: c’est un bloc de code nommé, déclaré dans une classe, que l’on peut appeler autant de fois que nécessaire. Une méthode static s’appelle directement par son nom depuis la classe, sans créer d’objet.

//  modificateurs   type de retour   nom      paramètres
    public static   double           moyenne (double a, double b) {
        return (a + b) / 2;      // valeur renvoyée
    }

Anatomie d’une méthode Java : modificateurs, type de retour, nom, paramètres et corps

  1. Exemple complet

public class Notes {

    // Méthode qui renvoie une valeur
    public static double moyenne(double[] notes) {
        double somme = 0;
        for (double n : notes) {
            somme += n;
        }
        return somme / notes.length;
    }

    // Méthode sans valeur de retour (void)
    public static void afficherMention(double moy) {
        if (moy >= 16) System.out.println("Très bien");
        else if (moy >= 14) System.out.println("Bien");
        else if (moy >= 12) System.out.println("Assez bien");
        else if (moy >= 10) System.out.println("Passable");
        else System.out.println("Ajourné");
    }

    public static void main(String[] args) {
        double[] notesSara = {14.5, 12, 16};
        double m = moyenne(notesSara);           // appel : m vaut 14.166...
        System.out.printf("Moyenne : %.2f%n", m);  // Moyenne : 14,17 (ou 14.17 selon la langue du système)
        afficherMention(m);                       // Bien
    }
}
  1. Le passage des paramètres par valeur

Java transmet toujours une copie de la valeur. Modifier un paramètre de type primitif (int, double…) dans la méthode ne change pas la variable d’origine. Pour un tableau ou un objet, la copie porte sur la référence : la méthode peut donc modifier le contenu du tableau.

static void augmenter(int x)      { x = x + 1; }        // sans effet à l'extérieur
static void augmenter(int[] t)    { t[0] = t[0] + 1; }  // modifie le tableau

int n = 5;      augmenter(n);   // n vaut toujours 5
int[] tab = {5}; augmenter(tab); // tab[0] vaut 6
  1. La surcharge et la récursivité

  • Surcharge: plusieurs méthodes peuvent porter le même nom si leurs paramètres diffèrent (nombre ou types), comme les deux augmenter ci-dessus.
  • Récursivité: une méthode peut s’appeler elle-même ; il faut toujours un cas d’arrêt.
static long factorielle(int n) {
    if (n <= 1) return 1;            // cas d'arrêt
    return n * factorielle(n - 1);   // appel récursif
}
// factorielle(5) vaut 120
  1. Activités

Activité 1. Écrivez une méthode estMajeur(int age) qui renvoie true si l’âge est supérieur ou égal à 18.

Voir la correction
public static boolean estMajeur(int age) {
    return age >= 18;
}

Activité 2. Écrivez une méthode prixTTC qui reçoit un prix hors taxes et un taux de TVA (par exemple 0.19) et renvoie le prix TTC arrondi à deux décimales, puis surchargez-la pour utiliser 19 % par défaut.

Voir la correction
public static double prixTTC(double ht, double taux) {
    return Math.round(ht * (1 + taux) * 100) / 100.0;
}

public static double prixTTC(double ht) {
    return prixTTC(ht, 0.19);   // surcharge : taux par défaut
}
// prixTTC(100) vaut 119.0

Activité 3. Que vaut a après ce code ? int a = 3; doubler(a); avec static void doubler(int x) { x = x * 2; }. Comment obtenir 6 ?

Voir la correction

a vaut toujours 3 : la méthode a reçu une copie.

static int doubler(int x) { return x * 2; }
int a = 3;
a = doubler(a);   // a vaut 6
  1. À retenir

  1. Sources

  • Documentation Oracle : « The Java Tutorials : Defining Methods » et « Passing Information to a Method » (docs.oracle.com).
  • apcpedagogie.com : Les boucles en Java.

Leçon précédente : Les boucles en Java

Cet article vous a-t-il aidé ?