| ← (précédent) A.1 La fonction System.out.print() |
| A.3 La fonction System.in.read() → |
| Accueil ↔ S O M M A I R E |
A.2 Les variables (1) : |
|
Lorsque vous donnez votre numéro à la sécurité sociale, on retrouve vos nom, prénom(s), âge, etc... Parce que ce programme qui se trouve dans leurs ordinateurs a besoin
de stocker ces informations. Ces informations sont contenues dans ce qu'on appelle des variables. Ces dernières ont pour valeurs, des nombres (entiers ou décimaux),
des mots, des dates de naissance, des fichiers, et d'autres informations moins simples que nous verrons plus tard : des objets (au sens de la programmation orientée objet). Dans ce chapitre, nous nous contenterons de voir les variables de type primitif qui sont : byte, short, int, long, float, double, char, boolean et String. Encore que le dernier peut être utilisé aussi bien en type primitif qu'en type Objet. Programmez sans variables est une mission plutôt impossible |
EXEMPLE 1 :
1. public class Variables1
2. {
3.
4. public static void main (String [] args)
5. {
6. age = 40;
7. }
8.
9. }
|
|
Compilez ce programme, un message d' erreur sera affiché. Ce message sera : Variables1.java:9: cannot find symbol symbol : variable age location: class Testeur age = 40; ^ 1 error EXPLICATIONS : Java ne comprend pas un terme. Ce terme est la variable age qui se trouve dans la classe Variables1.java Ce message est normal. En Java, quand on utilise une variable, on doit d' abord la déclarer. Et on déclare une variable grâce à au moins deux mots : le nom de la variable, précédé de son type. Java est en effet un langage de programmation fortement typé. On ne met pas n' importe quelle valeur dans n' importe quelle variable. Cela permet d' éviter des erreurs. Vous le comprendrez mieux au fur et à mesure que vous comprendrez la programmation. En Java, on distingue 2 grands groupes de types de variables. Les types primitifs encore appelés types de bases et les types dits de classe encore appelés types objets, au sens de la programmation orientée objet. Nous verraons les types objet plus tard. Les types primitifs sont classés en 4 groupes : Le type nombre entier qui contient 4 sous-types : Le type byte dont les valeurs sont comprises entre - 128 et + 127 ... Le type short dont les valeurs sont comprises entre - 32 768 et + 32 767... Le type int dont les valeurs sont comprises entre - 2 147 483 648 et + 2 147 483 647 et enfin Le type long dont les valeurs sont comprises entre - 9 223 372 036 854 775 808 et + 9 223 372 036 854 775 807 Avant de parler des autres types de base, un petit exemple : |
EXEMPLE 2 :
1. public class Variables2
2. {
3.
4. public static void main (String [] args)
5. {
6. byte age;
7. age = 40;
8. System.out.print(age);
9. }
10.
11. }
|
|
Compilez puis exécutez ce programme, il sera affiché : 40 Expliquons : Sur la ligne 6, nous avons déclaré la variable age comme étant de type byte. Donc, un nombre entier dont la valeur est comprise entre - 128 et + 127. Sur la ligne 7, on a mis la valeur 40 dans la variable age. On dit aussi qu' on a affecté la valeur 40 à la variable age. Sur la ligne 8, vous l' avez deviné, on demande à Java d' afficher la variable age. Attention, il ne s' agit pas d' afficher le mot age. Si c' était le cas, il y aurait eu des doubles guillemets autour du mot age. Non, il s' agit en fait d' afficher la valeur de la variable age. Lorsque Java voit un mot sans guillemets dans les parenthèses de la fonction System.out.print() , il considere que c' est une variable. Si cette variable existe (comme c' est le cas ici), java affiche son contenu. D' où le nombre 40 affiché. |
EXEMPLE 3 :
1. public class Variables3
2. {
3.
4. public static void main (String [] args)
5. {
6. byte age = 40;
7. System.out.println(age);
8. short nombreEleves = 12574;
9. System.out.println(nombreEleves);
10. int populationFrance = 65254897;
11. System.out.println(populationFrance);
12. long distanceExoPlanete = 12425369875489624;
13. System.out.println(distanceExoPlanete);
14.
15. }
16. }
|
|
Compilez puis exécutez ce programme, il sera affiché : 40 12574 65254897 12425369875489624 Expliquons : La ligne 6 : déclaration et affectation d' une valeur à une variable. La ligne 7 : affichage de la valeur de cette variable. Même raisonnement pour les lignes 8 et 9, puis 10 et 11, puis 12 et 13. Sachez que dans la pratique, pour ce qui est des variables de type primitifs, déclaration et affectation vont toujours ensemble. Le nom d' une variable peut commencer par une lettre (miniscule obligatoirement) ou par le caractère underscore _ (sur la même touche que 8 sur le clavier azerty). Personnellement, je préfère la lettre miniscule. Dans le cas où le nom d' une variable est un ensemble de mots, la première lettre des autres mots doit être en majuscules, ceci afin de différencier les mots et faciliter ainsi la lecture. Afficher les valeurs de variables, c' est bien. Mais si on ne sait pas à quoi correspond cette valeur, ça n' a pas d' importance. au lieu d' afficher par exemple 40, ce serait mieux d' afficher age = 40. C' est plus parlant non? , il considere que c' est une variable. Si cette variable existe (comme c' est le cas ici), java affiche son contenu. D' où le nombre 40 affiché. |
EXEMPLE 4 :
1. public class Variables4
2. {
3.
4. public static void main (String [] args)
5. {
6. byte age = 40;
7. System.out.println("age = " + age);
8. short nombreEleves = 12574;
9. System.out.println("nombreEleves = " + nombreEleves);
10. int populationFrance = 65254897;
11. System.out.println("populationFrance = " + populationFrance);
12. long distanceExoPlanete = 12425369875489624;
13. System.out.println("distanceExoPlanete = " + distanceExoPlanete);
14.
15. }
16. }
|
|
Compilez puis exécutez ce programme, il sera affiché : age = 40 nombreEleves = 12574 populationFrance = 65254897 distanceExoPlanete = 12425369875489624 C' est pas mieux ça ? Evidement ! ligne 7 : Java affiche ce qui se trouve entre les doubles guillemets, puis affiche le contenu de la variable préalablement déclarée et affectée ligne 6 Même raisonnement pour les autres affichages. Autre chose sur les nombres entiers. Si vous ne connaissez pas quel type choisir, parce que évidement vous ne connaissez pas l' échelle des valeurs, choisissez le type int. C' est toujours le type qu' on choisit par défaut. Même java le choisit par défaut. Je vous expliquerais pourquoi dans la partie opérateurs et opérations sur les variables. Maintenant, voyons les autres types primitifs. |
EXEMPLE 5 :
1. public class Variables5
2. {
3.
4. public static void main (String [] args)
5. {
6. char lettre = 't';
7. System.out.println("lettre = " + lettre);
8. String nom = "DUPONT";
9. System.out.println("nom = " + nom);
10.
11. }
12. }
|
|
Compilez puis exécutez ce programme, il sera affiché : lettre = c nom = DUPONT Lorsque votre variable ne doit contenir qu' un seul caractère, et que cela ne doit pas changer au cours du programme, vous avez affaire à une variable de type char. Si vous essayez de mettre plus d' un caractère dans une variable de type char, un message d' erreur sera affiché à la compilation. Même chose si vous essayez d'y mettre zéro caractère. Attention, Le caractère espace n'est pas zéro caractère. Donc, char c = ' '; est acceptable en Java. Pas char c = ''; Alors que le type String lui accepte zéro caractère. String z = ""; est correct en Java. Pour le type String, c' est tout simplement la chaine de caractères dont il est question en exemple 1 du chapitre A1 Sachez que le type String n' est pas un type de base, un type primitif de java. Mais plutôt un type Objet. Mais si on en parle ici, c' est parce qu' il a une petite particularité. Une variable de type String peut être affectée comme un type primitif, avec le signe égal (=). Alors que les types Objets sont toujours affectés par le mot clé new . Nous le verrons plus tard en Programmation Orientée Objet. Sachez pour finir avec ce type que vous pouvez mettre un nombre de caractères indifférents dans le type String. Y compris zéro caractère. |
EXEMPLE 6 :
1. public class Variables6
2. {
3.
4. public static void main (String [] args)
5. {
6. float tva = 20.6f;
7. System.out.println("tva = " + tva);
8. double tauxLivret = 2.5;
9. System.out.println("tauxLivret = " + tauxLivret);
10.
11. }
12. }
|
|
Compilez puis exécutez ce programme, il sera affiché : tva = 20.6 tauxLivret = 2.5 Les types float et double sont des types nombres décimaux. En java, on dit surtout nombres réels ou nombres à virgule flottante. le type float est un type dont les valeurs sont comprises entre - 1.4 * 10-45 et + 3.4 * 10 + 38 Le type double a ses valeurs comprises entre - 4.9 * 10- 324 et 1.7 * 10+ 308 Le caractère * est le signe de la multiplication en Java Si vous ne connaissez pas l' échelle de valeurs de la variable de type nombre réel que vous manipulez, préférez le type double. C' est aussi le type que Java choisit par défaut. La lettre f qui termine la valeur de la variable de type float permet de préciser qu' il est bien question de type float. Si la lettre n' y est pas mentionné, alors on a affaire au type double. Essayer de mettre une valeur de type double dans une variable de type float, un message d' erreur s' affiche. Java n' aime pas ça. Je vous expliquerais pourquoi dans la partie opérateurs et opérations sur les variables. |
EXEMPLE 7 :
1. public class Variables7
2. {
3.
4. public static void main (String [] args)
5. {
6. boolean situation1 = true;
7. System.out.println("situation1 = " + situation1);
8. boolean situation2 = false;
9. System.out.println("situation2 = " + situation2);
10.
11. }
12. }
|
|
Compilez puis exécutez ce programme, il sera affiché : situation1 = true situation2 = false Les variables de type booléenne n' ont que deux valeurs possibles. Si une situation est vraie, la valeur est true. Dans le cas contraire, la valeur est false. On ne peut pas affecter une autre valeur dans une variable de type boolean. Si vous essayez, message d' erreur à la compilation Dans la pratique, vous n' aurez pas à afficher la valeur d' une variable de type boolean. Vous exploiterez cette valeur de façon implicite dans des structures conditionnelles. Par exemple, si x est supérieur à y, alors afficher x. Sinon, affichez y. Evidement, vous utiliserez le langage Java pour cela. Si x est effectivement supérieur à y, la situation est vraie. Fausse dans le cas contraire. |
EXEMPLE 8 :
1. public class Variables8
2. {
3.
4. public static void main (String [] args)
5. {
6. final int NOMBRE = 25;
7. System.out.println("NOMBRE = " + NOMBRE);
8.
9 . }
10. }
|
|
Compilez puis exécutez ce programme, il sera affiché : NOMBRE = 25 ligne 6 déclaration et affectation d' une variable. Comme vous le savez déjà. Mais il y a quelque chose en plus. Le mot final. Ce mot a une signification particulière en Java. Ccedil;a veut dire que la variable NOMBRE est constante. Donc la valeur de ce nombre ne doit pas varier au cours du programme. Si tel devait être le cas, à la compilation, un message d' eereur s' afficherait. Remarquez aussi le nom de la variable. Toutes les lettres sont en majuscules. En Java, il est conseillé (pas une obligation) d' écrire le nom d' une variable contante toute en majuscules. La question qui peut se poser est de savoir ce qu' on fait si le nom de cette variable est composée de plusierurs mots. Que faire étant donné que je vous ai dit de mettre la première de chaque mot (à partir du 2ème) en majuscules ? C' est simple ! Utiliser le caractère underscore (sous le chiffre 8 du clavier azerty). Par exemple : NOMBRE_CONSTANT, TAUX_TVA ou encore DISTANCE_SOLEIL |
EXEMPLE 9 :
1. public class Variables9
2. {
3.
4. public static void main (String [] args)
5. {
6. final int NOMBRE = 25;
7. NOMBRE = 33;
8.
9 . }
10. }
|
|
Compilez ce programme. Et vous aurez un message d' erreur qui sera : cannot assign a value to a final variable NOMBRE Ce qui veut dire : je ne peux pas attribuer une valeur à une variable final. En effet, une variable déclarée avec le mot clé final est une constante. Donc, impossible de changer sa valeur. Le même message d' erreur sera affiché, même dans le cas ou vous essayez de mettre la valeur 25 dans la variable NOMBRE. Etonnant ? pas vraiment. Lorsque vous donnez une nouvelle valeur à une variable, cette nouvelle valeur vient chasser l' ancienne. Ce qui veut dire que l' action de mettre une valeur dans la variable est quand même réalisée. Le compilateur JAVA juge l' action de vouloir mettre une valeur dans une variable constante. Ce qui, pour lui, est anormal. Le compilateur ne cherche pas à comparer la nouvelle valeur et l' ancienne. |
EXEMPLE 10 :
1. public class Variables10
2. {
3.
4. public static void main (String [] args)
5. {
6. int for = 25;
7.
8.
9 . }
10. }
|
|
compilez ce programme et un message d' erreur vous signalera que l' instruction n' en est pas une (not a statement sera affiché.) Pourquoi ? parce que le nom de la variable est ici un mot clé java. Ce mot (for) est toujours suivi d' une paire de parenthèses. Ce qui n' est pas le cas ici. Donc, le compilateur considère que ce n' est pas une instruction ( a statement). for est un mot clé du langage JAVA. En effet, Un mot-clé est tout simplement un mot qui a été réservé pour une utilisation spéciale par le langage. Vous ne pouvez donc pas employer des mots-clés comme noms de variable, ou nom de classe. Ces mots sont : abstract - assert - boolean - break - byte - case - catch - char class - const - continue - default - do - double - else - extends - false - final - finally - float - for - goto - if - implements - import - instanceof - int - interface - long - native - new - null - package - private - protected - public - return - short - static - strictfp - super - switch - synchronized - this - throw - throws - transient - true - try - void - volatile - while |
EXEMPLE 11 :
1. public class Variables11
2. {
3.
4. public static void main (String [] args)
5. {
6. int 1nombre = 25;
7.
8.
9 . }
10. }
|
|
compilez ce programme et un message d' erreur vous signalera que l' instruction n' en est pas une (not a statement sera affiché.) pourquoi ? Parce qu' ici le nom de la variable commence par un chiffre. Et ça, le compilateur Java n' aime pas. Le nom d' une variable ou de quoique ce soit d' ailleurs en java, ne doit jamais commencer par un nombre. |
EXEMPLE 12 :
1. public class Variables12
2. {
3.
4. public static void main (String [] args)
5. {
6. int nombre1 = 25; int nombre2 = 11; int nombre3 = 52;
7. System.out.println("nombre1 = " + nombre1);
8. System.out.println("nombre2 = " + nombre2);
9 . System.out.print("nombre3 = " + nombre3);
10. }
11. }
|
|
Compilez puis exécutez ce programme, il sera affiché : nombre1 = 25 nombre1 = 11 nombre1 = 52 Ligne 6 : déclaration de la variable nombre1 et affectation de la valeur 25 à cette variable. Même chose pour nombre2 avec valeur 11 et même chose pour nombre3 avec valeur 52 Ligne 7 : affichage de la chaine de caractères nombre1 = suivi de la valeur de la variable nombre1 Même explication pour nombre2 (ligne8) et nombre3 (ligne9). Jusqu'ici, cet exemple ne vous apprend rien de nouveau à priori. Mais reprenez ce programme et changez seulement la ligne 6 en ceci : int nombre1 = 25, nombre2 = 11, nombre3 = 52; Après compilation et exécution, vous aurez le même résultat. explications : En Java, on peut déclarer plusieurs variables de même type en écrivant une seule fois le mot-clé représentant le type. A condition de mettre une virgule au lieu d'un point virgule après chaque variable déclarée. int a, b, c, d; équivaut à int a; int b; int c; int d; int a = 1, b = 5, c = 21; équivaut à int a = 1; int b = 5; int c = 21; Notez bien les endroits où l'on utilise seulement la virgule. int a = 31; b = 25; --> à la compilation, message d'erreur. Car b = 5 n'est pas reconnu par Java. Seul a est reconnu comme une ariable de type int. correction : int a = 31, b= 25; ou int a = 31; int b = 25; Evidement, int a = 33, byte b = 4; est une fausse déclaration qui sera sanctionnée par le compilateur en vous envoyant un message d'erreur. En effet, byte et int sont peut-être deux variables de type nombre entier. Mais on ne peut pas les déclarer en séparant par une simple virgule. |
| ← (précédent) A.1 La fonction System.out.print() |
| A.3 La fonction System.in.read() → |
| Accueil ↔ S O M M A I R E |
A.2 Les variables (1) : les types primitifs - les constantes |