&& og & operatører i Java

I Java, && kalles den betingede og operatøren. Det er et eksempel på en logisk operatør i Java. Som en annen operatør, og har to funksjoner i Java. I en situasjon kalles det en logisk og operatør. I den andre situasjonen kalles det bitvis og operatør. Hver av disse operatørene er en binær operatør. Dette betyr at hver har en operand på venstre side og til høyre. Resultatet av alt dette uttrykket kan tilordnes en variabel. Disse operatørene jobber med primitive typer, og derfor trenger ikke klassen å importeres av programmereren.

Sannhetsbordet for og er:

falsk og falsk = falsk
falsk og sann = falsk
sant og usant = falsk
sant og sant = sant

Denne artikkelen forklarer bruken av disse tre operatørene, som begynner med den logiske og operatøren, og.

Logisk og operatør

En boolsk verdi er enten sann eller falsk. Denne operatøren skal brukes når begge operandene er boolske verdier. Følgende program illustrerer dette:

public class theclass
public static void main (String [] args)
boolean bl1 = falsk og falsk; System.ute.println (BL1);
Boolean BL2 = falsk og sann; System.ute.println (BL2);
Boolean BL3 = True & False; System.ute.println (BL3);
Boolean BL4 = True & True; System.ute.println (BL4);

I Java er et program en programmerer implementert klasse. Navnet på programfilen er klassenavnet. Klassen skal ha Main () -metoden. For dette programmet er navnet på klassen, theclass. I hovedmetoden () her er det fire linjer. Hver linje tilsvarer en linje i og sannhetstabellen. Hver linje skriver ut resultatet. Utgangen er:

falsk
falsk
falsk
ekte

bekrefter at dette er og logikk.

Den betingede og operatøren, &&

Operatøren, && er en og operatør, og den brukes i IF-kondisjoner og sløyfekondisjoner. Dens venstre operand er et generelt uttrykk for generell hensikt, og dens høyre operand er også et uttrykk for generell hensikt. Følgende program illustrerer den samme bruken, utenfor IF eller Loop -tilstanden:

public class theclass
public static void main (String [] args)
boolean bl1 = 1 == 0 && 1 == 0; System.ute.println (BL1);
boolean bl2 = 1 == 0 && 1 == 1; System.ute.println (BL2);
boolean bl3 = 1 == 1 && 1 == 0; System.ute.println (BL3);
boolean bl4 = 1 == 1 && 1 == 1; System.ute.println (BL4);

I hovedmetoden () her er det fire linjer. Hver linje tilsvarer en linje i og sannhetstabellen. Legg merke til venstre og høyre operander for hver && operatør. Hver av disse operandene er et uttrykk. Hvert av disse uttrykkene resulterer i sant eller usant. Så et sant uttrykk kunne ha blitt erstattet med det nakne ordet, sant og et falskt uttrykk kunne ha blitt erstattet med det nakne ordet, falskt. Utgangen er:

falsk
falsk
falsk
ekte

bekrefter at dette er og logikk.

Ovennevnte program er omskrevet, der hver interesseinje, er en if-compound-uttalelse:

public class theclass
public static void main (String [] args)
if (1 == 0 && 1 == 0) system.ute.println (sant); annet system.ute.println (falsk);
if (1 == 0 && 1 == 1) system.ute.println (sant); annet system.ute.println (falsk);
if (1 == 1 && 1 == 0) system.ute.println (sant); annet system.ute.println (falsk);
if (1 == 1 && 1 == 1) system.ute.println (sant); annet system.ute.println (falsk);

I hovedmetoden () her er det fire linjer. Hver linje tilsvarer en linje i og sannhetstabellen. Legg merke til venstre og høyre operander for hver && operatør. Hver av disse operandene er et uttrykk. Hvert av disse uttrykkene resulterer i sant eller usant. Så et sant uttrykk kunne ha blitt erstattet med det nakne ordet, sant og et falskt uttrykk kunne ha blitt erstattet med det nakne ordet, falskt. Utgangen er:

falsk
falsk
falsk
ekte

bekrefter at dette er og logikk.

Den bitvise og operatøren, og

Og sannhetstabellen med biter er:

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

& er og operatøren for biter, så vel som det er og operatøren for boolske verdier.

Nå 1111111100000000 i heksadesimal er 0xff00, og i desimal er det 65280.

1111000011110000 i heksadesimal er 0xf0f0, og i desimal er det 61680.

1111000000000000 i heksadesimal er 0xf000, og i desimal er det 61440.

Desimal betyr base 10.

Og binære tall bit-for-bit kalles bitwise anding, og operatøren for dette er &. Så

1111111100000000 & 1111000011110000 = 1111000000000000

Det samme gjelder deres tilsvarende heksadesimale tall. Det er:

0xff00 & 0xf0f0 = 0xf000

Det samme gjelder deres tilsvarende desimaltall. Det er:

65280 & 61680 = 61440

Den bitvise operatøren brukes normalt med heksadesimale tall eller desimaltall.

Bitvis og (&) med heksadesimale tall

Følgende program bitwises 0xff00 & 0xff00 til å ha 0xf000:

public class theclass
public static void main (String [] args)
int num1 = 0xff00;
int num2 = 0xf0f0;
int num3 = num1 & num2;
System.ute.println (num3);

NUM1 og NUM2 er erklært og initialisert med heksadesimale tall. Den tredje uttalelsen gjør bitvis, og bruker &, for disse heksadesimale tallene. Den siste uttalelsen skriver ut resultatet. Utgangen er 61440, som er desimalekvivalenten til den forventede, 0xf000.

Bitvis og (&) med desimaltall

Følgende program bitwises 65280 & 61680 for å ha 61440 (alle desimaltall):

public class theclass
public static void main (String [] args)
int num1 = 65280;
int num2 = 61680;
int num3 = num1 & num2;
System.ute.println (num3);

NUM1 og NUM2 er erklært og initialisert med desimaltall. Den tredje uttalelsen gjør bitvis, og bruker &, for disse desimaltallene. Den siste uttalelsen skriver ut resultatet. Utgangen er 61440, som er desimalekvivalenten til binær 1111000000000000.

Konklusjon

I Java, && kalles den betingede og operatøren. I Java, og er den logiske og operatøren og også den bitvis operatøren. Disse tre operatørene er binære operatører, i den forstand at hver har en venstre operand og en høyre operand. && brukes når venstre og høyre operander er uttrykk, der hver resulterer i ekte eller usant. En av disse uttrykkene kan faktisk erstattes med ekte eller usant og brukes når du håndterer boolske verdier: Sann eller falsk. og må brukes når bitvis og er påkrevd.