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 superflues 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 flottantes 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 final 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 float. Le résultat est de type float.
  • 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 float. Le résultat est de type float. Pour pouvoir lui ajouter la valeur de b1, on soumet cette dernière à une conversion d’ajustement de type de byte en float (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 float). Le résultat est de type float.
  • 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 float). Le résultat est de type double. Il est divisé par la valeur obtenue par conversion d’ajustement de type de x de float 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 float. La même démarche s’applique, en substituant le type float au type double. Le résultat final est de type float.


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 flottants ne conduit à un arrêt de l’exécution. En revanche, les nombres flottants respectent les conventions IEEE 754 qui imposent l’existence d’un motif particulier représentant les valeurs infinies, lequel s’imprime sous la forme Infinity ou -Infinity. Les constantes correspondantes se notent Float.Infinity ou Double.Infinity.

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).

Article plus récent Article plus ancien

Leave a Reply

Telechargement