&& & & Operadores em Java

Em java, && é chamado de condicional e operador. É um exemplo de operador lógico em Java. Como outro operador, e tem duas funções em Java. Em uma situação, é chamado de lógica e operador. Na outra situação, é chamado de operador bit-in-e. Cada um desses operadores é um operador binário. Isso significa que cada um tem um operando à sua esquerda e à sua direita. O resultado de toda essa expressão pode ser atribuído a uma variável. Esses operadores trabalham com tipos primitivos e, portanto, sua classe não precisa ser importada pelo programador.

A tabela de verdade para e é:

falso e falso = falso
falso e verdadeiro = falso
verdadeiro e falso = falso
verdadeiro e verdadeiro = verdadeiro

Este artigo explica o uso desses três operadores, começando com o operador lógico e o operador, &.

Lógico e operador

Um valor booleano é verdadeiro ou falso. Este operador deve ser usado, quando ambos os operandos são valores booleanos. O programa a seguir ilustra o seguinte:

classe pública theClass
public static void main (string [] args)
Booleano Bl1 = Falso e Falso; Sistema.fora.println (bl1);
Boolean Bl2 = False & True; Sistema.fora.println (bl2);
Boolean Bl3 = True & False; Sistema.fora.println (BL3);
Boolean BL4 = True & True; Sistema.fora.println (BL4);

Em Java, um programa é um programador implementado pela classe. O nome do arquivo do programa é o nome da classe. A classe deve ter o método principal (). Para este programa, o nome da classe é, o Teclass. No método Main () aqui, há quatro linhas. Cada linha corresponde a uma linha na tabela de verdade e. Cada linha imprime seu resultado. A saída é:

falso
falso
falso
verdadeiro

confirmando que isso é e lógica.

O operador condicional e, &&

O operador, && é um operador e é usado em condições if e loop-condicionas. Seu operando esquerdo é uma expressão de propósito geral, e seu operando direito também é uma expressão de propósito geral. O programa a seguir ilustra seu mesmo uso, fora da condição IF ou loop:

classe pública theClass
public static void main (string [] args)
booleano bl1 = 1 == 0 && 1 == 0; Sistema.fora.println (bl1);
booleano bl2 = 1 == 0 && 1 == 1; Sistema.fora.println (bl2);
BL3 booleano = 1 == 1 && 1 == 0; Sistema.fora.println (BL3);
booleano bl4 = 1 == 1 && 1 == 1; Sistema.fora.println (BL4);

No método Main () aqui, há quatro linhas. Cada linha corresponde a uma linha na tabela de verdade e. Observe os operando esquerda e direita para cada operador &&. Cada um desses operando é uma expressão. Cada uma dessas expressões resulta em verdadeiro ou falso. Portanto, uma expressão verdadeira poderia ter sido substituída pela palavra nua, verdadeira e uma expressão falsa poderia ter sido substituída pela palavra nua, falsa. A saída é:

falso
falso
falso
verdadeiro

confirmando que isso é e lógica.

O programa acima é reescrito, onde cada linha de interesse, é uma declaração IF composta:

classe pública theClass
public static void main (string [] args)
if (1 == 0 && 1 == 0) sistema.fora.println (true); Sistema else.fora.println (false);
if (1 == 0 && 1 == 1) sistema.fora.println (true); Sistema else.fora.println (false);
if (1 == 1 && 1 == 0) sistema.fora.println (true); Sistema else.fora.println (false);
if (1 == 1 && 1 == 1) sistema.fora.println (true); Sistema else.fora.println (false);

No método Main () aqui, há quatro linhas. Cada linha corresponde a uma linha na tabela de verdade e. Observe os operando esquerda e direita para cada operador &&. Cada um desses operando é uma expressão. Cada uma dessas expressões resulta em verdadeiro ou falso. Portanto, uma expressão verdadeira poderia ter sido substituída pela palavra nua, verdadeira e uma expressão falsa poderia ter sido substituída pela palavra nua, falsa. A saída é:

falso
falso
falso
verdadeiro

confirmando que isso é e lógica.

O operador bit-and-and, &

A tabela de verdade e a verdade com bits é:

0 e 0 = 0
0 e 1 = 0
1 e 0 = 0
1 e 1 = 1

& é o operador e os bits, bem como é o operador e os valores booleanos.

Agora 111111111100000000 em hexadecimal é 0xff00 e em decimal, é 65280.

Além disso, 1111000011110000 em hexadecimal é 0xf0f0 e, em decimal, é 61680.

Além disso, 11110000000000 em hexadecimal é 0xf000 e, em decimal, é 61440.

Decimal significa base 10.

Anding números binários bit-bit é chamado Bitwise Anding, e o operador para este é &. Então

111111111100000000 e 11110000111110000 = 1111000000000000

O mesmo se aplica aos seus números hexadecimais correspondentes. Aquilo é:

0xff00 & 0xf0f0 = 0xf000

O mesmo se aplica aos seus números decimais correspondentes. Aquilo é:

65280 e 61680 = 61440

O operador bitwise é normalmente usado com números hexadecimais ou números decimais.

Bit e (&) com números hexadecimais

O seguinte programa BitWises 0xff00 e 0xff00 para ter 0xf000:

classe pública theClass
public static void main (string [] args)
int num1 = 0xff00;
int num2 = 0xf0f0;
int num3 = num1 e num2;
Sistema.fora.println (num3);

num1 e num2 são declarados e inicializados com números hexadecimais. A terceira declaração faz bit e, usando &, para esses números hexadecimais. A última declaração imprime o resultado. A saída é 61440, que é o equivalente decimal do esperado, 0xf000.

Bit a bit e (&) com números decimais

O seguinte programa Bitwises 65280 e 61680 para ter 61440 (todos os números decimais):

classe pública theClass
public static void main (string [] args)
int num1 = 65280;
int num2 = 61680;
int num3 = num1 e num2;
Sistema.fora.println (num3);

num1 e num2 são declarados e inicializados com números decimais. A terceira declaração faz bit e, usando &, para esses números decimais. A última declaração imprime o resultado. A saída é 61440, que é o equivalente decimal do binário 1111000000000000.

Conclusão

Em java, && é chamado de condicional e operador. Em Java, & é o operador lógico e também o operador bitwise. Esses três operadores são operadores binários, no sentido de que cada um tem um operando esquerdo e um operando direito. && é usado quando os operando esquerdo e direito são expressões, onde cada um resulta em verdadeiro ou falso. Qualquer uma dessas expressões pode realmente ser substituída por verdadeira ou falsa e é usada ao manusear valores booleanos: verdadeiro ou falso. e deve ser usado quando bit e é necessário.