&& & & operadores en Java

En java, && se llama condicional y operador. Es un ejemplo de un operador lógico en Java. Como otro operador, y tiene dos funciones en Java. En una situación, se llama un operador lógico. En la otra situación, se llama bit a bitwise y operador. Cada uno de estos operadores es un operador binario. Esto significa que cada uno tiene un operando a su izquierda y a su derecha. El resultado de todo esa expresión puede asignarse a una variable. Estos operadores trabajan con tipos primitivos, por lo que el programador no tiene que importar su clase.

La tabla de la verdad para y es:

falso y falso = falso
falso y verdadero = falso
Verdadero y falso = Falso
verdadero y verdadero = verdadero

Este artículo explica el uso de estos tres operadores, comenzando con el operador lógico y.

Lógico y operador

Un valor booleano es verdadero o falso. Este operador debe usarse, cuando ambos operandos son valores booleanos. El siguiente programa ilustra esto:

clase pública THECLASS
public static void main (string [] args)
booleano bl1 = falso y falso; Sistema.afuera.println (BL1);
booleano bl2 = falso y true; Sistema.afuera.println (BL2);
booleano bl3 = verdadero y falso; Sistema.afuera.println (BL3);
boolean bl4 = verdadero y verdadero; Sistema.afuera.println (BL4);

En Java, un programa es una clase implementada de programador. El nombre del archivo del programa es el nombre de la clase. La clase debe tener el método Main (). Para este programa, el nombre de la clase es, THECLASS. En el método main () aquí, hay cuatro líneas. Cada línea corresponde a una línea en la tabla y la verdad. Cada línea imprime su resultado. La salida es:

FALSO
FALSO
FALSO
verdadero

confirmando que esto es y lógica.

El condicional y el operador, &&

El operador, && es un operador y se usa en condiciones if y bucle-condiciones. Su operando izquierdo es una expresión de propósito general, y su operando derecho también es una expresión de propósito general. El siguiente programa ilustra su mismo uso, fuera de la condición if o bucle:

clase pública THECLASS
public static void main (string [] args)
boolean bl1 = 1 == 0 && 1 == 0; Sistema.afuera.println (BL1);
boolean bl2 = 1 == 0 && 1 == 1; Sistema.afuera.println (BL2);
booleano bl3 = 1 == 1 && 1 == 0; Sistema.afuera.println (BL3);
booleano bl4 = 1 == 1 && 1 == 1; Sistema.afuera.println (BL4);

En el método main () aquí, hay cuatro líneas. Cada línea corresponde a una línea en la tabla y la verdad. Tenga en cuenta los operandos izquierdo y derecho para cada operador &&. Cada uno de estos operandos es una expresión. Cada una de estas expresiones da como resultado verdadero o falso. Entonces, una verdadera expresión podría haber sido sustituida con la palabra desnuda, verdadera y una expresión falsa podría haber sido sustituida con la palabra desnuda, falsa. La salida es:

FALSO
FALSO
FALSO
verdadero

confirmando que esto es y lógica.

El programa anterior se reescribe, donde cada línea de interés, es una declaración de compuesto IF:

clase pública THECLASS
public static void main (string [] args)
Sistema if (1 == 0 && 1 == 0).afuera.println (verdadero); más sistema.afuera.println (falso);
if (1 == 0 && 1 == 1) Sistema.afuera.println (verdadero); más sistema.afuera.println (falso);
Sistema if (1 == 1 && 1 == 0).afuera.println (verdadero); más sistema.afuera.println (falso);
if (1 == 1 && 1 == 1) Sistema.afuera.println (verdadero); más sistema.afuera.println (falso);

En el método main () aquí, hay cuatro líneas. Cada línea corresponde a una línea en la tabla y la verdad. Tenga en cuenta los operandos izquierdo y derecho para cada operador &&. Cada uno de estos operandos es una expresión. Cada una de estas expresiones da como resultado verdadero o falso. Entonces, una verdadera expresión podría haber sido sustituida con la palabra desnuda, verdadera y una expresión falsa podría haber sido sustituida con la palabra desnuda, falsa. La salida es:

FALSO
FALSO
FALSO
verdadero

confirmando que esto es y lógica.

El operador bit a bit, &

La mesa de la verdad con bits es:

0 & 0 = 0
0 & 1 = 0
1 y 0 = 0
1 y 1 = 1

& es el operador de bits, así como es el y el operador de los valores booleanos.

Ahora 1111111100000000 en hexadecimal es 0xff00, y en decimal, es 65280.

Además, 1111000011110000 en hexadecimal es 0xf0f0, y en decimal, es 61680.

Además, 1111000000000000 en hexadecimal es 0xf000, y en decimal, es 61440.

Decimal significa base 10.

Anding Binary números bit a bit se llama bitwise anding, y el operador de esto es &. Entonces

1111111100000000 y 1111000011110000 = 1111000000000000

Lo mismo se aplica a sus números hexadecimales correspondientes. Eso es:

0xff00 y 0xf0f0 = 0xf000

Lo mismo se aplica a sus números decimales correspondientes. Eso es:

65280 y 61680 = 61440

El operador bit a bit se usa normalmente con números hexadecimales o números decimales.

Bitwise y (&) con números hexadecimales

El siguiente programa se mueve 0xff00 y 0xff00 para tener 0xf000:

clase pública THECLASS
public static void main (string [] args)
int num1 = 0xff00;
int num2 = 0xf0f0;
int num3 = num1 y num2;
Sistema.afuera.println (num3);

num1 y num2 se declaran e inicializan con números hexadecimales. La tercera declaración hace el bit a bit y, usando y, para estos números hexadecimales. La última declaración imprime el resultado. La salida es 61440, que es el equivalente decimal del esperado, 0xf000.

Bitwise y (&) con números decimales

El siguiente programa Bitwises 65280 y 61680 tiene 61440 (todos los números decimales):

clase pública THECLASS
public static void main (string [] args)
int num1 = 65280;
int num2 = 61680;
int num3 = num1 y num2;
Sistema.afuera.println (num3);

num1 y num2 se declaran e inicializan con números decimales. La tercera declaración hace el bit a bit y, usando y, para estos números decimales. La última declaración imprime el resultado. La salida es 61440, que es el equivalente decimal del 1111000000000000 binario.

Conclusión

En java, && se llama condicional y operador. En Java, y es el operador lógico y también el operador bitwise. Estos tres operadores son operadores binarios, en el sentido de que cada uno tiene un operando a la izquierda y un operando derecho. && se usa cuando los operandos izquierdo y derecho son expresiones, donde cada uno da como resultado verdadero o falso. Cualquiera de estas expresiones puede ser sustituido con verdadero o falso y se usa al manejar valores booleanos: Verdadero o Falso. y debe usarse cuando se requiere bit a bit y es necesario.