Opérateurs Java

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 des exemples ci-dessus sont les suivants :

a　==　b　=　false
a　!=　b　=　true
a　>　b　=　false
a　<　b　=　true
b　>=　a　=　true
b　<=　a　=　false

Opérateurs de bit

Java définit des opérateurs de bit, appliqués aux types entiers (int), long, court (short), caractère (char) et octet (byte) et autres types.

Les opérateurs de bit agissent sur tous les bits et effectuent des opérations bit par bit. Supposons que a = 60, b = 13;Leur format binaire sera représenté comme suit :

A　=　0011　1100
B　=　0000　1101
-----------------
A&B　=　0000　1100
A　|　B　=　0011　1101
A　^　B　=　0011　0001
~A=　1100 0011

Le tableau suivant liste les opérations de base des opérateurs de bit, en supposant que la valeur de la variable entière A soit 60 et la valeur de la variable B sont 13:

Exemple

Le programme d'exemple simple suivant démontre les opérateurs de bit. Copiez et collez le programme Java suivant et enregistrez-le sous le fichier Test.java, puis compilez et exécutez ce 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;　　　　　/*　15　=　1111　*/
　　　　　System.out.println("a >>　2　　= \　+　c );
　　
　　　　　c = a >>>　2;　　　　　/*　15　= 0000　1111　*/
　　　　　System.out.println("a >>>　2　= \　+　c );
　　}
}

Les résultats de compilation et d'exécution des exemples ci-dessus sont les suivants :

a & b =　12
a | b =　61
a ^ b =　49
~a =　-61
a <<　2　=　240
a >>　2　　=　15
a >>>　2　=　15

Opérateurs logiques

Le tableau suivant liste les opérations de base des opérateurs logiques, en supposant que la variable booléenne A soit true et la variable B soit false

Exemple

Le programme d'exemple simple suivant démontre les opérateurs logiques. Copiez et collez le programme Java suivant et enregistrez-le sous le fichier Test.java, puis compilez et exécutez ce 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 des exemples ci-dessus sont les suivants :

a && b = false
a || b = true
!(a && b) = true

Opérateurs logiques courts-circuités

Lorsque l'utilisation des opérateurs logiques, le résultat est true uniquement lorsque les deux opérandes sont true, mais lorsque le premier opérande est false, le résultat est nécessairement false, et dans ce cas, le second opérande ne sera plus jugé.

public class LuoJi{}}
　　　　public　static　void　main(String[]　args){
　　　　　　　　int a =　5;//Définir une variable ;
　　　　　　　　boolean b = (a<4) && (a++<10);
　　　　　　　　System.out.println("Le résultat de l'utilisation de l'opérateur logique court-circuit est "+b);
　　　　　　　　System.out.println("Le résultat de a est "+a);
　　　　}
}

Le résultat de l'exécution est :

le résultat de l'utilisation de l'opérateur logique court-circuit est false
le résultat de a est5

Analyse :Ce programme utilise l'opérateur logique court-circuit (&&), d'abord juger a<4 si le résultat de < est false, alors le résultat de b doit nécessairement être false, donc la deuxième opération a n'est plus exécutée++<10 de jugement, donc la valeur de a est 5。

Opérateurs d'affectation

Voici les opérateurs d'affectation pris en charge par le langage Java :

Exemple

Le programme simple suivant montre l'opérateur d'affectation. Copiez et collez le programme Java suivant et enregistrez-le sous le nom de fichier AssignmentOperator.java, puis compilez et exécutez ce programme :

class AssignmentOperator {
　　　　public static void main(String[] args) {
　　　　　　　　
　　　　　　　　int number1, number2;
　　　　　　　　
　　　　　　　　//Assigner5est assignée à number1
　　　　　　　　number1　=　5;
　　　　　　　　System.out.println(number1);
　　　　　　　　　　　　　　　　
　　　　　　　　//La variable number2la valeur est assignée à number1
　　　　　　　　number2　=　number1;
　　　　　　　　System.out.println(number2);
　　　　}
}

Les résultats de compilation et d'exécution des exemples ci-dessus sont les suivants :

5
5

Opérateur conditionnel （?:）

L'opérateur conditionnel est également appelé opérateur ternaire. Cet opérateur a3un opérateur nécessitant une seule opération et nécessitant de juger de la valeur de l'expression booléenne. L'opérateur conditionnel principal est de décider quelle valeur doit être assignée à la variable.

variable　x　=　(expression)　?　value　if　true　:　value　if　false

Exemple

public　class　Test　{
　　　public　static　void　main(String[]　args){
　　　　　　int　a　,　b;
　　　　　　a　=　10;
　　　　　　//　si a est égal　1　si cela est établi, then set b to　20, sinon pour　30
　　　　　　b　=　(a　==　1)　?　20　:　30;
　　　　　　System.out.println(　"La valeur de b est : "　+　　b　);
　
　　　　　　//　si a est égal　10　si cela est établi, then set b to　20, sinon pour　30
　　　　　　b　=　(a　==　10)　?　20　:　30;
　　　　　　System.out.println(　"La valeur de b est : "　+　b　);
　　　}
}

Les résultats de compilation et d'exécution des exemples ci-dessus sont les suivants :

La valeur de b est :　30
La valeur de b est :　20

Opérateur instanceof

Cet opérateur est utilisé pour manipuler des exemples d'objets, pour vérifier si un objet est un type spécifique (type de classe ou de type d'interface).

Le format d'utilisation de l'opérateur instanceof est le suivant :

(　Object　reference　variable　)　instanceof　　(class/interface　type)

Si l'objet de la variable de gauche de l'opérateur est une classe ou une interface (class/Si un objet d'interface) est comparé, le résultat est true.

Voici un exemple :

String　name　=　"James";
boolean　result　=　name　instanceof　String;　//　Comme name est de type String, il retourne true

Si l'objet comparé est compatible avec le type de droite, cet opérateur retourne toujours true.

Voyons un exemple ci-dessous :

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 des exemples ci-dessus sont les suivants :

true

Priorité des opérateurs en Java

Quand plusieurs opérateurs apparaissent dans une expression, lequel vient en premier et lequel en dernier ? Cela concerne la question du niveau de priorité des opérateurs. Dans une expression avec plusieurs opérateurs, la différence de niveau de priorité des opérateurs peut entraîner des résultats très différents.

For example，（1+3）＋（3+2）*2，这个表达式如果按加号最优先计算，答案就是 18，如果按照乘号最优先，答案则是 14。

再如，x = 7 + 3 * 2；这里x得到13，而不是20，因为乘法运算符比加法运算符有较高的优先级，所以先计算3 * 2得到6，然后再加7。

The operators with the highest priority in the table are at the top, and the lowest priority are at the bottom.