Opérateurs

Les opérateurs servent à former des expressions plus complexes.

Pour chaque opérateur, Java définit

• le nombre d'arguments (opérandes)
  les opérateurs unaires ont un argument et les opérateurs binaires ont deux arguments
• les types des arguments
• le type du résultat

Les opérateurs arithmétiques

Exemple :

public class TestOperateurs  {

  public static void main( String [] args ) {

    int i = 10;
    int j = 3;
    int resultat;
    float f = 10;
    float resultatFloat;
    double d = 10;
    double resultatDouble;

    resultat = i + j;    // Calcule 13
    System.out.println( i + "+" + j + " == " + resultat );

    resultat = i - j;    // Calcule 7
    System.out.println( i + "-" + j + " == " + resultat );

    resultat = i * j;    // Calcule 30
    System.out.println( i + "*" + j + " == " + resultat );

    resultat = i / j;    // Calcule 3
    System.out.println( i + "/" + j + " == " + resultat );

    resultat = i % j;    // Calcule 1
    System.out.println( i + "%" + j + " == " + resultat );

    resultatFloat = f / j;    // Calcule 3.3333333
    System.out.println( f + "/" + j + " == " + resultatFloat );

    resultatDouble = d / j;    // Calcule 3.3333333333333335
    System.out.println( d + "/" + j + " == " + resultatDouble );

  }

}

Exemple :

int total = 763;           // cents
int dollars = total / 100; // = 7
int cents = total % 100;   // = 63
System.out.println("total = " + dollars + "." + cents + "$"); // "total = 7.63$"

Bonne pratique de la programmation

Le caractère espace autour des opérateurs (sauf + et - unaires).

Exemple :

j = -7 + 2 * (-i)

Priorité (précédence) des opérateurs

1. unaires +, - (par exemple, -7)
2. *, /, %
3. binaires +, -

Les opérateurs numériques ayant la même priorité sont évalués de gauche à droite.

Les parenthèses peuvent être utilisées pour changer l'ordre de l'évaluation.

Exemple :

Les expressions mixtes

• le résultat est double si n'importe quel opérande est double
• le résultat est float si un opérande est float et l'autre n'est pas double
• le résultat est int si chaque opérande est int, short ou byte
• le résultat est long si un opérande est long et l'autre est entier

Les classes Float et Double contiennent deux constantes Float.POSITIVE_INFINITY et Float.NEGATIVE_INFINITY qui représentent le résultat de la division par zéro en virgule flottante.

Exemple :

Soit les déclarations suivantes :
int i = 10;
float f = 1/3;
double d = 1/3.0;
byte b = 100;
short sh = 1000;
long ll = 100;

Opérateurs arithmétiques et affectation combinés

• n'est pas plus efficace à exécuter
• plus concise

Les opérateurs de transtypage ("cast operators")

Le transtypage (ou cast) est la conversion d'une expression d'un certain type en une expression d'un autre type.

• une perte d'information possible; exemple : float -> int

Transtypage de données de types primitifs

• une conversion implicite possible s'il n'y a pas de perte d'information;
  on passe d'un type "plus petit" vers un type "plus grand"
  Exemples :

  int i;
  short s;
  long l;
  byte b;
  float f;
  double d;
    ...
  // les instructions suivantes sont valides
  l = i = s = b;
  i = b;
  d = i;
  d = f = s;
  

• une conversion explicite nécessaire s'il y a une perte d'information;
  variable_de_nouveau_type = (nouveau_type)expression_a_convertir;

  int i;
  short s;
  ...
  s = (short)i;
    

Transtypage de référence d'objet

• le transtypage implicite vers un type ancêtre

  Exemples :

  class Forme { }
  class Quadrilatere extends Forme {  }
  class Losange extends Quadrilatere {  }
  class Carre extends Losange {  }
  class Cercle extends Forme {  }
  class Triangle extends Forme {  }
    ...
  // les instructions suivantes sont valides
  Quadrilatere q = new Carre();
  Forme f1 = new Losange();
  Forme f2 = new Triangle();
  

• le transtypage explicite vers un type dérivé

  Exemple :

  Forme f1 = new Quadrilatere();
  ...
  q = (Quadrilatere)f1;
  

  Attention : f1 doit être un Quadrilatere !
• certains transtypages ne sont pas possibles

      Triangle tr = new Triangle();
      Losange los = new Losange();
      los = (Losange)tr;
  

Opérateurs relationnels

Les opérateurs relationnels sont des opérateurs qui retournent un résultat de type boolean. Ils évaluent les rapports entre les valeurs des opérandes. Une expression relationnelle renvoie true si le rapport est vrai, false dans le cas opposé.

Les opérateurs sur les chaînes de caractères

• opérateur de concaténation : +
• conversion à String est forcée si n'importe quel opérande est String
• la classe String contient plusieurs méthodes : length, substring, toLowerCase, ...
• les éléments de chaînes de caractères sont indexés
• le premier caractère a l'indice 0

Exemples :

Méthode equals

La méthode equals appartient à la classe Object et toutes les autres classes en héritent.

Voici sa définition initiale qui compare les références :

public boolean equals(Object obj) {
  return (this == obj) ;
}

equals se comporte exactement comme ==. Dans la plus part des classes la méthode est redéfinie pour qu’elle compare les contenus des objets plutôt que leurs références.

Exemple :

String s1 = "INF1563";
String s2 = "INF1563";
System.out.println(s1 == s2);         // true
System.out.println(s1.equals(s2));    // true

String s3 = "INF";
String s4 = s1.substring(0, 3);       // "INF"
System.out.println(s3 == s4);         // false
System.out.println("INF".equals(s4)); // true

Les opérateurs logiques

Les opérateurs logiques acceptent obligatoirement des opérandes booléennes et calculent un résultat booléen.

Une évaluation partielle possible

• l’évaluation des expressions logiques est arrêtée dès lors que le résultat est déterminé;
  exemple : expression_vraie || expression_quelconque
• l’évaluation partielle optimise le code mais peut avoir des effets indésirables

Quiz

Trouvez les valeurs des expressions ci-dessous :

"INF" + 15 + 63

!faux || faux

(int)(1.2 + 0.5)