Nyanser av att arbeta med olika operatörer

1. Booleska operationer

Operatörerna |och &kan användas inte bara på siffror utan även på booleska uttryck.

Men, som du redan vet, det finns &&och ||operatörer. Varför skulle vi använda |istället för ||och &istället för &&? Finns det någon mening med detta? Det verkar som det finns. Ibland.

De logiska operatorerna exekveras från vänster till höger enligt en så kallad lazy-|| princip .&&

(expression1) || (expression2) || (expression3)

Om expression1 är lika med true, är det ingen idé att utvärdera expression2 och expression3: resultatet blir trueoavsett.

Följaktligen, vid utvärdering av uttryck (de utvärderas från vänster till höger), så snart vi får , truehoppas utvärderingen av resten av uttrycken över . Och om expression2 och expression3inkluderar metodanrop kommer dessa metoder inte att kallas !

Detsamma gäller för den &&logiska operatorn:

(expression1) && (expression2) && (expression3)

Om expression1är lika med false, är det ingen idé att utvärdera expression2och expression3: resultatet blir falseoavsett.

Detta är ett viktigt faktum som låter dig skriva saker som:

String s = null;
if (s != null && s.length() > 0) {

Exemplet ovan kommer aldrig att ge dig ett NullPointerException , eftersom s.length()det bara kommer att köras om den första delen s! = nullär true.

Om sär lika med , är nulldelen till vänster om operatorn , då är resultatet av hela det booleska uttrycket , så delen till höger ( ) utvärderas inte.&&falsefalses.length() > 0

2. Operationsprioritet i Java

Som du säkert minns från din matematikklass på gymnasiet har multiplikationsoperatorn högre företräde än additionsoperatorn. Parenteser har en ännu högre prioritet: uttryck inom parentes utvärderas först, sedan multiplikation och division, och sedan addition och subtraktion.

Operatörer i Java har också en prioritetsordning. Skillnaden är att a) det finns något fler av dem, b) för vissa operatörer utvärderas operanderna från vänster till höger, medan för andra - från höger till vänster.

Här är en tabell med alla Java-operatorer:

Den översta raden innehåller de operatorer som har högst företräde. Parenteser ()används för att uttryckligen ställa in prioritet. Hakparenteser []används för att komma åt ett element vid ett specifikt index för en matrisvariabel. Punktoperatorn ( .) används för att komma åt fält och metoder med hjälp av en referens till ett objekt eller en klass.

Ju lägre operatörerna är i tabellen, desto lägre har deras prioritet.

Om du använder flera operatorer i ett uttryck, var inte lat: lägg till parenteser.

I Java kan du skriva något som if (a & 1<< b > ~c), men du borde inte. Du skriver kod inte bara för kompilatorn utan även för andra programmerare. Ju mer läsbar koden är, desto bättre.

3. Prefix och postfix inkrement

Som du redan vet har Java en inkrementoperator ( ++) och en dekrementoperator ( --). De ökar respektive minskar värdet på en variabel med 1.

Vad du förmodligen inte vet är att det finns två typer av dessa operatorer: prefix (operatorn placeras före variabeln) och postfix (operatorn placeras efter variabeln). Och två sorters operatörer fungerar lite olika.

I Java kan du skriva ett uttryck så här:

int a = 5;
int b = a++;

Om ++operatorn visas efter en variabel och variabeln är en del av något uttryck (som i exemplet ovan), kommer uttrycket att använda det aktuella värdet på variabeln, och först efteråt kommer variabeln att ökas med 1.

Med andra ord, något sånt här kommer att hända:

int a = 5;
int b = a;
a = a + 1;

Det vill säga, bkommer att bli 5, inte 6som du kanske tror vid första anblicken.

Om ++operatorn är före variabeln och variabeln är en del av något uttryck, kommer den först att ökas med 1och först därefter kommer dess värde att användas i uttrycket.

int a = 5;
int b = ++a;

int a = 5;
a = a + 1;
int b = a;

Här bkommer att vara lika med 6.

Det finns till och med ett exempel som används av Java-programmerare för att avgöra om någon annan också är en Java-programmerare:

int a = 5;
int b = ++a + ++a;

Japp, det kan du också skriva.

Det här exemplet kommer att kompilera bra och förvandlas till något så här:

int a = 5;

a = a + 1;
int v1 = a;

a = a + 1;
int v2 = a;

int b = v1 + v2;

För --operatören är allt exakt sig likt.