La déclaration de variables
Une variable possède un nom, un type et une valeur. La déclaration d’une variable doit donc contenir deux choses : un nom et le type de données qu’elle peut contenir. Une variable est utilisable dans le bloc ou elle est définie.
La déclaration d’une variable permet de réserver la mémoire pour en stocker la valeur.
Le type d’une variable peut être un type élémentaire ou un objet :
type_élémentaire variable;
classe variable ;
| Exemple : |
long nombre; |
Rappel : les noms de variables en Java peuvent commencer par un lettre, par le caractère de soulignement ou par le signe dollars. Le reste du nom peut comporter des lettres ou des nombres mais jamais d’espaces.
Il est possible de définir plusieurs variables de même type en séparant chacune d’elles par une virgule.
| Exemple : |
int jour, mois, annee ; |
Java est un langage à typage rigoureux qui ne possède pas de transtypage automatique lorsque ce transtypage risque de conduire à une perte d’information.
Pour les objets, il est nécessaire en plus de la déclaration de la variable de créer un objet avant de pouvoir l’utiliser. Il faut réserver de la mémoire pour la création d’un objet ( remarque : un tableau est un objet en java ) avec l’instruction new. La libération de la mémoire se fait automatiquement grâce au garbage collector.
| Exemple : |
MaClasse instance; // déclaration de l'objetinstance = new maClasse(); // création de l'objetOU MaClasse instance = new MaClasse(); // déclaration et création de l'objet |
| Exemple : |
int[] nombre = new int[10]; |
Il est possible en une seule instruction de faire la déclaration et l’affectation d’une valeur à une variable ou plusieurs variables.
| Exemple : |
int i=3 , j=4 ; |
Les types élémentaires
Les types élémentaires ont une taille identique quelque soit la plate−forme d’exécution : c’est un des éléments qui permet à java d’être indépendant de la plate−forme sur lequel le code s’exécute.
| Type | Désignation | Longueur | Valeurs | Commentaires |
| boolean | valeur logique : true ou false | 8 bits | True ou false | pas de conversion possible vers un autre type |
| byte | octet signé | 8 bits | −128 à 127 | |
| short | entier court signé | 16 bits | −32768 à 32767 | |
| char | caractère Unicode | 16 bits | \u0000 à \uFFFF | entouré de cotes simples dans un programme Java |
| int | entier signé | 32 bits | −2147483648 à 2147483647 |
|
| float | virgule flottante simple précision (IEEE754) |
32 bits | 1.401e−045 à 3.40282e+038 |
|
| double | virgule flottante double précision (IEEE754) |
64 bits | 2.22507e−308 à 1.79769e+308 |
|
| long | entier long | 64 bits | −9223372036854775808 à 9223372036854775807 |
Les types élémentaires commencent tous par une minuscule.
Le format des types élémentaires
Le format des nombres entiers :
Les types byte, short, int et long peuvent être codés en décimal, hexadécimal ou octal. Pour un nombre hexadécimal, il suffit de préfixer sa valeur par 0x. Pour un nombre octal, le nombre doit commencer par un zéro. Le suffixe l ou L permet de spécifier que c’est un entier long.
Le format des nombres décimaux :
Les types float et double stockent des nombres flottants : pour être reconnus comme tel ils doivent posséder soit un point, un exposant ou l’un des suffixes f, F, d, D. Il est possible de préciser des nombres qui n’ont pas le partie entière ou décimale.
| Exemple : |
float pi = 3.141f;double v = 3dfloat f = +.1f , d = 1e10f; |
Par défaut un littéral est de type double : pour définir un float il faut le suffixer par la lettre f ou F.
| Exemple : |
double w = 1.1; |
Attention : float pi = 3.141; // erreur à la compilation
Le format des caractères :
Un caractère est codé sur 16 bis car il est conforme à la norme Unicode. Il doit être entouré par des apostrophes. Une valeur de type char peut être considérée comme un entier non négatif de 0 à 65535. Cependant la conversion implicite par affectation n’est pas possible.
| Exemple : |
/* test sur les caractères */class test1 {public static void main (String args[]) {char code = 'D';int index = code − 'A';System.out.println("index = " + index);}} |
L’initialisation des variables
| Exemple : |
int nombre; // déclarationnombre = 100; //initialisationOU int nombre = 100; //déclaration et initialisation |
En java, toute variable appartenant à un objet (définie comme étant un attribut de l’objet) est initialisée avec une valeur par défaut en accord avec son type au moment de la creation. Cette initialisation ne s’applique pas aux variables locales des méthodes de la classe.
Les valeurs par défaut lors de l’initialisation automatique des variables d’instances sont :
| Type | Valeur par défaut |
| boolean | false |
| byte, short, int, long | 0 |
| float, double | 0.0 |
| char | \u000 |
Remarque : Dans une applet, il est préférable de faire les déclarations et initialisation dans la méthode init().
L’affectation
le signe = est l’opérateur d’affectation et s’utilise avec une expression de la forme variable = expression. L’opération d’affectation est associatif de droite à gauche : il renvoie la valeur affectée ce qui permet d’écrire :
x = y = z = 0;
Il existe des opérateurs qui permettent de simplifier l’écritures d’une opération d’affectation associée à un opérateur mathématique :
| Opérateur | Exemple | Signification |
| = | a=10 | équivalent à : a = 10 |
| += | A+=10 | équivalent à : a = a + 10 |
| -= | a-= | équivalent à : a = a − 10 |
| *= | A*= | équivalent à : a = a * 10 |
| /= | a/=10 | équivalent à : a = a / 10 |
| %= | A%=10 | reste de la division |
| ^= | a^=10 | équivalent à : a = a ^ 10 |
| <<= | A<<=10 | équivalent à : a = a << 10 a est complété par des zéros à droite |
| >>= | a>>=10 | équivalent à : a = a >> 10 a est complété par des zéros à gauche |
| >>>= | a>>>=10 | équivalent à : a = a >>> 10 décalage à gauche non signé |
Attention : Lors d’une opération sur des opérandes de type différents, le compilateur détermine le type du résultat en prenant le type le plus précis des opérandes. Par exemple, une multiplication d’une variable de type float avec une variable de type double donne un résultat de type double. Lors d’une opération entre un opérande entier et un flottant, le résultat est du type de l’opérande flottant.
Les comparaisons
Java propose des opérateurs pour toutes les comparaisons :
| Opérateur | Exemple | Signification |
| > | a > 10 | strictement supérieur |
| < | a < 10 | strictement inférieur |
| >= | a >= 10 | supérieur ou égal |
| <= | a <= 10 | inférieur ou égal |
| == | a == 10 | Egalité |
| != | a != 10 | diffèrent de |
| & | a & b | ET binaire |
| ^ | a ^ b | OU exclusif binaire |
| | | a | b | OU binaire |
| && | a && b | ET logique (pour expressions booléennes) : l’évaluation de l’expression cesse dès qu’elle devient fausse |
| || | a || b | OU logique (pour expressions booléennes) : l’évaluation de l’expression cesse dès qu’elle devient vraie |
| ? : | a ? b : c | opérateur conditionnel : renvoie la valeur b ou c selon l’évaluation de l’expression a (si a alors b sinon c) : b et c doivent retourner le même type |
Les opérateurs sont exécutés dans l’ordre suivant à l’intérieure d’une expression qui est analysée de gauche à droite:
•incréments et décréments
•multiplication, division et reste de division (modulo)
•addition et soustraction
•comparaison
•le signe = d’affectation d’une valeur à une variable
L’usage des parenthèse permet de modifier cet ordre de priorité.