CHAPITRE 2 : LES

ELEMENTS DU LANGAGE
JAVA
Dr. A. Nejeoui

! POO JAVA: GI2

Objectifs :
INTRODUCTION
Comprendre la structure d’une application Java

Manipulation des variables de types primitifs

Comprendre le Dépassement

Manipulation des variable de types references

Les opérateurs (arithmétiques, logiques, )

Les Expressions et les Instructions

" POO JAVA : GI2

 INTRODUCTION
Instructions de contrôle

if - else

L’instruction switch

Boucle for

Boucle while

Boucle do-while

break et continue

try-catch-finally
return
# POO JAVA : GI2
STRUCTURE D’UNE APPLICATION
JAVA
UNE APPLICATION JAVA EST UN
ENSEMBLE DE CLASSES ET
INTERFACES DONT UNE AU MOINS
CONTIENT LA MÉTHODE MAIN. LES
CLASSES SONT COMPOSÉS DE
MÉTHODES ET ATTRIBUTS. UNE
MÉTHODE EST UN ENSEMBLE
D'INSTRUCTIONS. IL Y A 3 TYPES
D’INSTRUCTIONS, INSTRUCTIONS :
DE DECLARATION
D’EXPRESSION
DE CONTRÔLE DE FLOT
D’EXÉCUTION

$ POO JAVA: GI2

% POO JAVA: GI2
 LES DECLARATIONS

& POO JAVA: GI2

 LES VARIABLES DE TYPES
Type
PRIMITIFS
Taille Min M
UNE VARIABLE EST UNE ZONE
byte / Byte 8 -128 127
ax MEMOIRE IDENTIFIÉE PAR UN
IDENTIFICATEUR.

short / Short 16 -32768 32767 CHAQUE VARIABLE POSSÈDE UN

NOM ET UN TYPE ET ELLE EST
VISIBLE DANS SA PORTÉE.
char / Character 16 U+0000 U+FFFF
EN JAVA ON DISTINGUE ENTRE :

LES VARIABLES DE DE TYPE

int / Integer 32 -2147483648 2147483647
PRIMITIF

-922337203685 9223372036854 LES VARIABLES DE TYPE

long / Long 64 REFERENCE
4775808 775807
float / Float 32 1.4E-45 3.4028235E+38
-
1.79769313486
double / Double 64 4.9E-324
23157E308
boolean / Boolean - - -

' POO JAVA: GI2

OVERFLOW / UNDERFLOW

( BUSINESS THEME
 OVERFLOW / UNDERFLOW
Un entier int est stocké sur 32-bits, le résultat n*n est 4,000,000,000,000,000,000 dont la représentation
binaire est sur 64-bits :
-- Les bits du poids le plus fort -- 00110111 10000010 11011010 11001110 -- Les bits du poids le plus faible-
10011101 10010000 00000000 00000000
32-bit n’est pas suffisant pour stocker le nombre, les 4 octets du poids le plus fort sont tronqués, le nombre
est donc remplacé par les 4 octets du poids le plus faible : 10011101 10010000 00000000 00000000 qui
représente le nombre décimal 1651507200 et comme le bit du poids le plus fort est égal à 1, le nombre est
négatif donc on aura -1651507200

Un double est stocké sur 64-bits La valeur Max = Double.MAX_VALUE = 1.7976931348623157E308

La valeur Min = Double.MIN_VALUE = 1.7976931348623157E308
Un float est stocké sur 32-bits La valeur Max = Float.MAX_VALUE = 3.4028235E38
La valeur Min = Float.MIN_VALUE = 1.4E-45
Le résultat d’un Overflow pour les types double et float donne INFINITY
Le résultat d’un Underflow pour les types double et float donne 0.0

) POO JAVA: GI2

 NOM D’UNE VARIABLE
Un identificateur :
Doit commencer par une Lettre Java (Character.isJavaIdentifierStart(int ) doit retourner true)
Doit contenir seulement des caractères de type Lettre Java ou chiffres Java
(Character.isJavaIdentifierPart(int) doit retourner true )
Doit être différent des mots réservés du langage Java
Doit être différent des littérales : true, false et null.
Peut avoir une taille quelconque : mais de préférence il faut choisir des noms de variables significatifs
et courts.
Par convention : le nom d’une variables commence par une lettre minuscule.

!* POO JAVA: GI2

50 MOTS-RÉSERVÉS JAVA
abstract continue for new switch

assert default if package synchronized

boolean do goto private this

break double implements protected throw

byte else import public throws

case enum instanceof return transient

catch extends int short try

char final interface static void

volatile
class finally long strictfp

while
const float native super

!!
11 POO JAVA: GI2
 VARIABLES DE TYPE
REFERENCE
Toute variable de type différent des 8 types primitifs est dite de type référence. Example :
String nom=“Hicham”;
Date date;
Gadget helicopter = new Helicopter();
l’API Java 8 contient plus de 4000 classes.
On peut initialiser les variables de type reference par affectation d’une reference d’un type compatible ou via
l’appel d’un constructeur d’un type compatible.

!" POO JAVA: GI2

 INITIALISER UNE VARIABLE
une variable de type primitif • int x = 35;
peut être initialisée par une
latérale d’un type compatible. • double d=3.56;

• byte index=109; • long mils=1234567890L;

• short numero=34567; • char ‫\‘ = جيم‬u062C';

• float x = 35.09f; • char tradeM = ‘\u2122';

• boolean flag=true;

!# POO JAVA: GI2

PORTÉE D’UNE VARIABLE
Definition :
La portée d’une variable c’est la
section du code source dans
laquelle la variable est visible.
Java définit quatre niveaux de
portée :
Les variables membre
Les paramètres d’une
méthode
Les variables locales
Les paramètres de gestion
des exceptions :
accessibles dans le
block catch

!$ POO JAVA: GI2

 LA CLASSE STRING
La classe String est une classe immuable qui représente des
chaines de caractères immuables.

length()

charAt(int index)

split(String sep)

intern()

substring(int beginIndex, int endIndex)

match(String regex)

!% POO JAVA : GI2

 OPÉRATEURS
Il y’a plusieurs type d’opérateur en Java :
Opérateurs arithmétiques
Opérateurs conditionnels et relationnels
Opérateur logiques
Opérateurs sur les bits.
Opérateurs d’affectation

!& POO JAVA: GI2

 OPÉRATEURS ARITHMÉTIQUES
Opérateur Utilisation Description

+ op1 + op2 Ajoute de op1 à op2

- op1 - op2 Soustrait op2 de op1

* op1 * op2 Multiplie op1 par op2

/ op1 / op2 divise op1 par op2

% op1 % op2 Calcul le reste de la division de op1 par op2

!'
& POO JAVA: GI2
 OPÉRATEURS UNAIRES
Opérateur Utilisation Description
Change le type de op à int si c’était un byte,
+ +op
short, ou char
- -op Négation arithmétique de op

Opérateur Utilisation Description

Incrément op par 1; il est évalué par la valeur
++ op++
de op avant incrémentation .
Incrément op par 1; il est évalué par la valeur
++ ++op
de op après incrémentation .
Décrément op par 1; il est évalué par la valeur
-- op--
de op avant décrémentation .
décrément op par 1; il est évalué par la valeur
-- --op de op après décrémentation .

!(
& POO JAVA: GI2
 OPÉRATEURS RELATIONNELS
Opérateur Utilisation Retourne true si Un opérateur relationnel
compare deux
op1 est plus grand que opérandes et
> op1 > op2 détermine la relation
op2
entre eux
op1 est plus grand ou
>= op1 >= op2
égal à op2
< op1 < op2 op1 est inférieur à op2

op1 est inférieur ou égal

<= op1 <= op2
à op2
== op1 == op2 op1 et op2 sont égaux

op1 et op2 sont

!= op1 != op2
différents

!)
& POO JAVA: GI2
OPÉRATEURS CONDITIONNELS
Opérateur Utilisation Retourne true si

o p 1 & & op1 et op2 sont vrais tous les deux,

&&
op2 l’évaluation de op2 est conditionnelle
L’un des opérandes op1 ou op2 est vrai,
|| op1 || op2
l’évaluation de op2 est conditionnelle
! ! op op est faux
op1 et op2 sont vrais tous les deux,
& op1 & op2 l ’ é v a l u a t i o n d e o p 2 e t o p 1 e s t
nécessaire
L’un des opérandes op1 ou op2 est vrai,
| op1 | op2 l ’ é v a l u a t i o n d e o p 2 e t o p 1 e s t
nécessaire
^ op1 ^ op2 Si op1 et op2 sont différents

"*
& POO JAVA: GI2
 OPÉRATEURS D’AFFECTATION
Opérateur Utilisation Equivalence

+= op1 += op2 op1 = op1 + op2

-= op1 -= op2 op1 = op1 - op2

*= op1 *= op2 op1 = op1 * op2

/= op1 /= op2 op1 = op1 / op2

%= op1 %= op2 op1 = op1 % op2
&= op1 &= op2 op1 = op1 & op2
|= op1 |= op2 op1 = op1 | op2
^= op1 ^= op2 op1 = op1 ^ op2

"!
& POO JAVA: GI2
 LES OPÉRATEURS SUR LES BITS
Opérateur Utilisation Description Si l’un des opérandes n’est pas de
après promotion numérique binaire & est type primitif integral (byte,
& op1 & op2
appliquer sur chaque bit short, char, int, long)
après promotion numérique binaire | est l’expression génère une erreur
| op1 | op2
appliquer sur chaque bit de compilation.
Dans le cas des opérateurs (&, | ,
après promotion numérique binaire ^ est
^ op1 ^ op2 ^) la promotion numérique
appliquer sur chaque bit
binaire est appliquée sur les
~ ~op ~op égale (-op)-1 deux opérandes.
Décalage à La promotion numérique binaire
<< 7 << 2 donne 28
gauche n’est pas appliquée sur les
Décalage à deux opérandes dans la cas
>> 7 >> 2 donne 1
droit signée des opérateurs de décalage de
si n est un entier négatif (n >> s) + (2 << bits (>>, <<, >>>), par contre
n >>> s 31-s) la promotion numérique
Décalage à si n est un long négatif (n >> s) + (2L << unaire est appliquée sur
>>>
droit non 63-s)
chaque opérande séparément
signée -7 >>> 1 donne 2147483644
-7L >>>1 donne 9223372036854775804 avant d’appliquer les
opérateurs de décalage des
>>= op1>>=op2 op1=op1 >> op2
bits.
<<= op1<<=op2 op1=op1 << op2
""
& >>>=POO JAVA: GI2
op>>>=op2 op=op >>> op2
 AUTRES OPÉRATEURS
Opérateur Description
?: Abréviation de l’instruction if-else
Déclaration des tableaux (arrays), création, accès
[]
aux éléments.
. Pour former des nom composés
Détermine une liste des paramètres séparés par
(params )
des virgules.
( type ) Converti une valeur au type spécifié
new Pour créer un nouveau objet ou nouveau tableau
Détermine si son premier opérande est une
instanceof
instance de son second opérande.

"#
& POO JAVA: GI2
 COMPLÉMENT À DEUX
• Java utilise la representation complément à
deux pour représenter les nombres entiers.
• un nombre positifs est représenté par ça
représentation binaire ordinaire.
• un nombre négatif est est obtenu alors par
inversion des bits du nombre positif puis
ajouter 1 et ignorer le dépassement.

"$ POO JAVA: GI2

 EXPRESSIONS,
INSTRUCTION ET BLOCS

"% POO JAVA: GI2

 EXPRESSIONS
• Les expressions sont utilisées
pour calculer et assigner les
valeurs aux variables, et pour aider
Définition
à contrôler le flot d’exécution du Une expression est une

programme. série d’opérandes,

opérateurs et appels
de méthodes qui est

• Le rôle d’une expression est évaluée à une seule

valeur.

double: faire les calculs indiqués

par les éléments de l’expression et
retourner le résultat du calcul.
"& POO JAVA: GI2
 EXPRESSIONS
Quelques examples d’expressions
• a=b+c
• System.out.println(“Bonjour”)
• Character.isJavaIdentifierPart( ch )
• a++
• ch = str.charAt(0)
"' POO JAVA: GI2
 EVALUATION DES
EXPRESSIONS
l’opérande a gauche est évalué en premier :
• int a=5;
• a= (a=10)+a;
• System.out.println(a)
• a+=(a=10);
"(
• System.out.println(a)
POO JAVA: GI2
 VALEUR D’UNE
EXPRESSIONS
Expression Action Valeure Retournée

ch = ‘a’ affecte le charactere ‘a' à la variable ch la valeur de ch après

affectation de (‘a’)
Chaque expression
“La valeur MAX d’un Concatène la chaîne de caractères "La La chaîne de caractères :
réalisé une
type short est " + valeur MAX d’un type short est " et La valeur MAX d’un operation et
Short.MAX_VALUE la valeur de Short.MAX_VALUE type short est 32767
après conversion au type string
retourne une
valeur.

Character.isJavaIdentifi Appelle la méthode .isJavaIdentifierPart La valeure retournée par

erPart(ch) la méthode : true

")
& POO JAVA: GI2
 LES INSTRUCTIONS
Les instructions sont équivalentes aux phrases dans
les langages naturelles.
Une instruction forme une unité complète
d’exécution. Il y’a trois types d’instructions:
• Les instructions d’expressions
• Les instructions de déclarations
• Les instructions de contrôle de flux
#* POO JAVA: GI2
 INSTRUCTIONS
D’EXPRESSIONS
Toute expression terminée par un point virgule est une instruction d’expression.

Exemples :

• aValue = 8933.234; // instruction d’affectation

• aValue++; // instruction d’incrémentation

• System.out.println(aValue); //appel de méthode

• Integer integerObject = new Integer(4); // instruction d’instantiation

#! POO JAVA: GI2

 INSTRUCTIONS DE
DECLARATION
Une instruction de declaration permet de declarer une variable de type primitif
ou de type reference.

Exemples :

• int somme;

• char uneLettre;

• Voiture voiture;

• Object obj;

#" POO JAVA: GI2

 INSTRUCTIONS DE CONTRÔLE DE
FLOT D’EXÉCUTION
• if

• if-else

• switch

• boucles : for, while et do-while

• break

• continue

• try-catch-finally

• return

## POO JAVA: GI2

 IF - ELSE
La syntaxe générale :
if (expression booléenne) {
bloc1 }
else {
bloc2
}
La condition doit être évaluable en true ou false et elle est obligatoirement
entourée de parenthèses.
La partie commençant par else est facultative.
Les points-virgules sont obligatoires après chaque instruction et interdits après }.
Si un bloc ne comporte qu'une seule instruction, les accolades qui l'entourent
peuvent être omises.

#$ POO JAVA: GI2

 SINON PENDANT
‘DANGLING ELSE’

#% POO JAVA: GI2

 L'OPÉRATEUR TERNAIRE
( ) ? ... : ...

• int a=5, b=20, max;

• max = (a>b)?a:b ;
• System.out.println(max);

#& POO JAVA: GI2

 SWITCH
La syntaxe générale :
switch (expression entière ou caractère ou chaine de caractère ou
Enumeration) {
case i:
case j:
[bloc d'instructions]
break;
case k :
........
default:
}
Rq:
Le type de la variable d'une instruction case doit être char, byte, short,
int, String ou Enum.

#' POO JAVA: GI2

 SWITCH

#( POO JAVA: GI2

 SWITCH

#) POO JAVA: GI2

 BOUCLE FOR
Syntaxe Générale :
for ( liste expressions1; Expression
logique ; liste expressions3){
bloc
}
C'est la boucle contrôlée, utilisée
pour répéter N fois un même
bloc d'instructions
liste expressions1 précise la valeur
initiale des variables de
contrôle (ou compteurs)
Expression logique, la condition à
satisfaire pour rester dans la
boucle
liste expressions3, une liste
d’actions à réaliser à la fin
de chaque boucle (en
général, l'actualisation des
compteurs).
$* POO JAVA: GI2
 BOUCLE WHILE
L'itération while

int max = 100, i = 0, somme = 0; while (expression) {

bloc
while (i <= max) {
}
somme += i; // somme = somme + i
Elle permet de répéter un bloc
i++ ; d'instructions TANT QUE la
} condition est vraie.
La sortie de boucle est
effectuée aussitôt que la
Attention de ne pas mettre de point virgule après la condition est évalué fausse.
condition. Le test de cette condition est
vérifié au début de chaque
C’est une erreur non détectable par le compilateur mais boucle, si bien que le bloc
affecte la sémantique du programme. peut ne pas être exécuté.

$! POO JAVA: GI2

 BOUCLE DO-WHILE
int i = 100, j = 0, somme = 0 ;
do{ Cette structure est très proche de
somme += j; la structure while. Sa syntaxe
est :
j++;}
do{
while (j <= i); //Si oublié génère une erreur de instructions;}
compilation while (condition);
A la sortie de la boucle, la variable somme contient Dans cette boucle
faire_tant_que, la condition
la somme des 100 premiers entiers.
est évaluée après l’exécution
du corps de la boucle. Elle est
au minimum exécutée une fois
même si la condition à tester
est fausse au départ

$" POO JAVA: GI2

 INSTRUCTIONS DE
RUPTURE DE BOUCLE
Pas de goto; en Java .. mais il existe des moyens pour sortir ou effectuer
des "sauts" en rompant le cours normal d'une itération. Avec les
instructions
break [label] :on quitte définitivement le bloc courant (et on passe à la
suite).
continue [label] : on saute les instructions du bloc situés à la suite (et on
passe à l'itération suivante).
Si on indique break [label], ou continue [label], où label est une étiquette qui
marque un endroit dans le code, le saut s'effectue relativement au bloc
marqué par l'étiquette.

$# POO JAVA: GI2

 BREAK
■ L’instruction break a deux
formes: avec un label ou
sans label, on a déjà vu
la forme sans label avec
switch. Dans ce cas
break termine
l’instruction switch et
transfert le flux de
contrôle immédiatement
à l’instruction qui suit
switch
■ Vous pouvez aussi utiliser
l’instruction break pour
terminer une boucle for,
while ou do-while. Le
programme suivant
BreakDemo contient une
boucle for qui permet de
$$ POO JAVA: GI2 calculer la somme des
produits achetés .
 BREAK AVEC ÉTIQUETTE

$% POO JAVA: GI2

 CONTINUE
Cette instruction modifie aussi le
déroulement normal d’une boucle. Elle
permet de sauter les instructions qui
suivent continue et de redémarrer le
flot d'instructions au niveau de
l’évaluation de la condition de la
boucle.
Contrairement à l’instruction break qui
fait quitter la boucle, on saute les
instructions qui suivent continue puis
on continue l’exécution de l’itération.
L’instruction continue peut aussi se
combiner avec une étiquette.

$& POO JAVA: GI2

 TRY-CATCH-FINALLY

$' POO JAVA: GI2

 RETURN
Cette instruction termine immédiatement l’exécution des méthodes. On
peut donc considérer que c’est aussi une instruction de contrôle.
Le flux de contrôle est transféré à l’instruction qui suit immédiatement
l’appel de la méthode. L’instruction return a deux formes : une forme qui
retourne une valeur et une autre qui ne retourne aucune valeur. Pour
retourner une valeur vous pouvez tout simplement placer la valeur (ou
l’expression qui calcul cette valeur) après le mot clés return; le type de
données de la valeur retournée doit correspondre au type de la méthode
lors de la déclaration. Lorsque la méthode est déclarée de type void,
utilisez tout simplement return;

$( POO JAVA: GI2

 CONCLUSION
Dans ce chapitre on a présenté les elements de base du
langage JAVA :

Les Variables de types primitifs et références

Les opérateurs (arithmétiques, logiques, décalage de bits )

Les expressions

Les instructions

de déclaration

d’expression

de contrôle de flot d’executions

$) POO JAVA: GI2