Java
Les Opérateurs et les Expressions
Ahcène Bounceur
Pour commencer
i = 5 ;
◦ i est égal à 5
++i
◦ i est augmenté de 1
◦ i est égal à 6
k = i = 5 ;
◦ Équivalent à : k = (i = 5)
◦ Ça veut dire : on affecte la valeur 5 à i et puis on affecte la valeur de i à k ;
◦ Donc : k est égal à 5
Pour commencer
Toutes ces lignes s'appellent :
◦ Des exressions
◦ Elles ne sont pas des instructions !
Math.sqrt(5) ;
◦ Permet de calculer la racine carrée de 5
◦ Écrit tout seul ne produit pas une erreur de compilation mais il ne sert à rien
Les opérateur arithmétiques
Les opérateurs classiques binaires :
◦ + (addition)
◦ – (soustraction)
◦ * (multiplication)
◦ / (division)
Les opérateurs classiques unaires
◦ +n
◦ –n
◦ –(n+b)
Les opérateur arithmétiques
L'opéprateur %
◦ S'utilise avec des entiers ou des flottants :
◦ Il fournit le reste de la division entière de son premier opérande par son second
11%4 vaut 3
23%6 vaut 5
-11%3 vaut -2
-11%-3 vaut -2
12.5%3.5 vaut environ 3
-15.2%7.5 vaut environ -0.2
Les opérateur arithmétiques
Remarque :
◦ Le quotient de deux entiers fournit un entier
5/2 vaut 2
◦ Le quotient de deux flottant est un flottant
5.0/2.0 vaut environ 2.5
◦ x² : x*x
◦ x² : Math.pow(x,2)
La priorité relatives des opérateurs
Les opérateurs unaires
*, / et %
+ et –
En cas de priorité identique : le calcul s'effectue de gauche à droite
Pour imposer une priorité, il faut utiliser les
parenthèses
La priorité relatives des opérateurs
Exemples :
Expression Priorités
a + b * c a + ( b * c )
a * b + c % d ( a * b ) + ( c % d )
– c % d ( – c ) % d
– a + c % d ( – a ) + ( c % d )
– a / – b + c ( ( – a ) / ( – b ) ) + c – a / – ( b + c ) ( – a ) / ( – ( b + c ) )
Comportement en cas d’exception
Cas des entiers
◦ Division par zéro
Déclenche une exception :
Exception in thread "main" java.lang.ArithmeticException: / by zero at Test.main(Test.java:9)
Comportement en cas d’exception
Cas des flottants
◦ Les opérations sur les flottants ne provoqueront aucune exception
◦ Par contre les résultats retournée montre la nature du problème
◦ Exemple :
1e30 * 1e30 = Infinity
Infinity/0.0 = Infinity
15/0.0 = Infinity
Infinity/–Infinity = NaN (Non a Number)
Comportement en cas d’exception
Cas des flottants
◦ Affecter les infinis :
Float.POSITIVE_INFINITY ; // +
Double.POSITIVE_INFINITY ; // +
Float.NEGATIVE_INFINITY ; // –
Double.NEGATIVE_INFINITY ; // –
◦ Affecter les Nan :
Float.NaN
Double.NaN
Les conversions implicites
int n ;
int p ;
float x;
n * x + p
◦ n * x : int * float = float
◦ (n*x)+p : (float)+int = float
◦ n * x + p : float
Conversions d’ajustement
int long float double
Exemple :
int n ;
long p ;
float x;
n * x + p
◦ n * x : int * long = long
◦ (n*x)+p : long + float = float
◦ n * x + p : float
Le cas du type char
Un char est codé sur 1 octet (7 bits)
◦ Il peut être utilsé pour représenter un caractère
◦ Il peut être utilisé aussi pour représenter un nombre
Conversion d'ajustement
char int
Les opérateurs relationnels
Exemple :
◦ 2 * a > b + 5
◦ Elle peut être utilisée dans une instruction if :
if (2 * a > b + 5) …
◦ Elle peut être affectée à une variable boolénne :
boolean ok;
…
ok = 2 * a > b + 5
Les opérateurs relationnels
La liste des opérateurs
Opérateur Signification
<
<=
>
>=
==
!=
inférieur à
inférieur ou égal à supérieur à
supérieur ou égal à égal à
différent de
Les opérateurs relationnels
Les priorités :
◦ La priorité des opérateurs relationnels vient après celle des opérateurs arithmétiques
◦ (<, <=, >, >=) : ils ont la même priorité
◦ (== et !=) : ils ont la même priorité
Ainsi :
◦ x + y < a + 2 (x + y) < (a + 2)
Les opérateurs relationnels
Cas de infinity et Nan
double x = 5e22
if (x < Double.POSITIVE_INFINITY) … if (x < Float.POSITIVE_INFINITY) …
◦ Tous les deux sont justes.
◦ Dans la deuxième instruction le
Float.POSITIVE_INFINITY est convertie Double.POSITIVE_INFINITY
Les opérateurs relationnels
Cas des caractères
◦ Les caractères sont comparés par rapport à leur code
◦ On peut écrire :
c1 == c2
c1 == 'e'
c1 == 120
◦ L'utilisation d'unicode implique les relations suivantes :
'0'<'1'<…<‘9’<‘A’<‘B’<…<‘Z’<‘a’<‘b’<…<‘z’
Les opérateurs logiques
La liste des opérateurs logiques
Différence entre & et &&
Supposons que la condition (i<max) est vérifiée, alors : if (i < max && t[i++] != 0) … // i sera incrémenté if (i < max & t[i++] != 0) … // i ne sera pas incrémenté
Opérateur Signification
!
&
^
|
&&
||
Négation Et
Ou exclusif Ou inclusif
Et (avec court-circuit)
Ou inclusif (avec court-circuit)
Les opérateurs logiques
Priorités :
◦ Le ! est prioritaire
◦ Exemple :
! a == b
est équivalent à :
(! a) == b
Le || est moins prioritaire que le &&
Le && est moins prioritaire que le &
Ce qui donne les priorités suivantes :
◦ ! > & > ^ > | > && > ||
L’opérateur d’affectation =
Le = est le moins prioritaire de tous les autres opérateurs
◦ Donc : x = a + 3 equivaut à x = (a+3)
i = j = 5 équivaut à :
◦ j = 5
◦ i = j
◦ Attention : le = possède une associativité de droite à gauche
L’opérateur d’affectation =
La conversion par affectation :
◦ byte short int long float double
◦ char int long float double
Attention :
◦ Les autres conversions ne sont pas possibles
Exemple : char short
Incrémentation et décrémentation
i = i + 1
n = n – 1
++i
Si (i = 5) alors
◦ n = ++i – 5
n = (6 – 5) = 1
++i = 6 ensuite i = 6
◦ n = i++ – 5
n = (5 – 5) = 0
i++ = 5 ensuite i = 6
Incrémentation et décrémentation
++
◦ placé à gauche : opérateur de préincrémentation
◦ placé à droite : opérateur de postcrémentation
--
◦ placé à gauche : opérateur de prédécrémentation
◦ placé à droite : opérateur de postdécrémentation
Incrémentation et décrémentation
t [i++] = 5
◦ Si i = 3
t [3] = 5
i = 4
Attention :
◦ byte b ;
◦ b = b + 1 ; // erreur de compilation (parce que b+1 est un entier)
◦ b++ ; // juste
◦ b = (byte) (b + 1) ; // juste (cast)
Même remarque pour le type char
Affectation élargie
i = i + 1
◦ i++
i = i + k
◦ i += k
a = a + b
◦ a *= b
Toutes les affectations élargies :
+= -= *= /= %= |= ^=
&= <<= >>= >>>=
Affectation élargie
Attention !
◦ <= ou >= ne sont pas des affectation élargies
<= inférieur ou égtal
>= supérieur ou égtal
Incrémentation et décrémentation
Attention !
◦ byte b ;
◦ b = b + 3 ; // erreur de compilation
(parce que b+3 est un entier)
◦ b+=3 ; // juste
◦ b = (byte) (b + 3) ; // juste (cast)
Même remarque pour le type char
L’opérateur de cast
L'opérateur de cast est utilisé pour forcer la conversion d'une expression quelconque
dans un type de son choix
Si n et p sont deux entiers, l'expression
(double) (n/p)
aura comme valeur celle de l'expression entière (n/p) convertit en double
Les opérateurs de manipulation de bits
Travailler directemetn sur le motif binaire d'une valeur
Opérateur Signification
&
|
^
<<
>>
>>>
~ (uniaire)
Et (bit à bit)
Ou inclusif (bit à bit) Ou exclusif (bit à bit) Décalage à gauche
Décalage arithmétique à droite Décalage logique à droite
Complément
Les opérateurs de manipulation de bits
Les opérateuirs bit à bit :
◦ Soient les deux opérandes suivants :
o1 = 0 0 0 0 0 0 1 1
o2 = 0 0 0 0 0 1 0 1
o1 & o2 = 0 0 0 0 0 0 0 1
o1 | o2 = 0 0 0 0 0 1 1 1
o1 ^ o2 = 0 0 0 0 0 1 1 0
~o2 = 1 1 1 1 1 0 1 0
Les opérateurs de manipulation de bits
Les opérateuirs bit à bit :
◦ Soient les deux opérandes suivants :
n1 = 0 0 1 1 1 0 1 1
n1 << 2 1 1 1 0 1 1 0 0
n1 >> 3 0 0 0 0 0 1 1 1
n1 >>> 3 0 0 0 0 0 1 1 1
n2 = 1 1 1 0 1 1 0 0
n2 << 2 1 0 1 1 0 0 0 0
n2 >> 3 1 1 1 1 1 1 0 1
n2 >>> 3 0 0 0 1 1 1 0 1
L’opérateur conditionnel
if (a > b)
max = a ;
else
max = b;
On peut l'écrire comme suit :
max = (a>b) ? a : b ;
L’opérateur conditionnel
Exemples :
◦ 3*a+1>0 ? 3*a+1 : -3*a-1
◦ z = ( a>b ? a : b ) ;
◦ a>b ? : i++ ; i-- ;
Récapitulatif des priorités
Opérateurs Associativité
() [] . ++(postfixé) --(postfixé)
+(uniaire) --(uniaire) ++(préfixé) --(préfixé)
~(unaire) ! cast new
* / %
+ -
<< >> >>>
< <= > >= instanceof
== !=
&
^
|
&&
||
?:
= += -= *= /= %= <<= >>= >>>= &< |= ^=
