Java 03 : Variables

Tous les langages informatiques utilisent des variables. Cela permet d'enregistrer de manière temporaire (c'est-à-dire le temps de l'exécution du programme) des informations dans la mémoire de l'ordinateur.

Les noms des variables sont choisis par le développeur (en suivant certaines normes pouvant varier d'un langage à l'autre), qui peut y enregistrer des valeurs de différents types (nombres, texte, ...). Ainsi stockées dans des variables, les données sont faciles à retrouver et à manipuler. Il existe aussi des variables pré-définies, accessibles dès le départ sans que l'on ait besoin de les créer.

Pour te donner un exemple parlant, les variables sont un peu comme des boîtes, dans lesquelles tu peux mettre différentes choses, qui ont une étiquette dessus, avec un nom suffisamment parlant pour que tu saches ce que tu y as mis.

Objectifs

• Comprendre le fonctionnement des variables en Java, les règles de nommage, les différents types et leur manipulation.

Les règles associées au nom des variables

• Une variable ne doit pas commencer par un chiffre.

• Une variable peut commencer par toute lettre, $ ou _, mais par convention on évitera ces deux derniers.

• Une variable peut à la suite comporter lettres, chiffres et les caractères $ et _, mais là encore on évitera le $ qui est plutôt utilisé par certains générateurs de code.

• Une variable peut contenir des accents ou des lettres d'alphabets non-latins, mais ça pourrait poser des problèmes d'interfaçage avec d'autres systèmes.

Exemples de noms de variables valides :

str
myValue
ohCqfd
theBestValue

Attention, les noms des variables sont sensibles à la casse. blAcK et black sont deux variables différentes.

Exemples de nom de variables invalides :

4days            // commence par un chiffre
my-Bad           // contient un caractère interdit (-)
name@domain      // caractère interdit (@)
first name       // caractère interdit ( )
float            // mot clef

Les bonnes pratiques :

• Un nom de variable doit toujours t'aider à identifier ce qu'elle contient. Cela permet de simplifier et d'accélérer la lecture et la compréhension du code. N'oublie jamais que le code que tu écris sera relu et ré-utilisé par d'autres développeurs qui ne sont pas dans ta tête. Il faut toujours avoir à l'esprit la nécessité d'être clair, simple et concis.

• Toujours en anglais. Cela permettra à ton code d'être international et plus facilement accessible aux développeurs non francophones.

• N'hésite pas à utiliser plusieurs mots dans le nom de ta variable afinDeMieuxDecrireSonContenu.

• Il est recommandé, en Java, de nommer ses variables en camelCase. Ce n'est pas une obligation technique du langage, mais une convention, une bonne pratique utilisée notamment dans la plupart des gros projets écrits en Java. L'écriture camelCase consiste à écrire en minuscule et si le nom contient plusieurs mots, chaque mot (sauf le premier) commence par une majuscule. Cela forme donc des 'bosses' d'où le nom de camelCase.

Remarque Il existe d'autres conventions de nommage que le camelCase. Par exemple, les constantes qui sont des variables préfixées par static final sont en SNAKE_CASE par convention.

Exemples de variables bien nommées :

• une variable contenant le nom d'une voiture : carName (car_name ou CarName sont techniquement valides mais déconseillés)

• une variable contenant le résultat d'une addition : total ou result (value, number, resultat sont techniquement valides mais peu précis, ou pas en anglais, ce qui est également déconseillé)

Choisir un bon nom de variable est quelque chose d'extrêmement important, ne néglige surtout pas cela. Il vaut souvent mieux prendre quelques secondes pour trouver un nom de variable cohérent, plutôt que de se retrouver au final avec un code contenant var1, var2, toto, maVariable, duTexte... qui deviendront vite incompréhensibles.

Les types

Que met-on dans une variable ? Eh bien, des valeurs, des données, ce que l'on veut ! Le Java est un langage dit à typage fort. Cela signifie que l'on va toujours devoir définir le type d'une variable de manière explicite, et qu'il faudra parfois la convertir pour passer d'un format à l'autre (ex: un décimal vers une présentation textuelle avec 2 chiffres après la virgule). L'avantage est qu'un IDE peut procéder à une analyse dite "statique" du code et détecter d'éventuels problèmes avant même la compilation. D'autres langages sont beaucoup plus souples sur les types: php ou javascript par exemple.

Il existe deux grandes familles de type de données :

• primitives

• Objet

Les variables primitives (autrement dit scalaires) sont des variables ne contenant qu'une seule valeur à la fois. Elles sont composées des types suivants :

• byte : 8 bits signé (defaut: 0)

• short : 16 bits signé (defaut: 0)

• int : 32 bits signé (defaut: 0)

• long : 64 bits signé (defaut: 0L)

• float : 32-bit IEEE 754 (defaut: 0.0f)

• double : 64-bit IEEE 754 (defaut: 0.0d)

• char : 16-bit unicode (defaut: 'u0000')

• boolean : pas défini (defaut: false)

Notez les suffixes pour "forcer" Java à interpréter une valeur comme un type donné (par exemple lorsqu'on pratique une opération arithmétique avec une valeur: le type en sortie de myVar * 3.0f et myVar * 3.0d n'est pas le même)

Toutes les autres variables sont des objets:

• Instances de Classes

• Tableaux : Ils sont aussi typés. C'est le type _array of MaClasse_ qu'on note MaClasse[]. Leur longueur est fixe.

Une chaîne de caractères comme String school = "WCS";, bien qu'elle soit aussi triviale à déclarer que les primitives, est aussi une instance de classe, pas seulement une référence vers un tableau de char. String est une classe avec ses méthodes.

Les types primitifs ont leur pendant Objet: Byte, Short, Integer, Long, Float, Double, Character, Boolean du package java.lang, et qui portent des méthodes permettant de les manipuler.

BigInteger et BigDecimal sont aussi très usités.

Et leur valeur par défaut, comme celle de tout type non-primitif est null. null représente une référence vers aucun objet. Les primitives n'étant pas des objets, elles ne peuvent pas être null. Mais String s = null; est valide...

La gestion et le fonctionnement des tableaux et objets seront vus dans d'autres quêtes.

Lorsque l'on souhaite créer une variable, on parle de déclaration. Lorsque l'on souhaite lui attribuer (ou modifier) une valeur, il faut utiliser l'opérateur d'affectation =. On parle donc d'affectation. À la première déclaration de la variable, on parle d'initialisation et on affecte donc une valeur à cette variable. En Java, il est possible de déclarer une variable sans l'initialiser tout de suite, mais si on l'utilise par la suite, il faut absolument qu'elle soit initialisée au préalable. Le nom de la variable est toujours écrit en premier, suivi de l'opérateur d'affectation, suivi de la valeur, en terminant la ligne par un point-virgule.

int i = 1; // on affecte la valeur 1 à la variable i;

2 = i; // renvoie une erreur car 2 n'est pas une variable, on ne peut donc pas lui affecter de valeur.

Exemples de déclaration de variables :

• Entiers

int size = 200; long start = 0;

• Décimaux

float pi = 3.141592654f; half = 0.5;

• Booléens

isSaved = true; hasField = false;

• caractères

char letter = 'Z';

• Chaînes

String firstName = "Indiana"; String lastName = "Jones";

Tu noteras qu'il est également possible de déclarer plusieurs variables d'un coup :

    int a, b, c; // les trois variables a, b et c, de me type, sont déclarées en même temps, mais attention à la lisibilité!

...ou d'affecter une même valeur à plusieurs variables d'un coup :

    a = b = c = 2; // les trois variables a, b et c sont initialisées en même temps à 2, mais attention à la lisibilité là encore!

La portée (ou scope) des variables

La zone dans le code où est déclarée une variable est important. Une variable peut ne pas être visible par l'ensemble de ton code.

Dans la plupart des cas, quand tu déclares une variable, celle-ci est accessible dans l'ensemble de la classe où tu la déclares. Dans une méthode, elle est accessible en dessous de l'endroit où tu la déclares.

public class MyTest {

    int visibleInTheClassAndItsMethods;
    // ...

    public void myMethod() {
        int visibleInTheMethodOnly;
        // ...
        visibleInTheMethodOnly += 1; // doesn't compile, variable needs to be initialized first
    }

}

De manière générale, une variable n'est visible et donc accessible que dans le bloc où elle a été déclarée. On parle cette fois de variable à portée locale. En d'autres termes : ce qui se passe dans une méthode, reste dans la méthode !

Exemple :

public class MyTest {

    public void myMethod() {
        int visibleInTheMethodOnly = 0;

        for(int i = 0; i < 4; i++) {
            visibleInTheMethodOnly++; // compiles

            int visibleInTheBlockOnly = 1;
        }
        visibleInTheBlockOnly = 2; // Does not compile either
    }

}

Manipulations basiques des variables

int i = 1;
System.out.println(i + 1); // retourne 2, mais attention i vaut TOUJOURS 1, le println n'a fait que renvoyer le résultat de l'opération, sans écraser la valeur initiale de i

i = i + 1; // ici, on ajoute 1 à i, puis on affecte le résultat du calcul à i (on écrase ainsi la valeur précédente). Attention, i doit donc être préalablement déclaré sinon tu obtiendras une erreur.
System.out.println(i); // retourne 2, mais ici i vaut bien 2 car le résultat de l'opération a été affecté à i.

Il est donc possible d'effectuer les 4 opérations classiques : addition +, soustraction -, division /, multiplication *. On notera aussi l'existence du modulo % (qui donne en résultat le reste d'une division), et de nombreuses autres fonctions arithmétiques via les méthodes statiques (comprenez: fonctions) de la classe Math (ex: Math.pow(2, 5) pour calculer une puissance). Pour concaténer des chaînes de caractères, on utilisera aussi l'opérateur +.

Il existe des versions raccourcies des opérateurs arithmétiques.

i = 1;
i = i + 1; // i vaut 2.
i += 1; // cette ligne est la version raccourcie de la précédente, elle signifie : ajoute 1 à i puis affecte le résultat à i. i vaut maintenant 3.
i++; // cette notation signifie : incrémente i de 1, elle est donc l'équivalente des 2 lignes précédentes, mais attention, cette notation ne permet que d'ajouter 1, pas d'autres valeurs.

i -= 1: // équivaut à i = i - 1;
i--; // équivaut à la ligne ci-dessus, permet de décrémenter (uniquement de 1)
i *= 2: // équivaut à i = i * 2;
i /=2; // équivaut à i = i / 2;

En Java, qui est un langage très typé, certaines opérations arithmétiques induisent une 'promotion' du type des certaines variables. Cela se produit si tu utilises un opérateur qui va transformer de fait le type de la variable pour pouvoir fonctionner. On peut éventuellement forcer une variable sur un type en la préfixant par un type entre parenthèses (type)var, mais attention aux effets de bord!

        int i = 1; // OK
        long l = i; // OK i est converti en long

        i = i * 0.5; // ne compile pas, 0.5 est un double
        float f = i * 0.5; // ne compile pas, 0.5 est double, précision plus importante que float
        float g = i * 0.3f; // OK, i est converti en float et le résultat de l'opération va dans g

        double d = i; // OK, i est converti en double

        i = (int)f; //OK avec (cast), mais la valeur est potentiellement tronquée
        g = (float)d; //OK avec (cast), mais la valeur est potentiellement tronquée

        byte b = -23; // OK
        b = i; // ne compile pas, i a une précision plus importante que byte

        String s = "Hello " + 2018; // OK, 2018 est converti en chaîne avant la concaténation

Challenge

Déclarer et afficher des variables

Ecris un petit programme (une seule classe avec une méthode public static void main(String...args) qui va déclarer quatre variables de quatre types différents (à toi de choisir le bon type selon les cas). Pour réaliser ce programme, utilise les valeurs que tu trouveras sur le site IMDB, sur la fiche de la dernière croisade

• La première variable doit contenir le nom de ce film d'Indiana Jones, en VO
• La seconde variable te permettra d'indiquer si tu as vu ou non le film en question
• La troisième sera l'année de sortie en salle.
• La quatrième la note du film sur le site IMDB.

Affiche ces valeurs les unes sous les autres (tu peux utiliser System.out.println() pour afficher une variable).

Critères de validation

• le code est sur un GIST
• 4 types différents de variables sont représentés et utilisés à bon escient (int, string, boolean et float)
• les variables sont bien nommées (respect des bonnes pratiques et noms cohérents avec la valeur associée)
• ça fonctionne : le contenu des variables est affiché quand on lance le code.