En nybörjarhandbok för logiska och relationsoperatörer i Java

Operatörer är symboler som används för att utföra operationer på värden, variabler eller uttalanden. Uttrycken som de utför dessa åtgärder kallas för operander. Operationerna ger ett booleskt resultat (sant eller falskt) för relations-, jämlikhets- och logiska operatörer.

Antalet operander som en operatör tar bestämmer dess typ. En operatör som tar en operand kallas "unary". En operatör som tar två operander kallas "binär".

Läs vidare för att lära dig hur du kan använda logiska och relationsoperatörer i Java. Ännu bättre, de flesta programmeringsspråk använder samma operatörer så att du kan använda denna kunskap någon annanstans.

Logiska operatörer

De används för att bygga logiska uttalanden under programmeringen. Det finns sex logiska operatörer i Java. Tabellen nedan sammanfattar dem.

Operatör	namn	Typ
|	Boolesk logisk ELLER	Binär
&	Boolesk logisk OCH	Binär
^	Boolean Logical Exclusive ELLER	Binär
||	Villkorligt ELLER	Binär
&&	Villkorligt OCH	Binär
!	Logiskt INTE	Unary

Om du vill kontrollera om ett eller båda villkoren är sanna, använd den här operatören. Ett villkor är ett uttryck som antingen kan vara sant eller falskt.

Boolean Logical Inclusive ELLER (|)

Den logiska ELLER kontrollerar om båda operanderna är sanna innan uttrycket utvärderas.

if (dob <2005 | höjd <= 5) {
pengar ++;
}

Ovanstående exempel ger någon mer pengar om deras födelsedatum (dob) är mindre än 2005 eller om deras höjd är mindre än eller lika med 5 fot.

Boolean Logical AND (&)

Denna operatör används för att kontrollera om båda villkoren är uppfyllda innan de tar en viss körväg i programmet. Den kontrollerar först om båda villkoren är sanna innan hela utvärderingen utvärderas.

Relaterad: Hur man validerar strängar med hjälp av booleska metoder i Python

Boolean Logical Exclusive ELLER (^)

Om du vill kontrollera om något av villkoren är sant, men inte båda, är detta operatören att använda. Sanningstabellen nedan sammanfattar de resultat du ser när du använder den.

expression1	expression2	expression1 ^ expression2
falsk	falsk	falsk
falsk	Sann	Sann
Sann	falsk	Sann
Sann	Sann	falsk

Boolesk villkorad AND (&&)

Denna operatör liknar det logiska AND. Skillnaden är att den först kontrollerar om villkoret till vänster är sant innan du går vidare för att kontrollera det till höger.

Om den vänstra delen visar sig vara falsk, avbryts körningen omedelbart. I annat fall fortsätter utvärderingen av rätt del. Denna funktion kallas kortslutningsutvärdering.

Se sanningstabellen nedan för att förstärka din förståelse för denna operatör.

expression1	expression2	expression1 && expression2
falsk	falsk	falsk
falsk	Sann	falsk
Sann	falsk	falsk
Sann	Sann	Sann

Villkorligt ELLER (||)

Om något av villkoren är falskt hoppas körningen till nästa del av programmet. Med andra ord måste båda villkoren vara sanna.

Den här operatören liknar den logiska ELLER. Den kontrollerar också om endera eller båda villkoren är uppfyllda innan en viss kod körs.

I likhet med villkorligt AND använder den logiska OR också kortslutningsutvärdering. Den kontrollerar först om operanden till vänster är sant innan den utvärderas till höger.

Relaterad: Vad är en konstruktör i Java och hur använder du den?

Om villkoret till vänster visar sig vara sant, behöver du inte kontrollera det till höger. I annat fall fortsätter utvärderingen till höger.

Logiskt INTE (!)

Denna operatör används för att upphäva ett tillstånd. Det vänder helt enkelt innebörden av vad det fungerar på.

om (! (x> 5)) {
// uttalanden
}

Ovanstående uttalande betyder att om "x är större än 5" INTE är sant, kör sedan uttalandena i om.

Lägg märke till användningen av runda parenteser med uttrycket (x> 5). Om du inte inkluderar dessa parenteser när du skriver ditt program får du ett kompileringsfel. Anledningen är att ! är en unary operatör som agerar på ett villkor. Utan parenteser skulle kompilatorn tolka den som operatören som agerar på x, inte x> 5.

Inkluderingen av parenteser är inte bara för att kompilatorn ska kunna tolka ett uttryck korrekt. De kan också användas som ett sätt för programmeraren att bättre förstå mer komplexa uttryck. Titta på exemplet nedan:

ålder> = 7 && höjd <5

Vissa människor kan ha svårt att följa upp logiken. Därför föredrar vissa programmerare att lägga till överflödiga parenteser av läsbarhetsskäl:

(ålder> = 7) && (höjd <5)

Relationsoperatörer

Dessa operatörer används för att jämföra enkla relationer mellan operander.

Operatör	namn
>	Större än
<	Mindre än
>=	Större än eller lika med
<=	Mindre än eller lika med

Relationsoperatörer är ganska lätta att förstå eftersom de alla har samma betydelse som de vanliga algebraiska operatorerna du redan känner till. Det vill säga, > och < har samma betydelse som du redan känner till som den som ges i tabellen ovan.

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

Ovanstående om uttalande kontrollerar om x är mindre än eller lika med 7. Om det är sant, utförs uttalandena inom parentes, annars gör de det inte.

Nu skulle det vara en bra tid att nämna jämställdhetsoperatörer. Det finns bara två av dem (lika med, == och! =, Inte lika med). Som namnet antyder används de för att testa jämlikhet mellan två operander.

Relaterad: Hur man skapar och utför operationer på arrays i Java

Likhetsoperatören (==) ska inte förväxlas med uppdragsoperatören (=). Nybörjare programmerare är förtjust i att blanda ihop de två. Detta är rimligt eftersom symbolen (=) används i algebra för att uttrycka jämlikhet. Det är dock inte rätt i programmering.

Tilldelningsoperatören (=) tilldelar ett värde till en variabel medan jämställdhetsoperatören (==) testar för likhet. Se exemplet nedan för att förstå skillnaden:

om (x = 5) {
// uttalanden
}

Ovanstående kod kommer alltid att köras oavsett om x faktiskt är lika med 5. Under tiden körs koden nedan endast om x är lika med 5. Därför är det viktigt att inte blanda ihop de två.

om (x == 5) {
// uttalanden
}

De två nämnda jämställdhetsoperatörerna har samma företrädesnivå, dock lägre än relationsoperatörernas.

Relationsoperatörer har också samma företräde. Utförandet av dessa operatörer börjar från vänster till höger.

Ytterligare överväganden av Java-operatörer

Du måste ha observerat att det finns ett utrymme mellan vissa operatörer och deras operander i några av exemplen medan det i andra inte finns det.

Frånvaron / närvaron av det utrymmet borde inte oroa dig. Kompilatorn ignorerar det. Följande uttryck betyder därför samma sak:

Y> = 7 // inget tomt utrymme
Y> = 7 // med blanksteg

Relationsoperatörer används vanligtvis för att uttrycka enkla villkor. För att kombinera enkla förhållanden till mer komplexa måste du använda logiska operatorer. Logiska operatörer kan testa flera villkor, till skillnad från relationsoperatörer som bara testar ett villkor.

Det är också viktigt att notera att de logiska operatorerna (|, &, ^) kan vara bitvisa operatorer när de har integrerade operander. När de används som bitvisa operatörer kommer de att fungera på bitarna i sina operander.

Med denna kunskap från operatörer bör du nu vara redo att lära dig Java-klasser.

Lär dig hur du skapar klasser i Java

Om du lär dig att programmera i Java måste du veta hur du skapar klasser.

Läs Nästa

Om författaren