Operatörsföreträde - 1

"Hej, Bilaabo!"

"Bilaabo hälsar gärna sin vän!"

"I dag kommer Bilaabo att berätta om operatörernas företräde. Men först kommer han att berätta om operatörerna själva."

"Vilka är de här operatörerna du pratar om?"

"Du är faktiskt redan bekant med dem. Du kanske inte visste att de kallas operatörer."

"Säg till exempel att vi har uttrycket  c = a + b; "

"Den har två operatörer: en tilläggsoperatör och en uppdragsoperatör."

"Med andra ord, operatorer är bara matematiska tecken? Som multiplikation, division och addition?"

"Ja, det är sant. Men det finns skillnader."

"Jag kommer inte att definiera operatörer för dig: en definition kommer inte att göra dig smartare. Det är bättre att se dem i aktion. Operatörer kan delas in i flera grupper, som vi ska undersöka nu."

1) " Matematiska operatorer "

Symbol Exempel namn Beskrivning (vad den gör)
+ a + b Tilläggsoperatör Tilläggsoperatör.
- c - d Subtraktionsoperatör Subtraherar det andra talet från det första.
* a * t Multiplikationsoperator Multiplicerar två tal.
/ a / b Divisionsoperatör Dividerar det första talet med det andra.
% c % d Dividerar det första talet med det andra. Beräknar resten efter att ha dividerat det första talet med det andra.
- -a Unär minus Ändrar variabelns tecken till dess motsats.
Plus till minus och minus till plus.
+ +a Unärt plus Ändrar ingenting. Detta lades till för att komplimentera den unära minusoperatorn. Det är bara för utseendet.

"Jag känner igen dessa från skolan. Min firmware inkluderar skolkurser."

"Men vad är det med det där procenttecknet, någon sorts trolldom?"

"Det är operatorn " resterande efter division ". Om 11 delas med 5 får vi 2 och resten av 1. Denna 1 kan erhållas genom att skriva 11 % 5;"

"När du delar heltal i Java blir resultatet också ett heltal. Resten från divisionsoperationen ignoreras helt enkelt. Om vi ​​delar 8 med 5 får vi 1."

Uttryck Resultat
19 / 10 1 Om vi ​​delar 19 med 10 blir resultatet 1 med resten av 9.
19 % 10 9 Om vi ​​delar 19 med 10 blir resultatet 1 med resten av 9.
2 / 5 0 Om vi ​​dividerar 2 med 5  blir resultatet 0 med resten av 2.
16 % 2 0 Om vi ​​dividerar 16 med 2 blir resultatet 8 med resten av 0.

"Men vad i hela friden behöver vi resten till?"

"Anta att du behöver kontrollera om ett heltal är jämnt. Sedan kan du skriva:"

if (a % 2 == 0)

"Och om du behöver kontrollera om b är udda kan du skriva:"

if (b % 2 == 1)

"Eller för att kontrollera om d är delbart med 3:"

if (d % 3 == 0)

"Intressant. Jag kommer ihåg det."

2)  " Jämförelseoperatorer "

Symbol Exempel namn Beskrivning (vad den gör)
< a < b Mindre än Kontrollerar om a är mindre än b.
<= c <= d Mindre än eller lika med Kontrollerar om c är mindre än eller lika med d.
> a > b Större än Kontrollerar om a är större än b.
>= c >= d Större än eller lika med Kontrollerar om c är större än eller lika med d.
== i == j lika Kontrollerar om i är lika med j.
!= a != 0 Inte lika med Kontrollerar om a inte är lika med noll.

"Jag använder redan alla dessa."

"Och vad är den största skillnaden mellan dessa operatorer och de matematiska operatorerna?"

"Om vi ​​adderar två tal får vi ett tal, men om vi jämför två tal får vi sant eller falskt."

"Det stämmer. Resultatet av en jämförelse är ett " logiskt värde " värde, som, som du vet, representeras av den booleska typen. Det finns två möjligheter: sant eller falskt.

"Japp, det är helt klart. Jag vet det redan."

3) " Logiska operatorer "

Symbol Exempel namn Beskrivning (vad den gör)
&& a && b OCH Uttryckets resultat är sant endast när både a och b är sanna.
|| c || d ELLER Uttryckets resultat är sant om antingen a eller b är sant. Båda eller åtminstone en.
! !a INTE Uttryckets resultat är bara sant om a är falskt.

"Logiska operatorer kan endast användas med booleska variabler eller uttryck."

Exempel Beskrivning
boolean a = true;
boolean b = true;if (a && b)
Om-villkoret är sant om båda värdena är sanna
Med andra ord, om både a och b är sanna är resultatet sant .
boolean a = true;
boolean b = false;if (a || b)
Om-villkoret är sant om minst ett värde är sant.
Med andra ord, om antingen a eller b är sant, är resultatet sant .
boolean b = false;

if (!b)

Om-villkoret är sant om b inte är sant.
Med andra ord, om   b är falskt är resultatet  sant .
int a = 2, b = 3, c = 4;

if (a < b && a < c)
if ((a < b) && (a < c))

Om a är mindre än b och a är mindre än c, är uttryckets resultat sant.
a, b och c är heltal, men resultatet av att jämföra heltal är ett logiskt värde (sant, falskt), vilket betyder att vi kan använda logiska operatorer.

"Jag vet allt det här redan."

"Verkligen? Låt oss fortsätta då."

4) " Bitvisa operatorer "

Symbol Exempel namn Beskrivning (vad den gör)
& a & b OCH Bitvis OCH
| c | d ELLER Bitvis ELLER
~ ~a INTE Bitvis INTE
^ a ^ b XOR Bitvis "EXKLUSIVT ELLER"

" Bitvisa operatorer utför bit-för-bit-operationer på heltal."

"Vad är det?"

"Varje tal representeras som en uppsättning bitar, och sedan beräknas resultatet enligt följande:"

"Om den första biten av båda talen är 1, så blir resultatets första bit 1."

"Om den andra biten av båda talen är 1, blir resultatets andra bit 1. Och så vidare."

"Är det sant för alla bitvisa operatorer?"

"Det är mycket enklare än så. En bit kan bara ha två värden, 0 och 1, eller hur?"

"Höger."

"Tänk sedan på 1 som sant och 0 som falskt. Operationer på enskilda bitar kommer då att vara nästan identiska med logiska operationer:"

Logiskt uttryck Bitvis uttryck
sant && sant == sant 1&1 == 1
sant && falskt == falskt 1&0 == 0
sant || sant == sant 1|1 == 1
sant || falskt == sant 1|0 == 1
falskt || falsk = falsk 0|0 == 0
!falskt == sant ~0 == 1
!sant == falskt ~1 == 0

"Åh! Det är så lätt."

"Ja, glöm bara inte att bitvisa operationer använder motsvarande bitar från två nummer."

"Ja, jag kommer ihåg: den första biten i ett nummer paras ihop med den första biten i den andra, och resultatet skrivs också till den första biten. Och detsamma gäller resten av bitarna."

"Det stämmer. Har du några andra frågor?"

"Vad är det med XOR och 'exklusivt eller'?"

"Det är en piece of cake: när värdena är olika är det sant; när de är samma är det falskt."

Logiskt uttryck Bitvis uttryck
sant XELLER sant == falskt 1 ^ 1 == 0
false XOR false == false 0 ^ 0 == 0
sant XELLER falskt == sant 1 ^ 0 == 1
falskt XELLER sant == sant 0 ^ 1 == 1

Här är ytterligare ett par exempel på bitvisa operationer:

Exempel Siffror som bitar Resultat som bitar Resultat
5 & 3 0000010 1  & 0000001 1 0000000 1 1
7 & 2 000001 1 1 & 000000 1 0 00000010 2
5 | 9 00000 1 0 1  | 0000 1 00 1 00001101 13
5 ^ 9 00000 101  ^ 00001001 0000 1100 12
~9 ~ 00001001 11110110 246

"Tack, Bilaabo. Nu vet jag."

"Det finns ytterligare en grupp bitvisa operatorer, skiftoperatorerna:"

5) " Skiftoperatorer "

Symbol Exempel namn Beskrivning (vad den gör)
>> a >> b höger skift Flyttar bitarna i talet a åt höger med b-siffror.
<< c << d vänster Shift Flyttar bitarna av talet c åt vänster med d siffror.
>>> a >>> 2 osignerat högerskifte Flyttar bitarna i talet a åt höger med 2 siffror.

"Vad är det här för gatumagi?"

"Det är faktiskt allt väldigt enkelt. Kolla in det:"

Exempel Siffror som bitar Resultat som bitar Resultat
10 >> 1 0000 101 0 >> 1 00000 101 5
10 >> 2 0000 101 0 >> 2 000000 10 2
10 << 1 0000 101 0 << 1 000 101 00 20
10 << 2 0000 101 0 << 2 00 101 000 40

"Att flytta ett tals bitar åt vänster med 1 är detsamma som att multiplicera talet med 2. Att flytta med två siffror motsvarar multiplikation med 4, med tre siffror - multiplikation med 8, och så vidare."

"Att skifta åt höger motsvarar att dividera med 2, 4, 8, 16, etc."

"Men vad är skillnaden mellan >>> och >> operatörerna?"

"De skiljer sig åt när man arbetar med negativa tal. Detta beror på att  tecken med tecken använder biten längst till vänster för att indikera tecknet. Som ett resultat av detta slutar ett negativt tal att vara negativt när man växlar till höger. Så de kom på två olika operatorer. Kolla in det:"

Uttryck Resultat Beskrivning
1 000 1010 >> 1 11 000 101 Det negativa talet förblir negativt.
För negativa tal fylls de inkommande bitarna med 1:or.
1 000 1010 >> 2 111 000 10
1 000 1010 >> 3 1111 000 1
1 000 1010 >>> 1 01 000 101 Det negativa talet är inte längre negativt. För negativa tal fylls de inkommande bitarna med nollor.
1 000 1010 >>> 2 001 000 10
1 000 1010 >>> 3 0001 000 1

"Skiftet är inte cykliskt. Bitar som rör sig bortom den vänstra eller högra kanten av numret kasseras helt enkelt."

6) " Uppdragsoperatörer "

"Jag vet redan vad uppdrag är. Men varför säger du "operatörer"?"

"För att det finns flera av dem ☺"

Operatör Vad det betyder
a += b; a = a + b;
a -= b; a = a - b;
a *= b; a = a * b;
a %= b; a = a % b;
a |= b; a = a | b;
a &= b; a = a & b;

"Jag tror att du förstår logiken."

7) " Öka och minska operatörer "

Notation Exempel Beskrivning
++ a++;
++b;
Ökar antalet med 1.
-- d--;
--i;
Minskar talet eller variabeln med 1.

"Är det någon skillnad mellan att sätta de två minustecknen före eller efter variabeln?"

"Ja, det finns, men inte särskilt stort. Om en variabel med en av dessa operatorer är en del av ett uttryck eller tilldelning, så finns det skillnader. Jag skulle hellre visa dig med exempel:"

Exempel Vad händer egentligen Beskrivning
int a = 3;
int b = ++a;
int a = 3;
a = a + 1;
int b = a;
a ökas först med 1, och sedan används det i uttrycket.
int a = 3;
int b = a++;
int a = 3;
int b = a;
a = a + 1;
a används först i uttrycket och ökar sedan med 1.
int a = 3;
return a++;
int a = 3;
int result = a;
a = a + 1;
return result;
Funktionen returnerar 3, men värdet på a kommer att ökas med 1.
int x = 5;
x = ++x + ++x;
int x = 5;
int a = x + 1;// The first term is 6
x = a;
int b = x + 1;// The second term is 7
x = b;
x = a + b;
Resultatet här är 13. Först ökar x med 1, och detta värde kommer att ersätta den första termen, och sedan ökar x igen med 1.

"Wow! Det är coolt!"

"Jag är glad att du gillade det. Men om det inte finns något uttryck eller uppdrag, så finns det inga skillnader:"

"x++ är ekvivalent med x = x + 1."

"++x är ekvivalent med x = x + 1."

"Jag ska ha det i åtanke. Tack, Bilaabo."

8)  " Ternär operatör "

"Den här operatorn använder inte bara en eller två variabler eller uttryck. Den använder tre variabler eller uttryck samtidigt:"

Notation Motsvarande kod:
a ? b : c; if (a)
b
else
c
int min = a < b ? a : b; if (a < b)
min = a;
else
min = b;
return a != null ? a.length : 0; if (a != null)
return a.length;
else
return 0;

"Tja, det är super bekvämt."

"Ja. Och den är kompakt och koden är läsbar. Njut av att använda den!"

9) " Annan "

"Oavsett hur välorganiserad din musiksamling är, måste du fortfarande skapa en "Övrigt"-mapp."

"Ja, alla som någonsin har behövt kategorisera musik skulle helt hålla med."

"Så, det finns ytterligare tre operatörer jag vill berätta om:"

Notation Exempel Beskrivning
() (a + b) * c Parenteser ökar operatörens företräde.
Saker inom parentes exekveras först.
[] c [i] = c [i + 1]; Få ett arrayelement efter index.
. int n = a.length; " Punktoperatorn " kommer åt ett objekts variabler och metoder.

"Och slutligen, här är en tabell som sammanfattar operatörsföreträde:"

Operatörer Exempel
Högsta prioritet (operatörer exekveras enligt deras ordning i denna tabell)
()
[]
.
(a + b)
c [i] = c [i] + 1
++
--
~
!
+
-
i++; ++i;
--j; a--;
~c
!f
return +a;
return -a;
*
/
%
a * b
c / d
a % b
+
-
a + b
c - d
String s = "count"+"35";
>>
<<
>>>
a >> 3
b << 2
c >>> 3
<
<=
>
>=
a < b
a <= b
c > b
c >= b
==
!=
a == 3
a != 0
& a & 7
^ a ^ b
| a | b
&& (a < b) && (a < c)
|| (b != 0) || (c != 0)
? : = a > 0 ? a : -a;
=
*=, /=, %=
-=, +=
<<=. >>=, >>>=
&=, ^=. |=
Lägsta prioritet (utfördes senast)