Capsule : Notions de programmation - Déclaration (en construction)

Introduction

Une déclaration est une construction d’un langage de programmation qui permet de définir un nouveau mot dans le langage. Elle consiste à associer ce nom, appelé « identificateur », à une entité du langage telle que, par exemple, un type, une constante, une variable ou un sous-programme.

Identificateur

D’une manière assez générale, on peut dire qu’un identificateur est une séquence de tiret bas, de chiffres et de lettres latines (sans accents) minuscules ou majuscules d’une longueur arbitraire. Même si de plus en plus de langages, dont Java, supportent la plupart des caractères Unicode dans les identificateurs, nous faisons ici le choix de nous en passer pour au moins deux raisons. La première est d’éviter des problèmes liés à l’encodage des fichiers sources. La seconde est la volonté de favoriser l’anglais qui, par rapport au français, tend à faciliter la construction d’identificateurs (adjectifs placés avant le nom, adjectivation, etc.) et dont l’usage est fréquemment requis dans l’industrie du logiciel.

Il peut être utile de modifier la manière d’écrire les identificateurs en fonction du type d’entité qu’il représente (constante, variable, sous-programme, type, etc.). Dans le cadre de ce cours, nous adopterons la convention définie dans le document Google Java Style Guide. Selon cette convention, un identificateur qui représente une classe s’écrit en upper camel case, c’est-à-dire qu’il commence par une lettre majuscule et, s’il est composé de plusieurs mots, chacun d’eux commence par une majuscule. Par exemple :

  • MaxOfThree
  • UnitConverter

Les identificateurs des variables, des sous-programmes (procédure ou fonction) et des paramètres formels, doivent quant à eux être écrit en lower camel case. Par exemple :

  • temperature
  • convertCelsiusToKelvin

Enfin, une constante doit être écrite en upper snake case, c’est-à-dire que l’identificateur est écrit entièrement en majuscule et que les mots sont séparés par des tirets bas (underscore) comme dans l’exemple suivant :

  • FAHRENHHEIT_PER_KELVIN_RATIO

Portée d’un identificateur

La portée d’un identificateur désigne la portion de code dans lequel cet identificateur est défini. En Java la portée est le bloc d’instructions dans lequel il a été déclaré. Dans une même portée, un identificateur ne peut en principe être déclaré qu’une seule fois.

Par exemple, l’identificateur d’une fonction définie dans une classe est la classe en entier. L’identificateur d’une variable déclarée dans le bloc d’instructions d’un sous-programme est le bloc d’instruction en entier. La portée d’un paramètre formel ou une variable de boucle déclarée dans une instruction for est le corps du sous-programme ou de la boucle.

Plus concrètement, dans le code ci-après, l’identificateur getMaxValue est défini dans la classe MaxOfN et peut donc appelé dans la procédure main. En revanche, le paramètre args ainsi que les variables locales numOfValues, vals et input sont déclarés dans la procédure main ; ils ne sont donc valides que dans le corps de cette procédure. De même, le paramètre values et la variable locale max ne sont valide que dans la procédure getMaxValue. Enfin, la variable i de chacune des boucles for n’est valide que dans le corps respectif de ces boucles.

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
public class MinOfN {

    public static void main(String[] args) {
        int numOfValues;
        int[] vals;
        
        Scanner input = new Scanner(System.in);
        
        System.out.print("Veuillez saisir le nombre de valeurs : ");
        numOfValues = input.nextInt();
        
        vals = new int[numOfValues];
        
        for (int i = 0; i < numOfValues; i += 1) {
            System.out.printf(
                "Veuillez saisir la valeur %d de %d : ", i + 1, numOfValues);
            vals[i] = input.nextInt();  
        }
        
        System.out.printf("La valeur maximal est : %d\n", getMaxValue(vals));
    }
    
    private static int getMaxValue(int[] values) {
        
        int max = values[0];
        
        for (int i = 1; i < values.length; i += 1) {
            if (values[i] > max) {
                max = values[i];
            }
        }
        
        return max;
    }
}
Fig. 1 Portée des identificateurs

La portée d’un identificateur ne coïncide pas nécessaire avec la portion du code dans laquelle on peut l’utiliser. Dans le cas des variables, celles-ci ne sont utilisables qu’à partir de leur déclaration.

Déclaration de la classe « principale »

Un programme en Java est représenté par une classe qui contient une méthode statique main. Cette méthode est le point d’entrée du programme. Il s’agit d’une procédure qui reçoit un tableau de chaînes qui contient les arguments de la ligne de commande. Le nom du programme est le nom de la classe.

La forme générale d’un programme est la suivante :

public class ProgramName { GlobalVariableDeclaration MainProcedureDeclaration ProcedureDeclaration FunctionDeclaration }

La déclaration procédure main, quant à elle, doit avoir la forme suivante :

public static void main(String[] args) InstructionBlock

Par exemple, la classe ci-dessous représente un programme nommé MinOfThree.

1
2
3
4
5
6
public class MinOfThree {

    public static void main(String[] args) {
        // Code du programme
    }
}
Fig. 2 Squelette du programme MinOfThree

Déclaration d’une variale « globale »

Une variable globale est une variable dont la portée est le programme en entier. Pour être rigoureux, la plus grande portée que peut avoir une variable en Java est la classe, mais comme à ce stade nous considérons que la classe « principale » est le programme, une variable de classe est une variable globale. En programmation structurée, on cherche à minimiser leur usage autant que possible.

private static Type VariableName = Expression ObjectCreation ArrayCreation ArrayInitialization

Déclaration d’un sous-programme

Un sous-programme est une séquence d’instructions associée à un nom et un certain nombre de paramètres. Les paramètres servent à passer des valeurs au sous-programme au moment de l’appel.

Déclaration d’une fonction

Une fonction est un sous-programme qui renvoie une valeur. La valeur renvoyée ne doit dépendre que des paramètres et il ne devrait pas y avoir d’effet de bord (la valeur renvoyée ne devrait pas changer si on appelle plusieurs fois la fonction avec les mêmes paramètre).

private static Type FunctionName ( FormalParameters ) InstructionBlock

Déclaration d’une procédure

Une procédure est un sous-programme qui ne revoie pas de valeur et qui doit avoir un effet. L’effet d’une procédure peut être, par exemple, le fait d’écrire dans un fichier, afficher un message à l’écran ou encore lire la mémoire tampon du clavier.

private static void ProcedureName ( FormalParameters ) InstructionBlock

Paramètres formels

Les paramètres déclarés dans la déclaration d’un sous-programme sont appelés paramètres formels. Du point de vue du sous-programme, un paramètre est semblable à une variable locale dont la valeur est définie au moment de l’appel.

Type ParameterName ,

Déclaration d’une variable locale

Une variable locale est une variable déclarée dans le corps d’une procédure ou d’une fonction.

Type VariableName = Expression ObjectCreation ArrayCreation ArrayInitialization ;