1. Opérations booléennes
Les opérateurs |et &peuvent être appliqués non seulement aux nombres, mais aussi aux expressions booléennes.
Mais, comme vous le savez déjà, il existe des opérateurs &&et ||. Pourquoi utiliserions-nous |au lieu de ||, et &au lieu de &&? Y a-t-il un intérêt à cela ? Il paraît qu'il y en a. Parfois.
Les opérateurs logiques ||et sont exécutés de gauche à droite selon un principe&& dit paresseux .
(expression1) || (expression2) || (expression3)Si expression1 est égal à true, il est inutile d'évaluer expression2 et expression3: le résultat sera trueindépendamment.
Par conséquent, lors de l'évaluation d'expressions (elles sont évaluées de gauche à droite), dès que nous obtenons true, l'évaluation du reste des expressions est ignorée . Et si expression2 et expression3incluent des appels de méthode, ces méthodes ne seront pas appelées !
Il en va de même pour l' &&opérateur logique :
(expression1) && (expression2) && (expression3)Si expression1est égal à false, il est inutile d'évaluer expression2et expression3: le résultat sera falseindépendamment.
C'est un fait important qui vous permet d'écrire des choses comme :
String s = null;
if (s != null && s.length() > 0) {L'exemple ci-dessus ne vous donnera jamais une NullPointerException , car s.length()ne sera exécuté que si la première partie s! = nullest true.
Si sest égal à null, la partie à gauche de l' &&opérateur est false, alors le résultat de l'expression booléenne entière est false, donc la partie à droite ( s.length() > 0) n'est pas évaluée.
Si vous utilisez l' |opérateur ou l' &opérateur, alors il n'y a pas d'évaluation paresseuse : chaque sous-expression sera toujours évaluée.
2. Priorité des opérations en Java
Comme vous vous en souvenez probablement de votre cours de mathématiques au lycée, l'opérateur de multiplication a une priorité plus élevée que l'opérateur d'addition. Les parenthèses ont une priorité encore plus élevée : les expressions entre parenthèses sont évaluées en premier, puis la multiplication et la division, puis l'addition et la soustraction.
Les opérateurs en Java ont également un ordre de priorité. La différence est que a) il y en a un peu plus, b) pour certains opérateurs, les opérandes sont évalués de gauche à droite, tandis que pour d'autres — de droite à gauche.
Voici un tableau avec tous les opérateurs Java :
| Catégorie | Opérateur | Associatif |
|---|---|---|
| Suffixe | () [] . |
De gauche à droite |
| Unaire | ++ -- ! ~ |
De droite à gauche |
| Multiplicatif | * / % |
De gauche à droite |
| Additif | + - |
De gauche à droite |
| Déplacement | >> >>> << |
De gauche à droite |
| Relationnel | > >= < <= |
De gauche à droite |
| Égalité | == != |
De gauche à droite |
Au niveau du bitAND |
& |
De gauche à droite |
Exclusive OR(XOR) |
^ |
De gauche à droite |
Au niveau du bitOR |
| |
De gauche à droite |
LogiqueAND |
&& |
De gauche à droite |
LogiqueOR |
|| |
De gauche à droite |
| Conditionnel | ?: |
De droite à gauche |
| Mission | = += -= *= /= %= >>= <<= &= ^= |= |
De droite à gauche |
| Virgule | , |
De gauche à droite |
La ligne du haut contient les opérateurs avec la priorité la plus élevée. Les parenthèses ()sont utilisées pour définir explicitement la priorité. Les crochets []sont utilisés pour accéder à un élément à un index spécifique d'une variable de tableau. L'opérateur point ( .) est utilisé pour accéder aux champs et aux méthodes en utilisant une référence à un objet ou une classe.
Plus les opérateurs sont bas dans le tableau, plus leur priorité est faible.
Si vous utilisez plusieurs opérateurs dans une expression, ne soyez pas paresseux : ajoutez des parenthèses.
En Java, vous pouvez écrire quelque chose comme if (a & 1<< b > ~c), mais vous ne devriez pas. Vous écrivez du code non seulement pour le compilateur, mais aussi pour d'autres programmeurs. Plus le code est lisible, mieux c'est.
3. Incrément du préfixe et du suffixe
Comme vous le savez déjà, Java possède un opérateur d'incrémentation ( ++) et un opérateur de décrémentation ( --). Respectivement, ils augmentent et diminuent la valeur d'une variable de 1.
Ce que vous ne savez probablement pas, c'est qu'il existe deux types d'opérateurs : le préfixe (l'opérateur est placé avant la variable) et le suffixe (l'opérateur est placé après la variable). Et deux types d'opérateurs fonctionnent un peu différemment.
En Java, vous pouvez écrire une expression comme celle-ci :
int a = 5;
int b = a++;Si l' ++opérateur apparaît après une variable et que la variable fait partie d'une expression (comme dans l'exemple ci-dessus), alors l'expression utilisera la valeur actuelle de la variable, et ce n'est qu'ensuite que la variable sera augmentée de 1.
En d'autres termes, quelque chose comme ceci se produira :
int a = 5;
int b = a;
a = a + 1;Autrement dit, bsera 5, pas 6comme vous pourriez le penser à première vue.
Si l' ++opérateur est avant la variable et que la variable fait partie d'une expression, elle sera d'abord augmentée de 1et ce n'est qu'ensuite que sa valeur sera utilisée dans l'expression.
int a = 5;
int b = ++a;L'exemple ci-dessus est équivalent à l'exemple suivant :
int a = 5;
a = a + 1;
int b = a;Ici, bsera égal à 6.
Il existe même un exemple utilisé par les programmeurs Java pour déterminer si quelqu'un d'autre est également un programmeur Java :
int a = 5;
int b = ++a + ++a;Oui, vous pouvez l'écrire aussi.
Cet exemple se compilera très bien et se transformera en quelque chose comme ceci :
int a = 5;
a = a + 1;
int v1 = a;
a = a + 1;
int v2 = a;
int b = v1 + v2;Pour l' --opérateur, tout est exactement pareil.