En nybörjarguide till logiska och relationsoperatörer i Java

Operatörer är symboler som används för att utföra operationer på värden, variabler eller satser. Uttrycken som de utför dessa åtgärder på kallas operander. Operationerna returnerar ett booleskt resultat (sant eller falskt) för relationella, likvärdiga 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 relationsoperatorer i Java. Ännu bättre, de flesta programmeringsspråk använder samma operatörer så att du kan tillämpa denna kunskap någon annanstans.

Logiska operatörer

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

Operatör	namn	Typ
\|	Boolsk logisk ELLER	Binär
&	Booleansk logisk OCH	Binär
^	Boolean Logical Exclusive ELLER	Binär
\|\|	Villkorlig ELLER	Binär
&&	Villkorlig 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 (|)

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

if ( dob <2005 | height <= 5){  
money++;  
}

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

Booleansk logisk OCH (&)

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

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

Boolean Logical Exclusive ELLER (^)

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

uttryck1	uttryck2	expression1 ^ expression2
falsk	falsk	falsk
falsk	Sann	Sann
Sann	falsk	Sann
Sann	Sann	falsk

Boolskt villkorat OCH (&&)

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

Om det visar sig att den vänstra delen är falsk stoppas körningen omedelbart. Annars fortsätter utvärderingen av rätt del. Denna funktion är känd som kortslutningsutvärdering.

Se sanningstabellen nedan för att underbygga din förståelse av denna operatör.

uttryck1	uttryck2	expression1 && expression2
falsk	falsk	falsk
falsk	Sann	falsk
Sann	falsk	falsk
Sann	Sann	Sann

Villkorlig 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.

Denna operatör liknar den logiska ELLER. Det kontrollerar också om antingen en eller båda villkoren är sanna innan viss kod körs.

I likhet med villkorat OCH använder den logiska ELLER också kortslutningsutvärdering. Den kontrollerar först om operanden till vänster är sann innan den utvärderas till höger.

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

den här enheten kanske inte stöds

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

Logiskt INTE (!)

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

if(!(x>5)){  
// statements  
}

Ovanstående påstående betyder att om 'x är större än 5' INTE är sant, kör sedan påståendena inuti om .

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

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

age >= 7 && height <5

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

(age >= 7) && (height <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

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

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

Ovanstående om sats kontrollerar om x är mindre än eller lika med 7. Om det är sant, utförs satserna 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å matriser i Java

Jämställdhetsoperatören (==) får inte förväxlas med uppdragsoperatören (=). Nybörjarprogrammerare gillar att blanda ihop de två. Detta är rimligt eftersom symbolen (=) i algebra används för att uttrycka jämlikhet. Det är dock inte rätt i programmering.

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

if(x=5){  
// statements  
}

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

if(x==5){  
// statements  
}

De två nämnda jämställdhetsoperatörerna har samma prioritet, men lägre än de för relationsoperatörer.

Relationsoperatörer har också samma prioritet. 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 mellanrum 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 bör inte oroa dig. Kompilatorn kommer att ignorera det. Därför betyder följande uttryck samma sak:

Y>=7 // no whitespace  
Y >= 7 // with whitespace

Relationsoperatörer används vanligtvis för att uttrycka enkla förhållanden. 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 relationsoperatorer 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 deras operander.

Med denna kunskap om operatörer bör du nu förbereda dig på att lära dig Java -klasser.

Dela med sig Dela med sig Tweet E-post Lär dig hur du skapar klasser i Java

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

Läs Nästa Relaterade ämnen

Programmering
Java
Handledning för kodning

Om författaren Jerome Davidson(22 artiklar publicerade)

Jerome är personalförfattare på MakeUseOf. Han täcker artiklar om programmering och Linux. Han är också en kryptoentusiast och håller alltid koll på kryptoindustrin.

Mer från Jerome Davidson

Prenumerera på vårt nyhetsbrev

Gå med i vårt nyhetsbrev för tekniska tips, recensioner, gratis e -böcker och exklusiva erbjudanden!

Klicka här för att prenumerera