&& & & Opérateurs à Java

En java, && est appelé l'opérateur conditionnel et. C'est un exemple d'opérateur logique en Java. En tant qu'un autre opérateur, et a deux fonctions en Java. Dans une situation, il est appelé logique et opérateur. Dans l'autre situation, il s'appelle l'opérateur bitwise-and. Chacun de ces opérateurs est un opérateur binaire. Cela signifie que chacun a un opérande à sa gauche et à sa droite. Le résultat de toute cette expression peut être attribué à une variable. Ces opérateurs travaillent avec des types primitifs, et sa classe n'a donc pas à être importée par le programmeur.

La table de vérité pour et est:

Faux et faux = faux
Faux et true = faux
vrai et false = faux
true and true = true

Cet article explique l'utilisation de ces trois opérateurs, en commençant par l'opérateur logique et, &.

Logique et opérateur

Une valeur booléenne est vraie ou fausse. Cet opérateur doit être utilisé lorsque les deux opérandes sont des valeurs booléennes. Le programme suivant illustre ceci:

classe publique TheClass
public static void main (String [] args)
booléen bl1 = false & false; Système.dehors.println (BL1);
booléen bl2 = false & true; Système.dehors.println (BL2);
booléen bl3 = true & false; Système.dehors.println (BL3);
booléen bl4 = true & true; Système.dehors.println (BL4);

En Java, un programme est une classe implémentée par programmeur. Le nom du fichier du programme est le nom de classe. La classe doit avoir la méthode principale (). Pour ce programme, le nom de la classe est la classe. Dans la méthode principale () ici, il y a quatre lignes. Chaque ligne correspond à une ligne dans le tableau et la vérité. Chaque ligne imprime son résultat. La sortie est:

FAUX
FAUX
FAUX
vrai

confirmant que c'est et la logique.

L'opérateur conditionnel et, &&

L'opérateur, && est un et opérateur, et il est utilisé dans les conditions de sites et les conditions de boucle. Son opérande gauche est une expression à usage général, et son opérande droit est également une expression à usage général. Le programme suivant illustre sa même utilisation, en dehors de la condition IF ou LOOP:

classe publique TheClass
public static void main (String [] args)
booléen bl1 = 1 == 0 && 1 == 0; Système.dehors.println (BL1);
booléen bl2 = 1 == 0 && 1 == 1; Système.dehors.println (BL2);
booléen bl3 = 1 == 1 && 1 == 0; Système.dehors.println (BL3);
booléen bl4 = 1 == 1 && 1 == 1; Système.dehors.println (BL4);

Dans la méthode principale () ici, il y a quatre lignes. Chaque ligne correspond à une ligne dans le tableau et la vérité. Notez les opérandes gauche et droit pour chaque opérateur &&. Chacun de ces opérandes est une expression. Chacune de ces expressions se traduit par un vrai ou un faux. Ainsi, une vraie expression aurait pu être substituée par le mot nu, vrai, et une fausse expression aurait pu être substituée par le mot nu, faux. La sortie est:

FAUX
FAUX
FAUX
vrai

confirmant que c'est et la logique.

Le programme ci-dessus est réécrit, où chaque ligne d'intérêt, est une mise en place de la composition:

classe publique TheClass
public static void main (String [] args)
Système if (1 == 0 && 1 == 0).dehors.println (true); Système d'autre.dehors.println (false);
si (1 == 0 && 1 == 1).dehors.println (true); Système d'autre.dehors.println (false);
Système if (1 == 1 && 1 == 0).dehors.println (true); Système d'autre.dehors.println (false);
si (1 == 1 && 1 == 1).dehors.println (true); Système d'autre.dehors.println (false);

Dans la méthode principale () ici, il y a quatre lignes. Chaque ligne correspond à une ligne dans le tableau et la vérité. Notez les opérandes gauche et droit pour chaque opérateur &&. Chacun de ces opérandes est une expression. Chacune de ces expressions se traduit par un vrai ou un faux. Ainsi, une vraie expression aurait pu être substituée par le mot nu, vrai, et une fausse expression aurait pu être substituée par le mot nu, faux. La sortie est:

FAUX
FAUX
FAUX
vrai

confirmant que c'est et la logique.

L'opérateur bitwise et, &

La table et la vérité avec des bits est:

0 & 0 = 0
0 & 1 = 0
1 & 0 = 0
1 et 1 = 1

& est l'opérateur et les bits, ainsi que l'opérateur et les valeurs booléennes.

Maintenant 1111111100000000 en hexadécimal est 0xff00, et en décimal, il est 65280.

De plus, 11110000001110000 en hexadécimal est 0xf0f0, et en décimal, il est 61680.

De plus, 1111000000000000 en hexadécimal est 0xf000, et en décimal, il est 61440.

Décimal signifie base 10.

Et les numéros binaires bit-by bit est appelé bitwise anding, et l'opérateur pour cela est &. Donc

1111111100000000 et 1111000011110000 = 11110000000000

La même chose s'applique à leurs nombres hexadécimaux correspondants. C'est-à-dire:

0xff00 & 0xf0f0 = 0xf000

La même chose s'applique à leurs nombres décimaux correspondants. C'est-à-dire:

65280 et 61680 = 61440

L'opérateur de bitwise est normalement utilisé avec des nombres hexadécimaux ou des nombres décimaux.

Bitwise et (&) avec des nombres hexadécimaux

Le programme suivant Bitwise 0xff00 & 0xff00 pour avoir 0xf000:

classe publique TheClass
public static void main (String [] args)
int num1 = 0xff00;
int num2 = 0xf0f0;
int num3 = num1 & num2;
Système.dehors.println (num3);

num1 et num2 sont déclarés et initialisés avec des nombres hexadécimaux. La troisième déclaration fait le bit et, en utilisant et, pour ces nombres hexadécimaux. La dernière déclaration imprime le résultat. La sortie est de 61440, qui est l'équivalent décimal du 0xf000 attendu.

Bitwise et (&) avec des chiffres décimaux

Le programme suivant Bitwise 65280 et 61680 a 61440 (tous les chiffres décimaux):

classe publique TheClass
public static void main (String [] args)
int num1 = 65280;
int num2 = 61680;
int num3 = num1 & num2;
Système.dehors.println (num3);

num1 et num2 sont déclarés et initialisés avec des nombres décimaux. La troisième instruction fait le bit et, en utilisant et, pour ces chiffres décimaux. La dernière déclaration imprime le résultat. La sortie est de 61440, ce qui est l'équivalent décimal de Binary 11110000000000.

Conclusion

En java, && est appelé l'opérateur conditionnel et. En Java, et est l'opérateur logique et aussi l'opérateur bitwise. Ces trois opérateurs sont des opérateurs binaires, dans le sens où chacun a un opérande gauche et un opérande droit. && est utilisé lorsque les opérandes gauche et droit sont des expressions, où chacun se traduit par vrai ou faux. L'une de ces expressions peut en fait être substituée par vrai ou fausse et est utilisée lors de la gestion des valeurs booléennes: vrai ou faux. & doit être utilisé lorsqu'il est nécessaire et requis.