Série 5:
Modularisation

Buts

Dans cette série, vous apprendrez à améliorer la lisibilité de vos programmes en modularisant les traitements grâce à des méthodes auxiliaires de main. Cette série est très longue, le but étant de vous fournir beaucoup de matériel d'entraînement (progresser en programmation ne se faisant que par beaucoup de pratique !). Les exercices 11 à 12 sont du matériel supplémentaire que vous pouvez laisser de côté dans un premier temps et y revenir plus tard dans le semestre en guise de révision.

Exercice 1: Reprise du calcul des moyennes (Modularisation, Niveau 0)

Le but ici est de résoudre un petit exercice illustrant l'utilisation des méthodes auxiliaires.

Commencez comme d'habitude par ouvrir un nouveau fichier, par exemple ici Moyenne.java dans votre éditeur favori (par exemple XEmacs), puis préparez la "coquille vide" de base de votre programme : 

class Moyenne {

    public static void main(String[] args) {
    }
}

-->

Écrivez maintenant dans la méthode main, les instructions nécessaires pour demander deux notes à l'utilisateur et afficher leur moyenne.

Essayez de le faire par vous même sans regarder la solution ci-dessous

Solution :

La façon que nous avions jusqu'ici de réaliser un tel programme ressemble à peu près à ceci : 

private static Scanner scanner = new Scanner(System.in);

public static void main(String[] args) {
    double note1, note2;
    System.out.println("Entrez vos deux notes :");
    note1 = scanner.nextDouble();
    note2 = scanner.nextDouble();
        double moyenne = note1 + note2;
        moyenne /= 2;
    System.out.println("Votre moyenne est : " + moyenne);
}

Vous avez peut-être utilisé des int au lieu des double ici. C'est très bien : cela va aussi.
Cela signifie juste que pour vous une note est un nombre entier, alors que pour moi elle peut être fractionnaire

Continuons l'exercice pour maintenant introduire des méthodes auxiliaires.

Imaginons que ce programme rudimentaire soit amené à grandir et que le calcul de la moyenne soit nécessaire à plusieurs endroits différents du programme.

Il peut alors être judicieux de sortir le calcul de la moyenne du corps de la méthode main, de manière à ce qu'il puisse être réutilisé par d'autres parties du programme.

Nous voulons donc définir une méthode auxiliaire qui prenne deux doubles comme paramètres, et retourne le résultat sous forme de double.

Quel est alors l'entête de cette méthode  ?
(sans regarder ;-))

Solution

L'entête de cette méthode est le suivant :

    static double moyenne(double nombre1, double nombre2) {
    }

Le corps de la fonction calcule la moyenne des paramètres, et retourne le résultat du calcul. Bien que les deux solutions ci-dessous soit équivalentes, nous préférerons la deuxième qui est plus courte et élégante : 

    // solution 1
    static double moyenne(double nombre1, double nombre2) {
        // declaration et initialisation d'une variable
        double moyenne = nombre1 + nombre2;
        moyenne /=2;

        // la méthode renvoie la valeur de la variable moyenne
        return moyenne;
    }
 

    // solution 2
    static double moyenne(double nombre1, double nombre2) {
        // la fonction renvoie directement la valeur
        // il n'est pas nécessaire d'utiliser une variable intermédiaire
        return (nombre1 + nombre2) / 2;
    }

Il nous reste plus maintenant qu'à assembler les morceaux, c'est-à-dire faire appel à la fonction dans la méthode principale main.

Cela se fait simplement en mettant le nom de la fonction à appeler avec les paramètres voulus à l'endroit où l'on veut utiliser la valeur qu'elle retourne. Par exemple ici : 

        System.out.println("Votre moyenne est : " + moyenne(note1, note2));

Notez que la définition de notre méthode auxilaire peut se trouver n'importe où (avant ou après la méthode ou les méthodes l'utilisant).

On arrive donc au résultat : 

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
 
import java.util.Scanner;

class Moyenne {

    private static Scanner scanner = new Scanner(System.in);

    public static void main(String[] args) {
        double note1, note2;
        System.out.println("Entrez vos deux notes :");
        note1 = scanner.nextDouble();
        note2 = scanner.nextDouble();

        // appel
        System.out.println("Votre moyenne est : " + moyenne(note1, note2));
    }

    // définition
    static double moyenne(double nombre1, double nombre2) {
        return (nombre1 + nombre2) / 2;
    }
}


Exercice 2: Quiz du MOOC (MOOC, Niveau 1)

Pour préparer le cours du mercredi 9.10.2024, vous pouvez, après avoir visionné les vidéos en lignes de la semaine 6 du MOOC, répondre au quiz de la même semaine : quiz de la semaine 6.

Exercice 3: Rectangle (Modularisation, Niveau 1)

Ecrivez un programme Rectangle.java, permettant de lire la largeur et la hauteur d'un rectangle. Ce programme devra afficher, à la demande, le périmètre ou la surface du rectangle. Exemples d'exécutions: 
Entrez la largeur: ...
Entrez la hauteur: ...
Surface ('s/S') ou perimètre ('p/P')?: ...
La surface est ...
ou encore: 
Entrez la largeur: ...
Entrez la hauteur: ...
Erreur: vous avez introduit une largeur ou une hauteur négative!
Le programme devra être bien modularisé de sorte à ce que la méthode main se présente comme suit: 

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
 
    public static void main(String[] args) {
        double largeur = lireDonnee("largeur");
        double hauteur = lireDonnee("hauteur");

        boolean donneesOk = testerDonnees(largeur, hauteur);

        if (donneesOk) {
            calculer(largeur, hauteur);
        } else {
            afficherErreur();
        }
    }

Le test sur le type de calcul se fera au moyen d'un switch.

Exercice 4: Portée d'une variable (Modularisation, portée, Niveau 1)

Le programme Portee.java ci-dessous sert à illustrer un point important qui concerne la portée des variables dans un programme. Sans exécuter le programme, indiquez tout ce que le programme affichera à l'écran lors de l'exécution. Exécutez ensuite le programme (en cliquant ci-dessous sur "Exécutez le programme") pour vérifier votre réponse. 

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
 
class Portee {

    public static void main(String[] args) {
        int x = 11;
        int y = 22;
        System.out.println("1. x = " + x);
        System.out.println("2. y = " + y);
        System.out.println();

        calculer1(x, y);
        System.out.println("5. x = " + x);
        System.out.println("6. y = " + y);

        System.out.println();
        calculer2(x, y);
        System.out.println("11. x = " + x);
        System.out.println("12. y = " + y);

        System.out.println();
        int[] object = {5};
        System.out.println("13. object [0] = " + object[0]);
        calculer3(object);
        System.out.println("15. object [0] = " + object[0]);
    }

    static void calculer1(int x, int y) {
        x = 878;
        y++;
        System.out.println("3. x = " + x);
        System.out.println("4. y = " + y);
    }

    static void calculer2(int a, int b) {
        int x = 33;
        int y = 44;
        a = 2 * x;
        b = 2 * y;
        System.out.println("7. x = " + x);
        System.out.println("8. y = " + y);
        System.out.println("9. a = " + a);
        System.out.println("10. b = " + b);
    }

    static void calculer3(int[] object) {
        object[0] = 37;
        System.out.println("14. object[0] = " + object[0]);
    }
}


Exercice 5: Erreurs fréquentes dans les méthodes (Modularisation, Niveau 1)

Chacune des méthodes methode1 à methode8 dans le programme ErreursMethodes.java ci-dessous contient une seule erreur syntaxique. Il s'agit d'erreurs liées à l'utilisation des paramètres, des variables ou de la valeur retournée par la méthode. Il n'y pas d'erreurs dans la méthode main, ni dans la méthode methodeSansErreur. Trouvez et corrigez les erreurs !

Si vous sollicitez l'aide du compilateur pour trouver les erreurs, sachez qu'il aura de la peine avec ce type de programme où il y a beaucoup d'erreurs de structure. Il peut vous montrer la ligne approximative où se trouve une erreur, mais la solution proposée n'est pas toujours correcte, la liste des erreurs n'est pas toujours complète et les erreurs ne sont pas présentées dans le bon ordre. Dans ce genre de situation, utilisez surtout votre bon sens et vos propres connaissances de la syntaxe de Java. 

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
 
class ErreursMethodes {

    public static void main(String[] args) {
        int i1 = methode1();
        int i2 = methode2();
        int i3 = methode3();
        int i4 = methode4();
        methode5();
        methode6();
        methode7();
        methode8();
    }

    static int methode1 {
        int a = 0;
        System.out.println("Méthode 1");
        return a;
    }

    static int methode2() {
        int a = 0;
        i1 = 10;
        System.out.println("Méthode 2");
        return a;
    }

    static int methode3() {
        int a = 0;
        System.out.println("Méthode 3");
    }

    static int methode4() {
        String a = "0";
        System.out.println("Méthode 4");
        return a;
    }

    static void methode5() {
        double a = 0;
        System.out.println("Méthode 5");
        return a;
    }

    static methode6() {
        double a = 0;
        System.out.println("Méthode 6");
        return a;
    }

    static void methode7() {
        int a = 0;
        double b = 5.5;
        methodeSansErreur(a);
        System.out.println("Méthode 7");
    }

    static void methode8() {
        int a = 0;
        String b = "5.5";
        methodeSansErreur(a, b);
        System.out.println("Méthode 8");
    }

    static void methodeSansErreur(int a, double b) {
        // Cette méthode ne fait rien du tout
    }
}


Exercice 6: Passage par valeur (Passage de parametres, Niveau 1)

Soit le programme suivant : 

class ConcatIncorrecte {
    public static void main(String[] args) {
        String s = "China Blue";
        System.out.println(s);
        concatener(s, " Express");
        System.out.println(s);
    }

    public static void concatener(String s, String s2) {
        s +=s2;
    }
}

  1. Expliquez pourquoi la méthode concatener ne parvient pas à modifier la chaîne s du main (en y concaténant " Express")
  2. Corriger le codage de la méthode concatener et son utilisation dans le main de sorte à ce que l'exécution du programme affiche : 
    China Blue
China Blue Express
    au lieu de : 
    China Blue
China Blue

Exercice 7: Opération sur les tableaux (tableaux, Modularisation, Niveau 1)

Le programme Operations.java vous permettra d'exercer vos connaissances des tableaux de type int[] et des méthodes auxiliaires. Etudiez le fonctionnement du programme et complétez-le comme demandé ci-après.