numeric_expression

numeric_expression 
      ::= 
      ( ( "-" 
      | "++" 
      | "--" ) 
      expression ) 
      | ( expression 
      ( "++" 
      | "--" ) ) 
      | ( expression 
      ( "+" 
      | "+=" 
      | "-" 
      | "-=" 
      | "*" 
      | "*=" 
      | "/" 
      | "/=" 
      | "%" 
      | "%=" ) 
      expression ) 

This rule is called by

-> expression

Explications

Opération unaires

Des explications et des exemples d'utilisation concernant l'incrémentation et la décrémentation sont disponibles ici.

Opérations

Opération avec affectation

Lorsque l'on effectue des opérations sur des variables de types différents, le type du résultat est celui de l'opérande occupant le plus de place en mémoire. Cela peut être un type plus précis, ou un type permettant de stocker une valeur plus grande. Par exemple, lors d'une opération entre un float et un double, le résultat sera de type double.

Priorité des opérations

Attention !

Les opérations mathématiques en virgule flottante ne génèrent pas d'exceptions même dans le cas d'une division par zéro. Le résultat de 0.0/0.0 sera NaN (not a number). Il faudra utiliser la méthode statique Float.isNaN(float) ou Double.isNaN(double) pour tester le résultat d'une division. Attention : la constante Float.NaN n'est pas égale à un nombre dont la valeur est NaN, ni même à elle même. Ainsi, le test Float.NaN == Float.NaN retournera false !

De même, si on divise un nombre positif ou négatif par 0.0, le résultat sera l'infini positif, respectivement négatif. On peut utiliser la méthode statique Float.isInfinite(float), pour tester si le nombre est infini (positif ou négatif). On peut également comparer le résultat à Float.POSITIVE_INFINITY ou à Float.NEGATIVE_INFINITY (idem pour la classe Double si les variables sont de type double).

Exemple

class exNaN {

    public static void main (String args[]) {
        
        int resEntier,diviseurE = 0;
        float resFlottant,diviseurF = 0.0f;
        
        try {
            resEntier = 5/diviseurE;
            System.out.println("la division par zero entiere ne genere pas d'exception");
            System.out.println("Resultat : "+resEntier);
        } catch (ArithmeticException e) {
            System.out.println("la division par zero entiere genere une exception : "+e.getMessage());
        }
        
        try {
            resFlottant = -5.0f/diviseurF;
            System.out.println("la division par zero flottante ne genere pas d'exception");
            System.out.println("Resultat -5.0/0.0 = "+resFlottant);
            if (Float.isInfinite(resFlottant))
                System.out.println("Infini");
            if (resFlottant == Float.POSITIVE_INFINITY)
                System.out.println("posinf");
            else if (resFlottant == Float.NEGATIVE_INFINITY)
                System.out.println("neginf");
        } catch (ArithmeticException e) {
            // ce n'est jamais le cas !
            System.out.println("la division par zero flottante genere une exception : "+e.getMessage());
        }
    }
}

Exécution

la division par zero entiere genere une exception : / by zero
la division par zero flottante ne genere pas d'exception
Resultat -5.0/0.0 = -Inf
Infini
neginf

© 1996, DIP Genève, Alexandre Maret & Jacques Guyot

page générée Fri Jun 21 15:41:07 MET DST 1996