3.    Les expressions et les opérateurs


3.1    Type de résultat, transtypage.

            Fig. 3.1. Transtypage automatique autorisé en Java

public class Oper {
    public static void main(String arg[]){
        int k,i1=4, i2 = 5;
        double f1 =5.0;
        k= i1/i2 +i1/f2;
    }
}
•    L'expression i1/i2 se fait sans transtypage est le résultat est 0
•    Dans l'expression i1/f2, i1 est convertis en double est le résultat est 0.8
•    Le résultat final est de type double

transtypage explicite (caste)
int i = (int)56.4;            byte sh = (byte)456;

public class Oper {
    public static void main(String arg[]){
        int in;
        long ln=123L;
        double db = 34.5;
        in = ln;        //type mismatch
        in = db;        //type mismatch
        in = (int)ln;    //ok
        in = (int)db;    //ok
    }
}

public class Oper {
    public static void main(String arg[]){
        byte b1,b2=2,b3=3;
        b1 = 5;                //ok!
        b1 = b2+b3;            // type mismatch
        b1 = (byte)(b2+b3);    //ok!
        b1=130;                //type mismatch
        b1=(byte)130;        //ok!
    }
}


3.2    La priorité et l'associativité des opérateurs

Opérateurs

Associativité

()   []   .   ++(postfixé)   --(postfixé)

––>

+(unaire)   -(unaire)   ++(préfixé)   --(préfixé)   ~   !  cast new

<––

*   /  %

––>

+  -

––>

<<    >>    >>>

––>

<    <=    >    >=    instanceof

––>

==    !=

––>

&

––>

^

––>

|

––>

&&

––>

||

––>

?:

––>

=  +=  -=  *=  /=  %=  <<=  >>=  >>>=  &=  |=  ^=

<––


Tab. 3.1. Les opérateurs de Java et leurs priorités

3.3    Les opérateurs arithmétiques
•    +    addition;
•    -    soustraction,
•    *    multiplication,
•    /    division.

public class Oper {
    public static void main(String arg[]){
        System.out.println("11%4:\t"+11%4);
        System.out.println("23%6:\t"+23%6);
        System.out.println("-11%3:\t "+ -11%3);
        System.out.println("12.5%3.5:\t "+12.5%3.5);
        System.out.println("-15.2%7.5:\t "+-15.2%7.5);
    }
}

public class Oper {
    public static void main(String arg[]){
        float x = 1e30f ;
        float y ;
        y = x*x ;
        System.out.println (x + " a pour carre : " + y) ;
        float zero = 0.f ; // division flottante par zero
        float z = y/zero ;
        System.out.println (y + " divise par 0 = " + z) ;
        System.out.println("l'oppose de " + y + " = "+ -y);
        float z1 = z/y ;
        System.out.println (z + "/" + y + " = " + z1) ;
    }
}

opérateurs d’incrémentation (++ et --)

public class Oper {
    public static void main(String arg[]){
        int k, m=3;
        k = m++;    //m vaut 4,  k vaut 3 - valeur ancienne
        m=3;
        k = ++m;    //m vaut 4,    k vaut 4 - valeur novelle
        m=3;
        k = m--;    //m vaut 2,  k vaut 3 - valeur ancienne
        m=3;
        k = --m;    //m vaut 2,    k vaut 2 - valeur novelle   
        k= (m++)++;    //erreur!     m++ n'est pas constante
    }
}

L’opérateur d’affectation (=)

public class Oper {
    public static void main(String arg[]){
        int k, m=3,z=4,p;
        p = k =(m = 2) *(z = 4);    //m vaut 2
                                    //z vaut 4
                                    //k vaut 8
                                    //p vaut 8
        p = k = 2;                    //k vaut 2,  p vaut 2
        p = (k = 2);                //la même chose
        (p = k) = 2;                //erreur – l'opérande de gauche (p=k) est constante
    }
}

3.4    Les opérateurs de comparaisons logique

•    ==    Rend true si les deux opérandes sont égaux.
•    !=    Rend true si les deux opérandes sont différents.
•    <    Rend true si l'opérande de gauche est strictement inférieur à l'opérande de droite.
•    <=    Rend true si l'opérande de gauche est inférieur ou égal à l'opérande de droite.
•    >    Rend true si l'opérande de gauche est strictement supérieur à l'opérande de droite.
•    >=    Rend true si l'opérande de gauche est supérieur ou égal à l'opérande de droite.

public class Oper {
    public static void main(String arg[]){
        System.out.println("25>11:"+(25>11)+ "\t17<=8: "+(17<=8));
    }
}

3.5    Opérateurs logiques sur des booléens

•    &&    Opérateur ET (AND). Le résultat est true, si les deux opérandes ont la valeur true.
•    ||    Opérateur OU (OR). Le résultat est true, si l'un des deux opérandes a la valeur true.
•    !    Opérateur NON (NOT). Le résultat est true si le seul opérande a la valeur false.

public class Oper {
    public static void main(String arg[]){
        boolean b1=true,b2=true,b3=false,b4=false;
        System.out.println("true && true: "+(b1&&b2)+ "\t true && false: "+(b1&&b3));
        System.out.println("true || false: "+(b1||b3)+ "\t false || false: "+(b3&&b4));
        System.out.println("!true: "+!b1+"\t !false: "+!b3);
    }
}

3.6    Opérateurs logiques bit à bit

•    &    Opérateur ET (AND).
•    |    Opérateur OU (OR).
•    ~    Opérateur NON (NOT).
•    >>    Décalage arithmétique à droite. 
•    >>>    Décalage logique à droite. Le signe de l'opérande de gauche n'est pas gardé. On introduit toujours un zéro à gauche.
•    <<    Décalage à gauche. C'est une multiplication par 2

public class Oper {
    public static void main(String arg[]){
        System.out.println("7&8: "+(7&8)+"\t7|8: "+(7|8));
        System.out.println("~7: "+ (~7));
        System.out.println("7 << 2: "+(7 << 2));
        System.out.println("-7 >> 2: "+(-7 >> 2)+"\t -7 >>> 2: "+(-7 >>> 2));       
    }
}

3.7    Opérateur ternaire

public class Oper {
    public static void main(String arg[]){
        int res,a=4, b=9;
        res = a>b?a:b;
    }
}