La syntaxe Java

1.Les règles de base

Java est sensible à la casse.

Les blocs de code sont encadrés par des accolades. Chaque instruction se termine par un caractère ';' (point virgule).

Une instruction peut tenir sur plusieurs lignes :

exemple

char
code
=
'D';

L'indentation est ignorée du compilateur mais elle permet une meilleure compréhension du code par le programmeur.

2.Les identificateurs

Chaque objet, classe, programme ou variable est associé à un nom : l'identificateur qui peut se composer de tous les caractères alphanumériques et des caractères _ et $. Le premier caractère doit être une lettre, le caractère de soulignement ou le signe dollar.

Rappel : Java est sensible à la casse.

Un identificateur ne peut pas appartenir à la liste des mots réservé du langage Java :

abstract	const	final	int	public	throw
assert (Java 1.4)	continue	finally	interface	return	throws
boolean	default	float	long	short	transient
break	do	for	native	static	true
byte	double	goto	new	strictfp	try
case	else	if	null	super	void
catch	enum (Java 5)	implements	package	switch	volatile
char	extends	import	private	synchronized	while
class	false	instanceof	protected	this

3.Les commentaires

Ils ne sont pas pris en compte par le compilateur donc ils ne sont pas inclus dans le pseudo code. Ils ne se terminent pas par un caractère ";".

Il existe trois types de commentaire en Java :

Type de commentaires	Exemple
commentaire abrégé	// commentaire sur une seule ligne int N=1; // déclaration du compteur
commentaire multi ligne	/* commentaires ligne 1 commentaires ligne 2 */
commentaire de documentation automatique	/** * commentaire de la methode * @param val la valeur à traiter * @since 1.0 * @return la valeur de retour * @deprecated Utiliser la nouvelle methode XXX */

4.Les déclaration et l'utilisation de variables

4.1. 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 :

• soit un type élémentaire dit aussi type primitif déclaré sous la forme type_élémentaire variable;
• soit une classe déclarée sous la forme classe variable ;

long nombre;
int compteur;
String chaine;

Rappel : les noms de variables en Java peuvent commencer par une lettre, par le caractère de soulignement ou par le signe dollar. 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'objet
instance = new MaClasse(); // création de l'objet
OU 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.

int i=3 , j=4 ;

4.2. 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 laquelle le code s'exécute.

Type
Désignation
Longueur
Valeurs
Commentaires
boolean
valeur logique : true ou false
1 bit
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 du code 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.

4.3.Le format  des types élémentaires

Le format des nombres entiers :

Il existe plusieurs formats pour les 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 :

Il existe plusieurs formats pour les nombres décimaux. Les types float et double stockent des nombres flottants : pour être reconnus comme tels 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 pas de partie décimale.




exemple


float pi = 3.141f;
double valeur = 3d;
float flottant1 = +.1f , flottant2 = 1e10f; 


Par défaut un littéral représentant une valeur décimale est de type double : pour définir un littéral représentant une valeur décimale de type float il faut le suffixer par la lettre f ou F.


Attention
float pi = 3.141; // erreur à la compilation 
float pi = 3.141f; // compilation sans erreur


exemple
double valeur = 1.1;

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);
    } 
}
4.4.L'initialisation des variables
exemple
float pi = 3.141f;
double valeur = 3d;
float flottant1 = +.1f , flottant2 = 1e10f; 



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 création. 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
classe
null


Remarque : Dans une applet, il est préférable de faire les déclarations et initialisation dans la méthode init().

4.5.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 associative 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'écriture 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-=10
équivalent à : a = a - 10
*=
a*=10
é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 types 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.

4.6.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èses permet de modifier cet ordre de priorité.




4.7. Les opérations arithmétiques





Les opérateurs arithmétiques se notent + (addition), - (soustraction), * (multiplication), / (division) et % (reste de la division). Ils peuvent se combiner à l'opérateur d'affectation



Exemple :



nombre += 10;


4.7.1. L'arithmétique entière
Pour les types numériques entiers, Java met en oeuvre une sorte de mécanisme de conversion implicite vers le type int appelée promotion entière. Ce mécanisme fait partie des règles mise en place pour renforcer la sécurité du code.



Exemple :





short x= 5 , y = 15;
x = x + y ; //erreur à la compilation

Incompatible type for =. Explicit cast needed to convert int to short.
x = x + y ; //erreur à la compilation
^
1 error


Les opérandes et le résultat de l'opération sont convertis en type int. Le résultat est affecté dans un type short : il y a donc risque de perte d'informations et donc une erreur est émise à la compilation. Cette promotion évite un débordement de capacité sans que le programmeur soit pleinement conscient du risque : il est nécessaire, pour régler le problème, d'utiliser une conversion explicite ou cast.



Exemple :



x = (short) ( x + y );



Il est nécessaire de mettre l'opération entre parenthèse pour que ce soit son résultat qui soit converti car le cast a une priorité plus forte que les opérateurs arithmétiques.



La division par zéro pour les types entiers lève l'exception ArithmeticException.



Exemple :





/* test sur la division par zero de nombres entiers */ 
class test3 {
    public static void main (String args[]) {
        int valeur=10;
        double resultat = valeur / 0;
        System.out.println("index = " + resultat);
    }
}





4.7.2. L'arithmétique en virgule flottante


Avec des valeurs float ou double, la division par zéro ne produit pas d'exception mais le résultat est indiqué par une valeur spéciale qui peut prendre trois états :



indéfini : Float.NaN ou Double.NaN (not a number)

indéfini positif : Float.POSITIVE_INFINITY ou Double.POSITIVE_INFINITY,+ ¥

indéfini négatif : Float.NEGATIVE_INFINITY ou Double.NEGATIVE_INFINITY,- ¥

Conformément à la norme IEEE754, ces valeurs spéciales représentent le résultat d'une expression invalide NaN, une valeur supérieure au plafond du type pour infini positif ou négatif.






X
Y
X / Y
X % Y
valeur finie
0
+ ¥
NaN
valeur finie
+/- ¥
0
x
0
0
NaN
NaN
+/- ¥
valeur finie
+/- ¥
NaN
+/- ¥
+/- ¥
NaN
NaN



Exemple :

/* test sur la division par zero de nombres flottants */ 

class test2 {
    public static void main (String args[]) {
        float valeur=10f; 
        double resultat = valeur / 0;
        System.out.println("index = " + resultat);
    }
}

4.7.3. L'incrémentation et la décrémentation
Les opérateurs d'incrémentation et de décrémentation sont : n++ ++n n-- --n

Si l'opérateur est placé avant la variable (préfixé), la modification de la valeur est immédiate sinon la modification n'a lieu qu'à l'issue de l'exécution de la ligne d'instruction (postfixé)

L'opérateur ++ renvoie la valeur avant incrémentation s'il est postfixé, après incrémentation s'il est préfixé.



Exemple :

System.out.println(x++); // est équivalent à
System.out.println(x); x = x + 1;

System.out.println(++x); // est équivalent à
x = x + 1; System.out.println(x);
Exemple :

/* test sur les incrementations prefixées et postfixées */

class test4 {
    public static void main (String args[]) {
        int n1=0;
        int n2=0;
        System.out.println("n1 = " + n1 + " n2 = " + n2);
        n1=n2++;         
        System.out.println("n1 = " + n1 + " n2 = " + n2);
        n1=++n2;        
        System.out.println("n1 = " + n1 + " n2 = " + n2);
        n1=n1++;        //attention
        System.out.println("n1 = " + n1 + " n2 = " + n2);
    }
}


Résultat :

int n1=0;
int n2=0; // n1=0 n2=0
n1=n2++; // n1=0 n2=1
n1=++n2; // n1=2 n2=2
n1=n1++; // attention : n1 ne change pas de valeur
4.8. La priorité des opérateurs



Java définit les priorités dans les opérateurs comme suit ( du plus prioritaire au moins prioritaire )







les parenthèses
( )
les opérateurs d'incrémentation
++
--
les opérateurs de multiplication, division, et modulo

*
/

%
les opérateurs d'addition et soustraction
+
-
les opérateurs de décalage
<<
>>
les opérateurs de comparaison
<
>
<=
>=
les opérateurs d'égalité
==
!=
l'opérateur OU exclusif
^
l'opérateur ET
&
l'opérateur OU
|
l'opérateur ET logique
&&
l'opérateur OU logique
||
les opérateurs d'assignement
=
+=
-=


Les parenthèses ayant une forte priorité, l'ordre d'interprétation des opérateurs peut être modifié par des parenthèses.