L'une des utilisations les plus élémentaires des ordinateurs consiste à effectuer des opérations mathématiques. En tant que langage informatique, Java fournit également un riche ensemble d'opérateurs pour manipuler les variables. Nous pouvons diviser les opérateurs dans les groupes suivants :
Les opérateurs arithmétiques sont utilisés dans les expressions mathématiques et fonctionnent de la même manière qu’en mathématiques. Le tableau suivant répertorie tous les opérateurs arithmétiques.
L'exemple du tableau suppose que la variable entière A a une valeur de 10 et que la variable B a une valeur de 20 :
| Opérateur | décrire | exemple |
|---|---|---|
| + | Addition – les valeurs de chaque côté de l'opérateur d'addition | A + B est égal à 30 |
| - | Soustraction - opérande gauche moins opérande droit | A – B est égal à -10 |
| * | Multiplication - Multiplie les valeurs de chaque côté de l'opérateur | A * B est égal à 200 |
| / | Division - divise l'opérande de gauche par l'opérande de droite | B/A est égal à 2 |
| % | Modulo - le reste de l'opérande de gauche divisé par l'opérande de droite | B%A est égal à 0 |
| ++ | Incrément - augmente la valeur de l'opérande de 1 | B++ ou ++B est égal à 21 |
| -- | Décrémenter - diminue la valeur de l'opérande de 1 | B-- ou --B est égal à 19 |
Bien que les deux soient auto-croissants (leurs résultats de fonctionnement sont égaux à B+1), il existe encore des différences entre B++ et ++B. B est une lvalue et peut être exploité directement sur place (peut être compris comme + directement sur. variable B). 1), B++ est une rvalue Lors de l'opération dans le compilateur, une variable temporaire sera d'abord construite, puis la variable temporaire sera utilisée pour calculer +1 puis assignée à B.
Par conséquent, dans l'exemple de code ci-dessous, lors de l'impression de d++, on constate que le résultat n'est pas +1 (à ce moment, la variable d est imprimée et la variable temporaire de d est exploitée), mais le résultat affiché dans le prochain L'instruction imprimée est à nouveau +1. Le résultat final (la valeur de la variable temporaire est affectée à la variable d). Le résultat de l’impression de ++d est directement +1.
L'exemple de programme simple suivant montre les opérateurs arithmétiques. Copiez et collez le programme Java suivant et enregistrez-le en tant que fichier Test.java, puis compilez et exécutez le programme :
public class Test { public static void main(String args[]) { int a = 10; int b = 20; int c = 25; int d = 25; System.out.println("a + b = " + (a + b) ); System.out.println("a - b = " + (a - b) ); System.out.println("a * b = " + (a * b) ); System.out.println("b / a = " + (b / a) ); System.out.println("b % a = " + (b % a) ); System.out.println("c % a = " + (c % a) ); System.out.println("a++ = " + (a++) ); System.out.println("a-- = " + (a--) ); // 查看d++ 与++d 的不同System.out.println("d++ = " + (d++) ); System.out.println("d = " + d); System.out.println("++d = " + (++d) ); } }Les résultats de compilation et d'exécution de l'exemple ci-dessus sont les suivants :
a + b = 30 a - b = -10 a * b = 200 b / a = 2 b % a = 0 c % a = 5 a++ = 10 a-- = 11 d++ = 25 d =26 ++d = 27Le tableau suivant montre les opérateurs relationnels pris en charge par Java
L'exemple de variable entière A dans le tableau a une valeur de 10 et la variable B a une valeur de 20 :
| opérateur | décrire | exemple |
|---|---|---|
| == | Vérifie si les valeurs des deux opérandes sont égales, si c'est le cas alors la condition est vraie. | (A == B) est faux (pas vrai). |
| != | Vérifie si les valeurs de deux opérandes sont égales, si les valeurs ne sont pas égales alors la condition est vraie. | (A != B) est vrai. |
| > | Vérifie si la valeur de l'opérande gauche est supérieure à la valeur de l'opérande droit, si c'est le cas, la condition devient vraie. | (A>B) n'est pas vrai. |
| < | Vérifie si la valeur de l'opérande gauche est inférieure à la valeur de l'opérande droit, si c'est le cas, la condition devient vraie. | (A < B) est vrai. |
| >= | Vérifie si la valeur de l'opérande gauche est supérieure ou égale à la valeur de l'opérande droit, si c'est le cas, la condition devient vraie. | (A>=B) est faux. |
| <= | Vérifie si la valeur de l'opérande de gauche est inférieure ou égale à la valeur de l'opérande de droite, si c'est le cas, la condition devient vraie. | (A <= B) est vrai. |
L'exemple de programme simple suivant montre les opérateurs relationnels. Copiez et collez le programme Java suivant et enregistrez-le en tant que fichier Test.java, puis compilez et exécutez le programme :
public class Test { public static void main(String args[]) { int a = 10; int b = 20; System.out.println("a == b = " + (a == b) ); System.out.println("a != b = " + (a != b) ); System.out.println("a > b = " + (a > b) ); System.out.println("a < b = " + (a < b) ); System.out.println("b >= a = " + (b >= a) ); System.out.println("b <= a = " + (b <= a) ); } }Les résultats de compilation et d'exécution de l'exemple ci-dessus sont les suivants :
a == b = false a != b = true a > b = false a < b = true b >= a = true b <= a = falseJava définit des opérateurs au niveau du bit, qui s'appliquent aux types entiers (int), aux entiers longs (long), aux entiers courts (short), aux types de caractères (char) et aux types d'octets (byte).
Les opérateurs au niveau du bit opèrent sur tous les bits et fonctionnent au niveau du bit. Supposons que a = 60 et b = 13 ; leur représentation au format binaire sera la suivante :
A = 0011 1100 B = 0000 1101 ----------------- A&B = 0000 1100 A | B = 0011 1101 A ^ B = 0011 0001 ~A= 1100 0011Le tableau suivant répertorie les opérations de base des opérateurs au niveau du bit, en supposant que la variable entière A a une valeur de 60 et que la variable B a une valeur de 13 :
| Opérateur | décrire | exemple |
|---|---|---|
| & | Opérateur ET au niveau du bit, le résultat est 1 si et seulement si un certain bit des deux opérandes est différent de 0. | (A&B), obtenez 12, soit 0000 1100 |
| | | Opérateur OU au niveau du bit, tant qu'un certain bit des deux opérandes est différent de 0, le résultat sera 1. | (A | B) obtient 61, soit 0011 1101 |
| ^ | Opérateur XOR au niveau du bit, lorsqu'un certain bit des deux opérandes est différent, le bit de résultat est 1. | (A^B) nous donne 49, soit 0011 0001 |
| ~ | L'opérateur de complément au niveau du bit retourne chaque bit de l'opérande. | (~A) obtient -61, soit 1100 0011 |
| << | Opérateur de décalage vers la gauche au niveau du bit. L'opérande de gauche est décalé vers la gauche du nombre de bits spécifié par l'opérande de droite. | Un << 2 nous donne 240, soit 1111 0000 |
| >> | Opérateur de décalage à droite au niveau du bit. L'opérande de gauche est décalé au niveau du bit vers la droite du nombre de bits spécifié par l'opérande de droite. | A >> 2 donne 15, soit 1111 |
| >>> | Opérateur de remplissage zéro avec décalage à droite au niveau du bit. La valeur de l'opérande de gauche est décalée vers la droite du nombre de bits spécifié par l'opérande de droite et les postes vacants résultants sont remplis de zéros. | A>>>2 obtient 15, soit 0000 1111 |
L'exemple de programme simple suivant montre les opérateurs au niveau du bit. Copiez et collez le programme Java suivant et enregistrez-le en tant que fichier Test.java, puis compilez et exécutez le programme :
public class Test { public static void main(String args[]) { int a = 60; /* 60 = 0011 1100 */ int b = 13; /* 13 = 0000 1101 */ int c = 0; c = a & b; /* 12 = 0000 1100 */ System.out.println("a & b = " + c ); c = a | b; /* 61 = 0011 1101 */ System.out.println("a | b = " + c ); c = a ^ b; /* 49 = 0011 0001 */ System.out.println("a ^ b = " + c ); c = ~a; /*-61 = 1100 0011 */ System.out.println("~a = " + c ); c = a << 2; /* 240 = 1111 0000 */ System.out.println("a << 2 = " + c ); c = a >> 2; /* 215 = 1111 */ System.out.println("a >> 2 = " + c ); c = a >>> 2; /* 215 = 0000 1111 */ System.out.println("a >>> 2 = " + c ); } }Les résultats de compilation et d'exécution de l'exemple ci-dessus sont les suivants :
a & b = 12 a | b = 61 a ^ b = 49 ~a = -61 a << 2 = 240 a >> 2 = 15 a >>> 2 = 15Le tableau suivant répertorie les opérations de base des opérateurs logiques, en supposant que la variable booléenne A est vraie et la variable B est fausse.
| Opérateur | décrire | exemple |
|---|---|---|
| && | Appelé l’opérateur logique ET. Une condition est vraie si et seulement si les deux opérandes sont vrais. | (A && B) est faux. |
| | | Appelé l’opérateur logique OU. La condition est vraie si l’un des deux opérandes est vrai. | (A | | B) est vrai. |
| ! | Appelé l’opérateur logique NOT. Utilisé pour inverser l'état logique de l'opérande. Si la condition est vraie, l’opérateur logique NOT deviendra faux. | ! (A && B) est vrai. |
L'exemple de programme simple suivant montre les opérateurs logiques. Copiez et collez le programme Java suivant et enregistrez-le en tant que fichier Test.java, puis compilez et exécutez le programme :
public class Test { public static void main(String args[]) { boolean a = true; boolean b = false; System.out.println("a && b = " + (a&&b)); System.out.println("a || b = " + (a||b) ); System.out.println("!(a && b) = " + !(a && b)); } }Les résultats de compilation et d'exécution de l'exemple ci-dessus sont les suivants :
a && b = false a || b = true !(a && b) = trueVoici les opérateurs d'affectation pris en charge par le langage Java :
| Opérateur | décrire | exemple |
|---|---|---|
| = | Opérateur d'affectation simple, attribue la valeur de l'opérande de droite à l'opérande de gauche | C = A + B attribuera la valeur obtenue par A + B à C |
| + = | Opérateur d'affectation d'addition, qui additionne l'opérande gauche et l'opérande droit et attribue la valeur à l'opérande gauche | C + = A équivaut à C = C + A |
| -= | Opérateur de soustraction et d'affectation, qui soustrait l'opérande gauche et l'opérande droit et attribue la valeur à l'opérande gauche | C - = A est équivalent à C = C - A |
| * = | L'opérateur de multiplication et d'affectation, qui multiplie l'opérande de gauche et l'opérande de droite et attribue la valeur à l'opérande de gauche | C * = A est équivalent à C = C * A |
| / = | L'opérateur de division et d'affectation divise l'opérande gauche et l'opérande droit et attribue la valeur à l'opérande gauche. | C / = A équivaut à C = C / A |
| (%)= | Opérateur de module et d'affectation, qui modulo les opérandes gauche et droit et attribue la valeur à l'opérande gauche | C%=A équivaut à C=C%A |
| << = | opérateur d'affectation de quart de gauche | C << = 2 équivaut à C = C << 2 |
| >> = | opérateur d'affectation de quart de travail à droite | C >> = 2 équivaut à C = C >> 2 |
| &= | Opérateur d'affectation ET au niveau du bit | C&=2 équivaut à C=C&2 |
| ^ = | Opérateur d'affectation XOR au niveau du bit | C^=2 équivaut à C=C^2 |
| | | Opérateur d'affectation OU au niveau du bit | C|=2 équivaut à C=C|2 |
L’exemple de programme simple suivant illustre l’opérateur d’affectation. Copiez et collez le programme Java suivant et enregistrez-le en tant que fichier Test.java, puis compilez et exécutez le programme :
public class Test { public static void main(String args[]) { int a = 10; int b = 20; int c = 0; c = a + b; System.out.println("c = a + b = " + c ); c += a ; System.out.println("c += a = " + c ); c -= a ; System.out.println("c -= a = " + c ); c *= a ; System.out.println("c *= a = " + c ); a = 10; c = 15; c /= a ; System.out.println("c /= a = " + c ); a = 10; c = 15; c %= a ; System.out.println("c %= a = " + c ); c <<= 2 ; System.out.println("c <<= 2 = " + c ); c >>= 2 ; System.out.println("c >>= 2 = " + c ); c >>= 2 ; System.out.println("c >>= a = " + c ); c &= a ; System.out.println("c &= a= " + c ); c ^= a ; System.out.println("c ^= a= " + c ); c |= a ; System.out.println("c |= a= " + c ); } }Les résultats de compilation et d'exécution de l'exemple ci-dessus sont les suivants :
c = a + b = 30 c += a = 40 c -= a = 30 c *= a = 300 c /= a = 1 c %= a = 5 c <<= 2 = 20 c >>= 2 = 5 c >>= 2 = 1 c &= a = 0 c ^= a = 10 c |= a = 10Les opérateurs conditionnels sont également appelés opérateurs ternaires. Cet opérateur comporte trois opérandes et doit évaluer la valeur d'une expression booléenne. L'objectif principal de cet opérateur est de décider quelle valeur doit être attribuée à la variable.
variable x = (expression) ? value if true : value if false public class Test { public static void main(String args[]){ int a , b; a = 10; b = (a == 1) ? 20: 30; System.out.println( "Value of b is : " + b ); b = (a == 10) ? 20: 30; System.out.println( "Value of b is : " + b ); } }Les résultats de compilation et d'exécution de l'exemple ci-dessus sont les suivants :
Value of b is : 30 Value of b is : 20Cet opérateur permet d'opérer sur des instances d'objet et de vérifier si l'objet est d'un type spécifique (type classe ou type interface).
L'opérateur instanceof est utilisé au format suivant :
( Object reference variable ) instanceof (class/interface type)Si l'objet pointé par la variable du côté gauche de l'opérateur est un objet de la classe ou de l'interface (classe/interface) du côté droit de l'opérateur, le résultat est vrai.
Voici un exemple :
String name = 'James'; boolean result = name instanceof String; // 由于name是String类型，所以返回真Cet opérateur renvoie toujours vrai si les objets comparés sont compatibles avec le type de droite.
Regardez l'exemple suivant :
class Vehicle {} public class Car extends Vehicle { public static void main(String args[]){ Vehicle a = new Car(); boolean result = a instanceof Car; System.out.println( result); } }Les résultats de compilation et d'exécution de l'exemple ci-dessus sont les suivants :
trueLorsque plusieurs opérateurs apparaissent dans une expression, lequel apparaît en premier ? Cela implique la question de la priorité des opérateurs. Dans une expression multi-opérateurs, différentes priorités d’opérateur conduiront à des résultats finaux très différents.
Par exemple, (1+3) + (3+2)*2, si cette expression est calculée selon le signe plus comme priorité la plus élevée, la réponse est 18, et si le signe de multiplication est la priorité la plus élevée, la réponse est 14.
Autre exemple, x = 7 + 3 * 2 ; ici x obtient 13, pas 20, car l'opérateur de multiplication a une priorité plus élevée que l'opérateur d'addition, donc 3 * 2 est calculé d'abord pour obtenir 6, puis 7 est ajouté.
Les opérateurs ayant la priorité la plus élevée dans le tableau suivant se trouvent en haut du tableau et les opérateurs ayant la priorité la plus basse se trouvent en bas du tableau.
| catégorie | Opérateur | pertinence |
|---|---|---|
| suffixe | () [] (opérateur point) | de gauche à droite |
| un yuan | + + - ! ~ | de droite à gauche |
| multiplicatif | */% | de gauche à droite |
| Additivité | + - | de gauche à droite |
| changement | >> >>> << | de gauche à droite |
| relation | >> = << = | de gauche à droite |
| égal | == != | de gauche à droite |
| ET au niveau du bit | & | de gauche à droite |
| XOR au niveau du bit | ^ | de gauche à droite |
| OU au niveau du bit | | | de gauche à droite |
| ET logique | && | de gauche à droite |
| logique ou | | | de gauche à droite |
| condition | ? : | de droite à gauche |
| Affectation | = + = - = * = / =%= >> = << =&= ^ = = | de droite à gauche |
| virgule | , | de gauche à droite |