En begyndervejledning til logiske og relationsoperatører i Java

Operatører er symboler, der bruges til at udføre operationer på værdier, variabler eller udsagn. Udtrykkene, som de udfører disse handlinger på, kaldes operander. Operationerne returnerer et boolesk resultat (sand eller falsk) for relationelle, lighed og logiske operatører.

Antallet af operander, som en operatør tager, bestemmer dens type. En operatør, der tager en operand, kaldes "unary". En operatør, der tager to operander kaldes "binær".

Læs videre for at lære, hvordan du kan bruge logiske og relationelle operatører i Java. Endnu bedre, de fleste programmeringssprog bruger de samme operatorer, så du kan anvende denne viden andre steder.

Logiske operatører

De bruges til at opbygge logiske udsagn under programmering. Der er seks logiske operatører i Java. Tabellen nedenfor opsummerer dem.

Operatør	Navn	Type
|	Boolsk logisk ELLER	Binær
&	Boolsk logisk OG	Binær
^	Boolsk logisk eksklusiv ELLER	Binær
||	Betinget ELLER	Binær
&&	Betinget OG	Binær
!	Logisk IKKE	Unary

Hvis du vil kontrollere, om en eller begge betingelser er sande, skal du bruge denne operatør. En betingelse er et udtryk, der enten kan være sandt eller falsk.

Boolsk logisk inkluderende ELLER (|)

Den logiske ELLER kontrollerer, om begge operander er sande, før udtrykket evalueres.

hvis (dob <2005 | højde <= 5) {
penge ++;
}

Ovenstående eksempel giver nogen flere penge, hvis deres fødselsdato (dob) er mindre end 2005, eller hvis deres højde er mindre end eller lig med 5 fod.

Boolsk logisk AND (&)

Denne operatør bruges til at kontrollere, om begge betingelser er sande, inden de tager en bestemt eksekveringssti i programmet. Først kontrolleres det, om begge betingelser er sande, før det evalueres hele udtrykket.

Relaterede: Sådan valideres strenge ved hjælp af boolske metoder i Python

Boolsk logisk eksklusiv ELLER (^)

Hvis du vil kontrollere, om en af ​​betingelserne er rigtige, men ikke begge dele, er dette operatøren, der skal bruge. Sandhedstabellen nedenfor opsummerer de resultater, du ser, når du bruger den.

udtryk1	udtryk2	udtryk1 ^ udtryk2
falsk	falsk	falsk
falsk	rigtigt	rigtigt
rigtigt	falsk	rigtigt
rigtigt	rigtigt	falsk

Boolsk betinget AND (&&)

Denne operatør ligner den logiske AND. Forskellen er, at den først kontrollerer, om tilstanden til venstre er sand, inden den går videre for at kontrollere den til højre.

Hvis den venstre del viser sig at være falsk, stopper udførelsen med det samme. Ellers fortsætter evalueringen af ​​den rigtige del. Denne funktion kaldes kortslutningsevaluering.

Se sandhedstabellen nedenfor for at begrænse din forståelse af denne operatør.

udtryk1	udtryk2	expression1 && expression2
falsk	falsk	falsk
falsk	rigtigt	falsk
rigtigt	falsk	falsk
rigtigt	rigtigt	rigtigt

Betinget ELLER (||)

Hvis en af ​​betingelserne er falske, springer eksekveringen til den næste del af programmet. Med andre ord skal begge betingelser være sande.

Denne operatør ligner den logiske ELLER. Det kontrollerer også, om den ene eller begge betingelser er sande, før den udfører en bestemt kode.

I lighed med den betingede AND bruger den logiske OR også kortslutningsevaluering. Den kontrollerer først, om operanden til venstre er sand, inden den evalueres til højre.

Relaterede: Hvad er en konstruktør i Java, og hvordan bruger du det?

Hvis tilstanden til venstre viser sig at være sand, er der ingen grund til at kontrollere den højre. Ellers fortsætter evalueringen til højre.

Logisk IKKE (!)

Denne operatør bruges til at ophæve en tilstand. Det vender simpelthen betydningen af, hvad det fungerer på.

hvis (! (x> 5)) {
// udsagn
}

Ovenstående udsagn betyder, at hvis "x er større end 5" IKKE er sandt, skal du udføre udsagnene inde i hvis.

Bemærk brugen af ​​runde parenteser med udtrykket (x> 5). Hvis du ikke inkluderer disse parenteser, mens du skriver dit program, får du en kompileringstidsfejl. Årsagen er, at ! er en unary operatør, der handler på en betingelse. Uden parenteserne fortolker compileren det som operatøren, der handler på x, ikke x> 5.

Inkluderingen af ​​parenteser er ikke kun for at gøre det muligt for compileren at fortolke et udtryk korrekt. De kan også bruges som en måde, hvorpå programmøren bedre kan forstå mere komplekse udtryk. Se eksemplet nedenfor:

alder> = 7 && højde <5

Nogle mennesker har måske svært ved at følge logikken. Derfor foretrækker nogle programmører at tilføje overflødige parenteser af læsbarhedsårsager:

(alder> = 7) && (højde <5)

Relationelle operatører

Disse operatører bruges til at sammenligne enkle relationer mellem operander.

Operatør	Navn
>	Bedre end
<	Mindre end
>=	Større end eller lig med
<=	Mindre end eller lig med

Relationsoperatører er ret lette at forstå, fordi de alle har samme betydning som de sædvanlige algebraiske operatorer, som du allerede er bekendt med. Det vil sige, > og < har den samme betydning, som du allerede kender som den, der er angivet i tabellen ovenfor.

hvis (x <= 7) {
x ++;
}

Ovenstående hvis erklæring kontrollerer, om x er mindre end eller lig med 7. Hvis det er sandt, udføres udsagnene inden for parenteserne, ellers gør de det ikke.

Nu ville det være et godt tidspunkt at nævne ligestillingsoperatører. Der er kun to af dem (lig med = = og! =, Ikke lig med). Som deres navn antyder, er de vant til at teste lighed mellem to operander.

Relaterede: Sådan oprettes og udføres operationer på arrays i Java

Lighedsoperatoren (==) må ikke forveksles med opgaveoperatøren (=). Begynderprogrammerere er glade for at blande de to sammen. Dette er rimeligt, da symbolet (=) i algebra bruges til at udtrykke lighed. Det er dog ikke rigtigt i programmeringen.

Tildelingsoperatoren (=) tildeler en variabel en værdi, mens lighedsoperatoren (==) tester for lighed. Se eksemplet nedenfor for at forstå forskellen:

hvis (x = 5) {
// udsagn
}

Ovenstående kode udføres altid, uanset om x faktisk er lig med 5. I mellemtiden udføres koden nedenfor kun, hvis x er lig med 5. Derfor er det vigtigt ikke at blande de to sammen.

hvis (x == 5) {
// udsagn
}

De to nævnte ligestillingsoperatører har samme forrang, dog lavere end relationelle operatører.

Relationsoperatører har også samme forrang. Udførelsen af ​​disse operatører begynder fra venstre mod højre.

Yderligere overvejelser om Java-operatører

Du skal have observeret, at der er mellemrum mellem nogle operatører og deres operander i nogle af eksemplerne, mens det i andre ikke er det.

Fraværet / tilstedeværelsen af ​​dette rum bør ikke bekymre dig. Compileren ignorerer det. Derfor betyder følgende udtryk det samme:

Y> = 7 // intet mellemrum
Y> = 7 // med mellemrum

Relationsoperatører bruges generelt til at udtrykke enkle forhold. For at kombinere enkle forhold til mere komplekse, skal du bruge logiske operatorer. Logiske operatører kan teste flere betingelser, i modsætning til relationelle operatører, der bare tester en betingelse.

Det er også vigtigt at bemærke, at de logiske operatorer (|, &, ^) kan være bitvise operatorer, når de har integrerede operander. Når de bruges som bitvise operatorer, fungerer de på bitene af deres operander.

Med denne viden fra operatører skal du nu være klar til at lære Java-klasser.

Lær hvordan du opretter klasser i Java

Hvis du lærer at programmere i Java, skal du vide, hvordan du opretter klasser.

Læs Næste

Om forfatteren