Cours Syntaxe Java

http://www.labo-sun.
com
labo-sun@supinfo.com
Aut eur : Ol i vi er Cor ger on
Ver si on 2. 0 - 19 oct obr e 2004
Nombr e de pages : 21

Ecole Suprieure dInformatique de Paris
23. rue Chteau Landon 75010 PARIS
www.supinfo.com

La syntaxe Java
BASES & NOMENCLATURES

La synt axe J ava Bases & nomencl at ur es 2 / 21

ht t p: / / www. l abo- sun. com
Ce document est la proprit de Supinfo et est soumis aux rgles de droits dauteurs

Table des matires

1. BASES ................................................................................................................................................................ 4
1.1. LES IDENTIFICATEURS................................................................................................................................... 4
1.2. LES MOTS RESERVES..................................................................................................................................... 4
1.3. LES COMMENTAIRES ..................................................................................................................................... 5
1.3.1. Les commentaires explicatifs ................................................................................................................ 5
1.3.2. Les commentaires Javadoc.................................................................................................................... 5
1.3.3. Les tags ................................................................................................................................................. 5
2. TYPES PRIMITIFS ET DEFINITION DE VARIABLES............................................................................ 7
2.1. LES TYPES DE BASE (PRIMITIFS) .................................................................................................................... 7
2.1.1. Dclaration et initialisation .................................................................................................................. 7
2.1.1.1. Les entiers ............................................................................................................................................. 8
2.1.1.2. Les nombres flottants ............................................................................................................................ 8
2.1.1.3. Les caractres ....................................................................................................................................... 8
2.2. LES TYPES REFERENCE.................................................................................................................................. 9
2.3. LES WRAPPERS............................................................................................................................................ 10
2.4. LES METHODES ........................................................................................................................................... 10
2.5. LA METHODE MAIN()................................................................................................................................ 11
3. LES INSTRUCTIONS.................................................................................................................................... 12
3.1. INSTRUCTIONS SIMPLES............................................................................................................................... 12
3.2. EXPRESSION CONDITIONNELLE ................................................................................................................... 12
3.2.1. Lexpression if / else............................................................................................................................ 12
3.2.2. Lexpression switch............................................................................................................................. 13
3.3. ITERATIONS................................................................................................................................................. 14
3.3.1. Litrateur while.................................................................................................................................. 14
3.3.2. Litrateur do / while .......................................................................................................................... 14
3.3.3. Litrateur for ..................................................................................................................................... 14
4. LES OPERATEURS....................................................................................................................................... 16
4.1. POINTS COMMUNS ET DIFFERENCES AVEC LE C........................................................................................... 16
4.2. LES DIFFERENTES CATEGORIES DOPERATEURS........................................................................................... 16
4.2.1. Les oprateurs daffectation................................................................................................................ 16
4.2.2. Les oprateurs logiques ...................................................................................................................... 18
4.2.3. Les oprateurs de comparaison .......................................................................................................... 18
4.2.4. Les oprateurs arithmtiques .............................................................................................................. 18
4.2.5. Les oprateurs au niveau binaires ...................................................................................................... 19
4.2.6. Loprateur conditionnel ternaire....................................................................................................... 19
5. LES TABLEAUX............................................................................................................................................ 20
5.1. DECLARATION DU TABLEAU........................................................................................................................ 20
5.2. INITIALISATION DU TABLEAU...................................................................................................................... 20
5.2.1. Tableau une dimension..................................................................................................................... 20
5.2.2. Tableau multidimensionnels................................................................................................................ 20
5.3. ACCEDER A UN TABLEAU............................................................................................................................ 21
5.3.1. Longueur dun tableau........................................................................................................................ 21


1. Bases
1.1. Les identificateurs
Lidentificateur (traduit de "handle") est le nom que lon choisit pour appeler un lment comme une
variable, une mthode, une classe ou encore une interface. Ces identificateurs doivent commencer par
une lettre Unicode ou encore un underscore "_".
1.2. Les mots rservs

abstract
boolean
break
byte
case
catch
char
class
continue
const
default
do
double
else
enum (nouveaut J ava 5.0)
extends
false
final
finally
float
for
goto
if
implements
import
instanceof

int
interface
long
native
new
null
package
private
protected
public
return
short
static
super
switch
synchronized
this
throw
throws
transient
true
try
void
volatile
while


1.3. Les commentaires
1.3.1. Les commentaires explicatifs
Les commentaires sont grs de deux manires en J ava :

Soit avec le style du C :
/ * ceci
est un
comment ai r e
*/

Soit avec le style du C++

/ / Ceci est un comment ai r e sur une seul e l i gne
Les commentaires sur une seule ligne servent surtout pour de courtes remarques lintrieur des
mthodes, celles sur plusieurs lignes sont plus appropries pour de larges remarques.
1.3.2. Les commentaires Javadoc
La zone de commentaire commencent par /** informe un commentaire de documentation. Ce
commentaire est dgag par un gnrateur automatique de documentation. Ce commentaire se
terminera toujours par */ :
/ **
* Document at i on sur l a cl asse
* @ver si on 12. 33, 2004- 10- 03
*/
Les espaces avant les lignes sont ignors.
Les lignes qui dbutent par @ sont reconnues comme des mots clef spcifiques pour le gnrateur de
documentation (J avadoc).
1.3.3. Les tags
Voici une liste non exhaustive de tags que vous allez pouvoir utiliser pour documenter votre code.
Tag Rle Elment concern
Version du
JDK
@author permet de prciser l'auteur de l'lment classe et interface 1.0
@deprecated permet de prciser qu'un lment est dprci
package, classe, interface,
mthode et champ
1.1
{@docRoot}
reprsente le chemin relatif du rpertoire
principal de gnration de la documentation
1.3

@exception
permet de prciser une exception qui peut
tre leve par l'lment
mthode 1.0
{@link}
permet d'insrer un lien vers un lment de la
documentation dans n'importe quel texte
mthode, champ
1.2
@param permet de prciser un paramtre de l'lment constructeur et mthode 1.0
@see
permet de prciser un lment en relation
avec l'lment document
champ
1.0
@since
permet de prciser depuis quelle version
l'lment a t ajout
mthode et champ
1.1
@throws identique @exception mthode 1.2
@version
permet de prciser le numro de version de
l'lment
classe et interface 1.0
@return
permet de prciser la valeur de retour d'un
lment
mthode 1.0


2. Types primitifs et dfinition de
variables
Toutes les variables et lments possdent des types J ava reconnus lors de la compilation, comme dans
tous les langages statiques.

Les types de donnes J ava sont regroups en deux catgories bien distinctes :

Les types de base : valeurs simples fonctionnalits intgres dans le systme (constante,
expression, numrique).
La zone mmoire alloue contient la valeur associe lidentificateur
1
(comme un caractre
pour les char ).

Les types de rfrences : les donnes passes grce leur rfrence. Ce sont les types de
classes. Ils englobent les tableaux et les objets.
La zone mmoire alloue lidentificateur contient un hexadcimal reprsentant l'adresse
mmoire o sont situs les champs de l'objet.
Celle-ci peut tre null.

2.1. Les types de base (primitifs)
char (16 bits Unicode)
short (16 bits entier sign)
int (32 bits entier sign)
long (64 bits entier sign)
float (32 bits IEEE (spcification internationale) 754)
double (64 bits IEEE (spcification internationale) 754)
byte (8 bits entier sign)
boolean (1 bit, true/false)

Les oprations virgule flottante sont standardises afin de respecter la norme internationale IEEE
754 qui dfinit que tous les calculs flottants sont identiques sur toutes les plateformes de J ava.

2.1.1. Dclaration et initialisation
Les variables sont dclares comme en C :

1
Un identificateur dsigne une classe, une mthode, une variable

i nt t ot o;
double t 1, t 2;
boolean f aux;
Elles peuvent aussi tre initialises lors de la dclaration :
int t ot o = 10;
double t 1=1. 25, t 2 = 1. 26;
boolean f aux = false;

Les variables dclares sous la forme de variable dinstance lintrieur dune classe non initialises
ont une valeur par dfaut.

Par dfaut les types numriques sont 0, les caractres au caractre nul '\0', et les variables boolennes
false.
Remarque : Avant quune variable puisse tre utilise, elle doit tre initialise !
2.1.1.1. Les entiers
Quand un type numrique est utilis dans le cadre dune affectation, il peut tre tendu un type plus
important.
Par contre une valeur numrique ne peut jamais tre affecte un type infrieur sans conversion.
short x = 2;
int i = x;

int i = 2;
short x = ( short) i ;
Dans ce second cas, la conversion explicite permet dviter une erreur la compilation.
2.1.1.2. Les nombres flottants
Ils sont toujours de type double sauf sils sont suivis de la lettre f ou F qui indique le type float.
double x = 5. 23;
float y = 5. 125F;
2.1.1.3. Les caractres
Spcification dune valeur de type caractre encadre par des simples quottes ('a'), le caractre
dchappement tant \, ou encore un numro de caractre Unicode en hexadcimal.

char x = ' x' ;
char y = ' \ ' ' ;
char z = ' \ caf e' ;

2.2. Les types rfrence
J ava permet de crer des nouveaux types de donnes : ainsi en crant une nouvelle classe,
implicitement nous crons un nouveau type.
Un lment dun type particulier peut tre affect une variable du mme type ou pass en argument
une mthode acceptant une valeur de ce type.
Les types de rfrences ont le mme nom que les classes quils reprsentent.
A linstar des classes, les types enfants sont des types drivs de la classe parente. Un objet de type
enfant peut tre utilis la place dun objet de type parent tant donn quil reprend toutes les
spcificits de la classe parent.
Donc un objet de type enfant pourra toujours tre utilis l o un objet de type parent est utilis. Cest
la drivation polymorphique (cf. Essentiels Les Classes Concept & Hritage ).
Contrairement au passage par valeur des types primitifs (o les valeurs sont toujours dupliques), les
variables de type "rfrence" contiennent une rfrence sur un objet de son type. Cest lquivalent des
pointeurs en C/C++mais en J ava, les types sont fixs et la valeur de rfrence ne peut tre consulte
directement.
Convention :
Les types de donnes de rfrence peuvent tre soit des classes, soit des tableaux.
La nomenclature J ava veut que les noms des classes et des tableaux commencent par une majuscule
(ainsi que la premire lettre de chaque mot composant un identifiant. Ex : class ClasseLaMaison).

En revanche, les noms de variables et de mthodes doivent commencer par une lettre minuscule.
Ex : nomDeMethode(), maVariable.

En ce qui concerne les noms des packages, ils doivent tre entirement en minuscule.
Ex : com.company.mypackage


2.3. Les wrappers
Nous avons vu quil existait des types primitifs en java. Cependant il est parfois utile dencapsuler
ses types primitifs afin par exemple de les passer par rfrence.
J ava a donc prvu des classes enveloppes ces primitives. Voici un tableau rcapitulatif des wrappers
disponibles et de leur relation avec les types primitifs :

type classes enveloppes
char Character
byte Byte
short Short
int Integer
long Long
float Float
double Double
boolean Boolean

Ces wrappers ont galement dautres utilits tel la conversion. Si vous souhaiter parser (analyser)
une chane de caractres vers un entier par exemple il vous faudra utiliser le wrappers : Integer.

int ent i er = I nt eger . par se( " 10" ) ;
2.4. Les mthodes
Tous comme en C/C++, les mthodes J ava comprennent un type de retour, un nom, des parenthses
avec dventuels paramtres, et le code entre accolades.
Cette mthode peut tre de plus prcde dun mot-cl dfinissant sa visibilit (cf. Essentiels Les
Classes Concept & Hritage )

void maMet hode( int i ) {
/ / code
}

public void maMet hode2( int i ) {
/ / code
}

2.5. La mthode main()
La mthode main() est le point de dpart du programme. Cest celle qui sera excute par la
machine virtuelle J ava lorsque vous demanderez lexcution du programme.
Elle scrit toujours de la manire suivante (seul le nom du paramtre peut tre modifi) :

public static void mai n( St r i ng ar gs[ ] ) {
/ / code
}


3. Les instructions
3.1. Instructions simples
Les instructions simples sont toujours termines par un point virgule.
Les instructions les plus communes sont les affectations et les appels de mthodes, elles se trouvent
dans des blocs de code dlimits par des accolades.

{
int l ongueur = 10; / / dcl ar at i on et af f ect at i on
float poi ds; / / dcl ar at i on de var i abl e
}
Remarque : Les dclarations de variables ont une porte limite au bloc de code et ne peuvent donc
pas tre vues lextrieur des accolades o elles ont t dclares
3.2. Expression conditionnelle
3.2.1. Lexpression if / else
Smantique de lexpression : si prdicat =vrai alors excution de l'instruction 1 sinon excution de
l'instruction 2.
if ( condi t i on) {
i nst r uct i on1;
} else if ( condi t i on2) {
i nst r uct i on2;
} else {
i nst r uct i on3;
}
Lexpression est de type boolean. La condition est vrifie (vrai) ou non (fausse).

3.2.2. Lexpression switch
Lexpression est compare ltiquette, lexcution seffectue jusqu la fin du switch sauf bien sur si
une instruction break est rencontre.
Tout comme en C, linstruction break provoque la sortie du switch. Si aucune tiquette ne correspond
lexpression, ltiquette par dfaut est slectionne.

int j our s = 7;
switch ( j our s) {
case 1:
Syst em. out . pr i nt l n( " l undi " ) ;
break;
case 2:
Syst em. out . pr i nt l n( " mar di " ) ;
break;
case 3:
Syst em. out . pr i nt l n( " mer cr edi " ) ;
break;
case 4:
Syst em. out . pr i nt l n( " j eudi " ) ;
break;
case 5:
Syst em. out . pr i nt l n( " vendr edi " ) ;
break;
case 6:
Syst em. out . pr i nt l n( " samedi " ) ;
break;
case 7:
Syst em. out . pr i nt l n( " di manche" ) ;
break;
default:
Syst em. out . pr i nt l n( " J our er r on! " ) ;
}

Dans cet exemple la variable "jours" est de type int.
Si la variable vaut "1", lundi est affich.
Si la variable vaut "4", J eudi est affich.
Pour toute autre valeur de la variable "jours", "jour erron" est affich.

Remarque : la variable utilise avec linstruction switch doit imprativement tre du type int ou
compatible (plus petit).

3.3. Itrations
3.3.1. Litrateur while
La smantique du while : Tant que la condition est ralise, excuter linstruction.
La condition est de type boolean et litration excute l'instruction tant que la condition donne la
valeur true. Si la condition est fausse, linstruction ne sera jamais excute.

Forme gnrale :
while (condition) {instructions};

int i = 10, somme = 0, j = 0;
while ( j <= i ) {
somme += j ++; / / j ++ est une opr at i on de post - i ncr ment at i on
}
Syst em. out . pr i nt l n( " boucl e whi l e: " + somme) ;
3.3.2. Litrateur do / while
La smantique du do / while : excute linstruction tant que la condition est vrifie.
La condition est value la fin. Le bloc d'instruction est excut une fois au minimum.
La boucle cesse ds que la condition est fausse.

Forme gnrale :
do {instructions} while (condition);

int i = 10, somme = 0, j = 0;
do {
somme = somme + j ;
j = j + 1;
} while ( j <= i ) ;
Syst em. out . pr i nt l n( " boucl e do whi l e " + somme) ;
3.3.3. Litrateur for
Linstruction for ressemble beaucoup celle du C : on peut ajouter de nouvelles variables dans
lexpression dinitialisation, ces variables auront par contre une dure de vie limite la porte de
linstruction.

Forme gnrale :
for (initialisation; condition; incrmentation) {instructions;}

for ( int i = 0; i < 10; i ++) {
Syst em. out . pr i nt l n( i ) ;
}

Il est tout fait possible de ne spcifier aucun des arguments initialisation, condition et
incrmentation, dans quel cas lutilisation du mot cl for correspond une boucle infinie. Vous
pouvez galement les omettre individuellement.
Il nest pas ncessaire que linstruction incrmentation se reporte imprativement une opration sur
un compteur : vous pouvez trs bien mettre une opration que vous souhaitez voir se rpter la fin de
chaque boucle.
Remarque : J ava ne gre pas loprateur , (virgule) qui permet de regrouper plusieurs expressions
en une seule.

4. Les oprateurs
Laccs ou la rfrence des objets, des variables ou des classes, est effectue grce aux oprateurs.

Des proprits de priorit et dassociativit sont affectes aux oprateurs. Des rgles de priorits
existent en J ava pour dfinir quels sont les lments qui peuvent agir avant les autres.
Les oprateurs sont classs en six catgories bien distinctes : affectation, arithmtique, logique,
comparaison, au niveau binaire et ternaire.
4.1. Points communs et diffrences avec le C
J ava gre la quasi-totalit des oprateurs pris en compte dans le langage C.
Les priorits sont en J ava les mmes que celles du C. Toutefois certains oprateurs du langage C
nexistent pas en J ava comme la virgule pour combiner plusieurs expressions.
Les oprateurs "&", "*", et "sizeof" ne sont pas grs, puisque J ava ne permet pas de modifier
directement les pointeurs.

En compensation, J ava ajoute quelques nouveaux oprateurs comme le "+" pour effectuer des
concatnations de valeurs de type String .

Puisque tous les types numriques sont signs, loprateur ">>" effectue un dcalage de bits droite
avec une extension pour le signe et loprateur ">>>" effectue un dcalage de bits droite sans se
proccuper du signe.
4.2. Les diffrentes catgories doprateurs
4.2.1. Les oprateurs daffectation
Cest le stockage de la valeur de droite dans celle de gauche avec le signe"=".
Cet oprateur permet de donner une valeur une variable.

int nombr e; / / dcl ar at i on
nombr e = 2; / / i ni t i al i sat i on

Oprateur Dfinition Priorit Associativit
= Affecte la valeur de droite la variable de gauche 15 Droite
+= Ajoute la valeur de droite la variable de gauche 15 Droite
-= Soustrait la valeur de droite la variable de gauche Puis
affecte la nouvelle valeur la variable de droite
15 Droite
*= Multiplie la valeur de droite avec la variable de gauche. Puis
15 Droite
/= Divise la valeur de droite avec la variable de gauche. Puis 15 Droite



4.2.2. Les oprateurs logiques
Ils permettent de rassembler des expressions de type boolen en indiquant au programme comment
comprendre une condition spcifique :

! "Not" (Change "true" en "false" ou inversement 2 Droite
& "And" renvoie "true" les deux oprandes valent "true" 9 Gauche
^ "XOR" renvoie "true" si une des deux oprandes vaut "true" 10 Gauche
| "OR" renvoie "true" si au moins un des oprandes vaut "true" 11 Gauche
&& "AND" conditionnel. N'value le second oprande que si le
premier est "true"
12 Gauche
|| "OR" conditionnel. N'value le second oprande que si le
premier nest pas "true"
13 Gauche
4.2.3. Les oprateurs de comparaison
Leur fonction premire est de comparer des expressions dautres parties du code.

< Infrieur 7 Gauche
> Suprieur 7 Gauche
<= Infrieur ou gale 7 Gauche
>= Suprieur ou gale 7 Gauche
== Egale 8 Gauche
!= Diffrent 8 Gauche
4.2.4. Les oprateurs arithmtiques
J ava peut excuter des fonctions mathmatiques avec les oprateurs utiliss pour effecteur les calculs
sur les entiers et sur les nombres virgule flottante. Les signes mathmatiques "+", "-", "*" et "/" sont
utiliss.

Oprateur Description Type doprande Priorit Associativit
++/-- Incrmentation et dcrmentation Arithmtique 1 Droite
+/- Plus et moins unitaires Boolen 2 Droite
* Multiplication Arithmtique 4 Gauche
/ Division Arithmtique 4 Gauche
% Modulo Arithmtique 4 Gauche
+/- Addition et soustractions Arithmtique 5 Gauche


4.2.5. Les oprateurs au niveau binaires
Ces oprateurs agissent sur les binaires. Ils prservent le signe du nombre initial.

Oprateur Description Priorit Associativit
~ Not Inverse chaque bit 0 devinent 1 et inversement 2 Droite
<< Dcalage de bits gauche sign 6 Gauche
>> Dcalage de bits droite sign 6 Gauche
>>> Dcalage de bits droite par ajout de zros 6 Gauche
& And au niveau des bits 9 Gauche
| Or au niveau des bits 10 Gauche
^ Xor au niveau des bits 11 Gauche
<<= Dcalage de bits gauche avec affectation 15 Gauche
>>= Dcalage de bits droite avec affectation 15 Gauche
>>>= Dcalage de bits droite par ajout de zros avec
affectation
15 Gauche
4.2.6. Loprateur conditionnel ternaire
Il existe un oprateur conditionnel ternaire en J ava :

Forme gnrale :
( condition ? condition_valide : condition_invalid )

int j = ( i > 2 ? i : 0) ; / / j = i si i supr i eur 2, si non j = 0


5. Les tableaux
Les tableaux sont des structures de donnes qui contiennent des valeurs du mme type.
Les tableaux sont marqus laide de crochets [ ].
5.1. Dclaration du tableau
Pour dclarer un tableau en J ava on peut placer les crochets avant ou aprs lidentificateur.
int col l ect i on[ ] ;
int[ ] ensembl e;

Quand un tableau est dclar, sa taille nest pas spcifie puisque la dclaration de ce tableau
nengendre pas lallocation de mmoire.
La taille ne sera dfinie que lorsque le tableau sera initialis.
5.2. Initialisation du tableau
Loprateur new est utilis pour allouer de la mmoire et initialiser le tableau.
5.2.1. Tableau une dimension
Dans un tableau nouvellement cr, tous les lments sont null ou 0.
La premire position du tableau commence lindex 0 tout comme en C. Dans notre exemple, les
lments sont numrots de 0 9.

/ / t abl eau de 10 l ment s de t ype i nt i ni t i al i s 0
int col l ect i on[ ] = new int[ 10] ;
Quand on initialise un tableau, la mmoire est automatiquement affecte au tableau pour y mettre les
valeurs initialises ce qui ne ncessite pas lutilisation de loprateur new.
char[ ] genr e= {' h' , ' f ' };
5.2.2. Tableau multidimensionnels
Vous pouvez dfinir des tableaux avec autant de dimensions que vous souhaitez.
Pour les tableaux bidimensionnels, le premier lment dtermine le nombre de colonnes et le second le
nombre de lignes : [colonnes][lignes].
float[ ] [ ] di mensi on = new float[ 10] [ 10] ;
/ / t abl eau bi di mensi onnel de 10*10 l ment s de t ype f l oat
int[ ] [ ] coor donnes = {{1, 3}, {7, 5}};
Remarque : Lorsque vous dclarez un tableau multidimensionnel, vous pouvez omettre la taille des
dimensions sauf pour la premire qui est obligatoire.

5.3. Accder un tableau
Pour atteindre un lment dun tableau, il suffit d'indexer la variable du tableau. Pour cela il faut faire
suivre le nom du tableau de lindice entre crochets.
char pr emi er El ement = genr e[ 0] ; / / ' h'
char deuxi meEl ement = genr e[ 1] ; / / ' f '
Si vous spcifiez un indice incorrect, une erreur (Exception) sera gnre. La gestion des erreurs sera
traite dans un autre cours (Exceptions).
5.3.1. Longueur dun tableau
Il est possible de demander la taille dun tableau en utilisant la variable length.
int[ ] t abl eau = {1, 10, 12, 9};
Syst em. out . pr i nt l n( " Longueur du t abl eau " + t abl eau. l engt h) ;

Cours Syntaxe Java

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Cours Syntaxe Java

Uploaded by

Copyright:

Available Formats

http://www.labo-sun.

You might also like