Activité : Réaliser des fonctions (2)

Consigne

Prendre connaissance de l’activité et effectuer les tâches demandées.

L’objectif est d’apprendre la syntaxe de la définition d’une fonction et d’exercer l’utilisation des instructions de base de Java (affectation et structures de contrôle), ne faites donc pas de copier-coller, mais tapez votre code.

Le code des tests unitaires doit être utilisé tel quel et ne doit pas être modifié. Le travail est individuel. Vous pouvez communiquer, mais en respectant le code d’honneur.

Situation

Vous êtes chargé de réaliser une application de conversion de température.

Résultat attendu

  • Un projet Maven avec une classe principale App et une classe nommée UnitConverter qui contient les fonctions décrites dans les tâches.

Objectifs

À la fin de ce travail, vous devez :

  1. Connaître par cœur la syntaxe de la définition d’une fonction
  2. Connaître le terme signature d’une fonction pour désigner son type et les types de ses paramètres.
  3. Être capable de réaliser une fonction et de l’utiliser.

Ressources

Logiciel :

  • Maven
  • Visual Studio Code

Documents :

Fragments de code (snippets):

Ces fragments de code vous sont fournis pour vous aider à réaliser vos programmes. Prenez la peine de taper le code plutôt que de faire du copier-coller, de façon à vous familiariser avec la syntaxe et ainsi, l’apprendre.

Le fragment ci-dessous est le squelette de la définition d’une classe. Une classe doit se trouver dans un fichier .java dont le nom est strictement identique à celui de la classe et ce fichier doit se trouver dans une structure de répertoire correspondant exactement au package.

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
// Espace de noms (package) de la classe
package ch.epai.ict.m404.projet; // Remplacer projet par le nom
                                 // de votre projet


// Définition de la classe MaClasse.
public class MaClass { // Remplacer MaClasse par le nom de votre
                       // classe en UpperCamelCase.

    // Si nécessaire, insérer ici les constantes. Par exemple:
    public static final int MA_CONSTANTE = 1; // Remplacer MA_CONSTANTE par  
                                               // le nom de votre constante  
                                               // en UPPER_SNAKE_CASE, int 
                                               // par le type adéquat et
                                               // 1 par la valeur souhaitée.

    // Une procédure est une séquence d’instruction qui ne 
    // renvoie pas de valeur et qui doit avoir un effet.
    // 
    // Le nom d'une procédure s'écrit en lowerCamelCase
    //
    // Adapter le nom, le type et le nombre des paramètres.
    public static void procedureName(int param1, int param2) {

        // Insérer ici les déclarations des variables
        // locales et les instructions de la procédure.
        //
        // Les noms des variables locales s'écrivent
        // en lowerCamelCase.
    }


    // Une fonction est une séquence d’instruction qui renvoie 
    // une valeur et qui ne doit pas avoir d’effet de bord.
    // 
    // Le nom d'une fonction s'écrit en lowerCamelCase
    //
    // Adapter le nom, le type et le nombre des paramètres 
    // Adapter le type de la valeur renvoyée
    public static int functionName(int param1, int param2) {

        // Insérer ici les déclarations des variables
        // locales et les instructions de la fonction.
        //
        // Les noms des variables locales s'écrivent
        // en lowerCamelCase.
        
        // renvoyer une valeur
        return 0; 
    }
}

Mise en route

Rendez-vous sur le GitLab de l’école et connectez-vous en utilisant votre nom d’utilisateur et votre mot de passe I-FR pour vous assurez que votre compte est bien initialisé (le compte est initialisé lors de la première connexion).

Ouvrez ensuite une fenêtre de terminal (CMD ou PowerShell), rendez-vous dans votre répertoire de travail et lancez la commande suivante :

1
git clone https://gitlab.epai-ict.ch/m404/unit-converter.git

Déplacez-vous dans le répertoire unit-converter (avec la commande cd) et lancer la commande code . pour ouvrir ce répertoire dans VSC (Visual Studio Code).

Le projet contient déjà les tests unitaires des fonctions que vous devez réaliser. Si vous ouvrez le fichier de la classe UnitConverterTest, vous pouvez constater que le fichier contient des erreurs de syntaxe soulignées en rouge. En plaçant le curseur de la souris sur l’une d’entre elles, vous apprenez qu’il s’agit de méthodes qui ne sont pas définies (The method <nom de méthode> is undefined for the type <Nom de classe>). Dans la terminologie de la programmation orientée objet, le terme « méthode » désigne simplement une procédure ou une fonction qui se trouve dans une classe. Ces méthodes non définies sont les fonctions que vous devez réaliser.

Les tests unitaires ont une double utilité. Ils permettent bien sûr de vérifier que votre code correspond à la spécification, mais ils sont également un moyen de décrire cette spécification. Le code des tests unitaires décrit la manière dont les méthodes doivent se comporter.

Pour la réalisation, nous vous suggérons de procéder de la manière suivante :

  1. Éliminez les erreurs de syntaxe en définissant les méthodes sans les implémenter. Observez les appels des méthodes dans les tests unitaires pour déterminer leur signature (type de la valeur de retour et types des paramètres).
  2. Implémentez les fonctions les une après les autres et assurez-vous que tous les tests d’une fonction passent avant de passer à la suivante.

Pour le cas présent, commencez par définir une méthode celsiusToFahrenheit qui prend un nombre à virgule en paramètre et qui renvoie un nombre à virgule. Comme il s’agit d’une fonction, un bloc vide ne suffit pas. En effet, une fonction doit obligatoirement renvoyer une valeur ou alors jeter une exception. D’une manière générale, pour indiquer qu’une méthode n’est pas encore implémentée, une bonne pratique consiste à jeter une exception avec l’instruction throw new UnsupportedOperationException();.

Faite de même pour la méthode fahrenheitToCelsius puis vérifiez qu’il n’y a plus d’erreurs de syntaxe et que tous les tests échouent. Puisque les fonctions ne sont pas implémentées, les tests doivent échouer.

1
2
3
4
5
6
7
8
Tests run: 4, Failures: 0, Errors: 4, Skipped: 0

[INFO] ------------------------------------------------------------------------
[INFO] BUILD FAILURE
[INFO] ------------------------------------------------------------------------
[INFO] Total time:  1.394 s
[INFO] Finished at: 2019-06-06T09:44:57+02:00
[INFO] ------------------------------------------------------------------------

Vous pouvez maintenant implémenter la première fonction (celsiusToFahrenheit). Pour cela, il vous suffit de savoir qu’une différence de température de 9°F correspond à une différence de température de 5°C (FAHRENHEIT_PER_CELSIUS = 9.0 / 5.0) et qu’une température de 32°F correspond à une température 0°C (FAHRENHEIT_FOR_0_CELSIUS = 32). La conversion consiste à multiplier la température en degré Celsius par le rapport FAHRENHEIT_PER_CELSIUS et à ajouter au résultat le décalage FAHRENHEIT_FOR_0_CELSIUS. Pour implémenter la seconde fonction (fahrenheitToCelsius), il suffit d’inverser les opérations (soustraire le décalage à la température en degrés Fahrenheit puis diviser le résultat par le rapport). Vous devez vous assurer que les quatre tests passent avant de poursuivre.

Lorsque le projet unit-converter fonctionne, vous pouvez passer à la réalisation du projet better-unit-converter. Pour cela, ouvrez une fenêtre de terminal (CMD ou PowerShell), rendez-vous dans votre répertoire de travail et lancez la commande suivante :

1
git clone https://gitlab.epai-ict.ch/m404/better-unit-converter.git

Déplacez-vous dans le répertoire better-unit-converter (avec la commande cd) et lancer la commande code . pour ouvrir ce répertoire dans VSC (Visual Studio Code) et poursuivez avec les tâches décrites ci-après. La classe UnitConverter contient déjà toutes les constantes dont vous avez besoin pour les conversions.

Tâches

  1. Réalisez le travail décrit dans la section « Mise en route »
  2. Définissez les méthodes manquantes pour éliminer les erreurs de syntaxe comme précédemment et assurez-vous que les tests échouent.
  3. Implémentez les méthodes en commençant par la méthode convertToKelvin (la structure de choix switch peut être utile).
  4. Dans la méthode main de la classe App, réalisez une interface utilisateur en ligne de commande (CLI) qui demande à l’utilisateur une valeur de température, l’unité de la valeur et l’unité vers laquelle il souhaite convertir cette valeur.