&& e e operatori in java

In java, && è chiamato condizionale e operatore. È un esempio di operatore logico in Java. Come un altro operatore, e ha due funzioni in Java. In una situazione, si chiama logico e operatore. Nell'altra situazione, è chiamato bitwise e operatore. Ognuno di questi operatori è un operatore binario. Ciò significa che ognuno ha un operando alla sua sinistra e alla sua destra. Il risultato di tutta tale espressione può essere assegnato a una variabile. Questi operatori lavorano con tipi primitivi e quindi la sua classe non deve essere importata dal programmatore.

La tabella della verità per ed è:

false e false = false
false e vero = false
vero e falso = falso
vero e vero = vero

Questo articolo spiega l'uso di questi tre operatori, a partire dal logico e operatore, e.

Logico e operatore

Un valore booleano è vero o falso. Questo operatore deve essere utilizzato, quando entrambi gli operandi sono valori booleani. Il seguente programma illustra questo:

Classe pubblica TheClass
public static void main (string [] args)
booleano bl1 = false & false; Sistema.fuori.println (bl1);
booleano bl2 = false e vero; Sistema.fuori.println (bl2);
booleano bl3 = true & false; Sistema.fuori.println (bl3);
booleano bl4 = true & true; Sistema.fuori.println (bl4);

In Java, un programma è un programmatore implementato di classe. Il nome del file del programma è il nome della classe. La classe dovrebbe avere il metodo principale (). Per questo programma, il nome della classe è, questo. Nel metodo principale () qui, ci sono quattro righe. Ogni riga corrisponde a una riga nella tabella e alla verità. Ogni riga stampa il suo risultato. L'output è:

falso
falso
falso
VERO

confermando che questa è e la logica.

Il condizionale e operatore, &&

L'operatore, && è un operatore e viene utilizzato in condizioni e condizioni di loop. Il suo operando sinistro è un'espressione di scopi generici e il suo operand destro è anche un'espressione di scopo generale. Il seguente programma illustra il suo stesso utilizzo, al di fuori della condizione if o loop:

Classe pubblica TheClass
public static void main (string [] args)
booleano bl1 = 1 == 0 && 1 == 0; Sistema.fuori.println (bl1);
booleano bl2 = 1 == 0 && 1 == 1; Sistema.fuori.println (bl2);
booleano bl3 = 1 == 1 && 1 == 0; Sistema.fuori.println (bl3);
booleano bl4 = 1 == 1 && 1 == 1; Sistema.fuori.println (bl4);

Nel metodo principale () qui, ci sono quattro righe. Ogni riga corrisponde a una riga nella tabella e alla verità. Nota gli operandi sinistra e destra per ogni operatore &&. Ognuno di questi operandi è un'espressione. Ognuna di queste espressioni si traduce in vero o falso. Quindi, una vera espressione avrebbe potuto essere sostituita con la parola nuda, vera, e una falsa espressione avrebbe potuto essere sostituita con la parola nuda, Falso. L'output è:

falso
falso
falso
VERO

confermando che questa è e la logica.

Il programma di cui sopra viene riscritto, in cui ogni riga di interesse, è una dichiarazione IF-Cpound:

Classe pubblica TheClass
public static void main (string [] args)
if (1 == 0 && 1 == 0).fuori.println (true); altro sistema.fuori.println (false);
if (1 == 0 && 1 == 1) Sistema.fuori.println (true); altro sistema.fuori.println (false);
if (1 == 1 && 1 == 0).fuori.println (true); altro sistema.fuori.println (false);
if (1 == 1 && 1 == 1) Sistema.fuori.println (true); altro sistema.fuori.println (false);

Nel metodo principale () qui, ci sono quattro righe. Ogni riga corrisponde a una riga nella tabella e alla verità. Nota gli operandi sinistra e destra per ogni operatore &&. Ognuno di questi operandi è un'espressione. Ognuna di queste espressioni si traduce in vero o falso. Quindi, una vera espressione avrebbe potuto essere sostituita con la parola nuda, vera, e una falsa espressione avrebbe potuto essere sostituita con la parola nuda, Falso. L'output è:

falso
falso
falso
VERO

confermando che questa è e la logica.

Il bitwise e l'operatore, e

La tabella e della verità con bit è:

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

& è l'operatore e per bit, così come l'operatore e per i valori booleani.

Ora 1111111100000000 in esadecimale è 0xFF00 e in decimale è 65280.

Inoltre, 1111000011110000 in esadecimale è 0xf0f0 e in decimale è 61680.

Inoltre, 1111000000000000 in esadecimale è 0xf000 e in decimale è 61440.

Decimale significa base 10.

I numeri binari e il bit bit sono chiamati bitwise anding, e l'operatore per questo è &. COSÌ

111111111000000 e 1111000011110000 = 1111000000000000

La stessa cosa si applica ai corrispondenti numeri esadecimali. Questo è:

0xFF00 e 0xf0f0 = 0xf000

La stessa cosa si applica ai loro corrispondenti numeri decimali. Questo è:

65280 e 61680 = 61440

L'operatore bitwise viene normalmente utilizzato con numeri esadecimali o numeri decimali.

Bitwise e (&) con numeri esadecimali

Il seguente programma BitWises 0xFF00 e 0xFF00 per avere 0xf000:

Classe pubblica TheClass
public static void main (string [] args)
int num1 = 0xff00;
int num2 = 0xf0f0;
int num3 = num1 e num2;
Sistema.fuori.println (num3);

Num1 e Num2 sono dichiarati e inizializzati con numeri esadecimali. La terza affermazione fa il bitwise e, usando &, per questi numeri esadecimali. L'ultima dichiarazione stampica il risultato. L'output è 61440, che è l'equivalente decimale del previsto, 0xf000.

Bitwise e (&) con numeri decimali

Il seguente programma Bitwise 65280 e 61680 ha 61440 (tutti i numeri decimali):

Classe pubblica TheClass
public static void main (string [] args)
int Num1 = 65280;
int Num2 = 61680;
int num3 = num1 e num2;
Sistema.fuori.println (num3);

Num1 e Num2 sono dichiarati e inizializzati con numeri decimali. La terza affermazione fa il bitwise e, usando &, per questi numeri decimali. L'ultima dichiarazione stampica il risultato. L'uscita è 61440, che è l'equivalente decimale del binario 1111000000000000.

Conclusione

In java, && è chiamato condizionale e operatore. In Java, ed è l'operatore logico e anche l'operatore bitwise. Questi tre operatori sono operatori binari, nel senso che ognuno ha un operando sinistro e un operando destro. && viene utilizzato quando gli operandi sinistra e destra sono espressioni, dove ciascuno si traduce in vero o falso. Una di queste espressioni può effettivamente essere sostituita con vero o falso e viene utilizzata durante la gestione dei valori booleani: vero o falso. e deve essere utilizzato quando bit ed è richiesto.