Exercices Corriges JAVA : Niveau debutant TP java avec solution les bases

Exercice 1 : Priorités des opérateurs arithmétiques et parenthèses en JAVA

Éliminer les parenthèses superﬂues dans les expressions suivantes (l’ordre des calculs devant rester le même) :

(a + b) - (2 * c) // expression 1
(2 * x) / (y * z) // expression 2
(x + 3) * (n%p) // expression 3
(-a) / (-(b + c)) // expression 4
(x/y)%(-z) // expression 5
x/(y%(-z)) // expression 6

Exercice 2 : Conversions implicites En JAVA

Soit ces déclarations :

byte b1 = 10, b2 = 20 ;
short p = 200 ;
int n = 500 ;
long q = 100 ;
float x = 2.5f ;
double y = 5.25 ;

Donner le type et la valeur des expressions arithmétiques suivantes :

b1+b2 // 1
p+b1 // 2
b1*b2 // 3
q+p*(b1+b2); // 4
x+q*n // 5
b1*q/x // 6
b1*q*2./x // 7
b1*q*2.f/x // 8

Exercice 3 : Exceptions ﬂottantes et conventions IEEE 754

Quels résultats fournit ce programme ?

public class Excep

{ public static void main (String args[])

{ double x1 = 1e200, x2 = 1e210 ;

double y, z ;

y = x1*x2 ;

System.out.println ("valeur de y " + y) ;

x2 = x1 ;

z = y/(x2-x1) ;

System.out.println (y + " divise par " + (x2-x1) + " = " + z) ;

y = 15 ;

z = y/(x2-x1) ;

System.out.println (y + " divise par " + (x2-x1) + " = " + z) ;

z = (x2-x1)/(x2-x1) ;

System.out.println ((x2-x1) + " divise par " + (x2-x1) + " = " + z) ;

System.out.println (z + "+1 = " + (z+1)) ;

x1 = Float.POSITIVE_INFINITY ;

x2 = Double.NEGATIVE_INFINITY ;

z = x1/x2 ;

System.out.println (x1 + "/" + x2 + " = " + z) ;

}

Exercice 4 : Le type char en JAVA

Soit ces déclarations :

char c = 60, ce = 'e', cg = 'g' ;
byte b = 10 ;

Donner le type et la valeur des expressions suivantes :

c + 1
2 * c
cg - ce
b * c

------------------------------------------------------------------------------------------

Correction des Exercices - Solution des TP JAVA

------------------------------------------------------------------------------------------

Solution Exercice 1 :

a + b - 2 * c // expression 1
2 * x / (y * z) // expression 2

On pourrait aussi écrire cette expression 2*x/y/z mais l’ordre des calculs sera différent, ce qui peut avoir une légère incidence sur le résultat.

(x + 3) * (n%p) // expression 3

Ici aucune parenthèse ne peut être supprimée car * et % sont de même priorité ; la suppression de la seconde paire de parenthèses conduirait à une expression équivalent à : ((x+3)*n)%p.

-a / -(b + c) // expression 4

Ne pas oublier que l’opérateur unaire - est prioritaire sur tous les opérateurs arithmétiques à deux opérandes.

x/y%-z // expression 5
x/(y%-z) // expression 6

Solution Exercice 2 :

b1+b2 = 30 // 1

L’opérateur + soumet les valeurs de b1 et b2 à la promotion numérique de byte en int. Le résutat est de type int.

p+b1 = 210 // 2

L’opérateur + soumet ses opérandes à des promotions numériques : de short en int pour p et de byte en int pour b1. Le résultat est de type int.

b1*b2 = 200 // 3

Là encore, avant d’effectuer le produit, les valeurs de b1 et de b2 sont soumises à la promotion numérique de byte en int. Le résultat est de type int.

q+p*(b1+b2) = 6100 // 4

On évalue tout d’abord la somme s=b1+b2, en soumettant les valeurs des deux opérandes aux promotions numériques de byte en int. La valeur de s est de type int. Puis on effectue la somme q+p en soumettant le second opérande à une conversion d’ajustement de type de short en long (type de q). Le résultat est de type long. Il faut maintenant le multiplier par s, ce qui se fait en soumettant la valeur de s à une conversion d’ajustement de type de int en long. Le résultat ﬁnal est de type long.

x+q*n =50002.5 // 5

On évalue tout d’abord le produit q*n en soumettant la valeur de n à une conversion d’ajustement de type de int en long. Le résultat est de type long. Pour pouvoir l’ajouter à la valeur de x, on le soumet à une conversion d’ajustement de type de long en ﬂoat. Le résultat est de type ﬂoat.

b1*q/x=400.0 // 6

On évalue tout d’abord le quotient q/x en soumettant la valeur de q à une conversion d’ajustement de type de long en ﬂoat. Le résultat est de type ﬂoat. Pour pouvoir lui ajouter la valeur de b1, on soumet cette dernière à une conversion d’ajustement de type de byte en ﬂoat (ou, ce qui revient au même, d’abord à une promotion numérique de byte en int, puis à une conversion d’ajustement de type de int en ﬂoat). Le résultat est de type ﬂoat.

b1*q*2./x=800.0 // 7

On évalue tout d’abord le produit q*2., en soumettant la valeur de q à une conversion d’ajustement de type de long en double (attention, la constante 2. est de type double et non de type ﬂoat). Le résultat est de type double. Il est divisé par la valeur obtenue par conversion d’ajustement de type de x de ﬂoat en double. Le résultat, de type double est alors multiplié par la valeur obtenue par conversion d’ajustement de type de b1 en double. Le résultat est de type double.

b1*q*2.f/x=800.0 // 8

Il s’agit de l’expression précédente, dans laquelle la constante 2. (de type double) est remplacée par 2.f de type ﬂoat. La même démarche s’applique, en substituant le type ﬂoat au type double. Le résultat ﬁnal est de type ﬂoat.

Solution Exercice 3 :

Infinity divise par 0.0 = Infinity

15.0 divise par 0.0 = Infinity

0.0 divise par 0.0 = NaN

NaN+1 = NaN

Infinity/-Infinity = NaN

Rappelons qu’en Java aucune opération sur les ﬂottants ne conduit à un arrêt de l’exécution. En revanche, les nombres ﬂottants respectent les conventions IEEE 754 qui imposent l’existence d’un motif particulier représentant les valeurs inﬁnies, lequel s’imprime sous la forme Inﬁnity ou -Inﬁnity. Les constantes correspondantes se notent Float.Inﬁnity ou Double.Inﬁnity.

De même, il existe un motif particulier représentant une valeur non calculable ; il peut s’obtenir par Float.NaN ou Double.NaN et il s’imprime sous la forme NaN.

Solution Exercice 4 :

c + 1 = 61

L’opérateur + soumet ici son premier opérande à la promotion numérique de char en int, ce qui fournit la valeur 601

. Le résultat est de type int.

2 * c = 120

L’opérateur * soumet ici son second opérande à la promotion numérique de char en int, ce qui fournit la valeur 602

. Le résultat est de type int.

cg - ce = 2

L’opérateur - soumet ici ses deux opérandes à la promotion numérique de char en int. On obtient un résultat de type int qui représente l’écart entre les codes des caractères g et e (dans le code Unicode, les lettres consécutives d’une même casse ont des codes consécutifs).

b * c = 600

L’opérateur * soumet ici ses deux opérandes aux promotions numériques : de byte en int pour le premier, de char en int pour le second. On notera qu’aucun problème de dépassement de capacité n’apparaît puisque le produit est bien effectué dans le type int (il en irait différemment s’il était effectué dans le type byte puisque 600 n’est pas représentable dans ce type).