Hoi! Vandaag zullen we een heel belangrijk onderwerp bekijken, namelijk numerieke operatoren in Java .
Bij het programmeren zijn getallen overal. Als je diep graaft en je de middelbare school herinnert, herinner je je misschien dat een computer alle informatie in een numeriek formaat weergeeft: combinaties van nullen en enen, ook wel binaire code genoemd.
Er zijn veel numerieke operatoren in de programmering, dus we zullen voorbeelden gebruiken om de belangrijkste ervan te verkennen :) Laten we beginnen met de eenvoudigste: rekenkundige operatoren . Dit zijn de bekende operatoren voor optellen ( +), aftrekken ( -), vermenigvuldigen ( *) en delen ( )./
public class Main {
public static void main(String[] args) {
int x = 999;
int y = 33;
System.out.println(x+y);
System.out.println(x-y);
System.out.println(x*y);
System.out.println(x/y);
}
}
Console output: 1032 966 32967 30 Je hebt dit allemaal al gebruikt. Aan deze groep kunt u de operator rest of modulo ( ) toevoegen %.
public class Main {
public static void main(String[] args) {
int x = 33;
int y = 33%2;
System.out.println(y);
}
}
Console-uitvoer: 1 In dit voorbeeld delen we 33 door 2. Dit levert 16 op, met een extra "staart" (één) die niet deelbaar is door 2. Deze "staart" is het resultaat van de bewerking "rest van deling". Java implementeert ook vergelijkings-/relationele operatoren (net als in de wiskunde). Ze zijn je waarschijnlijk ook bekend van school:
gelijk aan ( ==)
groter dan ( >)
minder dan ( <)
groter dan of gelijk aan ( >=)
kleiner dan of gelijk aan ( <=)
niet gelijk ( !=)
Hier moet u letten op een belangrijk punt dat ervoor zorgt dat veel beginners fouten maken. De "is gelijk aan" operator is geschreven ==, niet =. In Java is een single =de toewijzingsoperator , die wordt gebruikt wanneer aan een variabele een getal, tekenreeks of de waarde van een andere variabele wordt toegewezen .
public class Main {
public static void main(String[] args) {
int x = 33;
int y = 999;
System.out.println(x=y);// We expect false to be displayed
}
}
Console-uitvoer: 999 Oeps! Dit is natuurlijk niet het resultaat dat we verwacht hadden. Het is een heel ander gegevenstype: we verwachtten een boolean te zien , maar we kregen een nummer. Allemaal omdat we een toewijzingsoperator tussen haakjes hebben gebruikt in plaats van een vergelijking . x=y De waarde van y(999) werd toegewezen aan de variabele xen vervolgens gaven we de waarde van weer x. Hier is de juiste manier om het te doen:
public class Main {
public static void main(String[] args) {
int x = 33;
int y = 999;
System.out.println(x==y);
}
}
Console-uitvoer: false Nu hebben we de twee getallen goed vergeleken! :) Hier is nog een kenmerk van de toewijzingsoperator ( =): deze kan aan elkaar worden "geketend":
public class Main {
public static void main(String[] args) {
int x = 999;
int y = 33;
int z = 256;
x = y = z;
System.out.println(x);
}
}
Console-uitvoer: 256 Onthoud dat de toewijzing van rechts naar links is . Deze uitdrukking ( x = y = z) wordt in stappen uitgevoerd:
y = z, dat is,y = 256
x = y, dat is,x = 256
Unaire operatoren.
Ze worden " unair " genoemd van het woord " uno ", wat " één " betekent. Ze hebben deze naam gekregen omdat ze, in tegenstelling tot de vorige operatoren, handelen op één nummer, niet op meerdere. Deze omvatten:
Unaire min. Het draait het teken van het nummer om.
public class Main {
public static void main(String[] args) {
int x = 999;
// Change the sign for the first time
x = -x;
System.out.println(x);
// Change the sign for the second time
x= -x;
System.out.println(x);
}
}
Console-uitvoer: -999 999 We hebben de unaire min-operator twee keer gebruikt. Als gevolg hiervan was ons nummer eerst negatief en daarna weer positief!
Verhogen (++) en verlagen (--)
De ++operator verhoogt een getal met één en de --operator verlaagt een getal met hetzelfde bedrag.
public class Main {
public static void main(String[] args) {
int x = 999;
x++;
System.out.println(x);
x--;
System.out.println(x);
}
}
Console-uitvoer: 1000 999 Deze notatie komt je misschien bekend voor als je hebt gehoord van de C++-taal. De makers gebruikten deze interessante naam om het idee over te brengen dat "C++ een uitbreiding is van de C-taal". Een populaire verbeterde versie van Notepad heet Notepad++ Hier is een belangrijk punt. Er zijn twee soorten operatoren voor verhogen en verlagen: postfix en prefix . x++- postfix ++x- prefix Wat is het fundamentele verschil tussen de plussen/minussen voor of achter het nummer plaatsen? We zullen zien in het volgende voorbeeld:
public class Main {
public static void main(String[] args) {
int x = 999;
int y = x++;
System.out.println(y);
}
}
Console-uitvoer: 999 Er klopt iets niet! We wilden met 1 verhogen xen de nieuwe waarde toekennen aan de variabele y. Met andere woorden, y zou 1000 moeten zijn. Maar in plaats daarvan krijgen we iets anders: 999. Het lijkt erop dat x niet is verhoogd en dat de toename-operator niet werkte? Maar het werkte wel. Om jezelf te overtuigen, probeer xaan het einde weer te geven :)
public class Main {
public static void main(String[] args) {
int x = 999;
int y = x++;
System.out.println(y);
System.out.println(x);
}
}
Console-uitvoer: 999 1000 In feite is dit precies de reden waarom deze bewerking postfix wordt genoemd: ze wordt uitgevoerd na de hoofdexpressie. Dit betekent in ons geval: int y = x++;y = xwordt eerst uitgevoerd (en de variabele ywordt geïnitialiseerd op de waarde van x), en pas daarna wordt x++uitgevoerd. Wat als dit niet het gedrag is dat we willen? Dan moeten we prefix- notatie gebruiken:
public class Main {
public static void main(String[] args) {
int x = 999;
int y = ++x;
System.out.println(y);
}
}
In dit geval ++xwordt eerst verwerkt en pas daarna y = x; uitgevoerd. Je moet dit verschil meteen in het geheugen vastleggen om te voorkomen dat je fouten maakt in een echt programma waar het gebruik van postfix in plaats van prefix alles op zijn kop zou kunnen zetten :)
Samengestelde operatoren
Daarnaast zijn er in Java zogenaamde samengestelde operatoren. Ze combineren twee operatoren:
Opdracht
Rekenkundige operatoren
Deze omvatten:
+=
-=
*=
/=
%=
Laten we een voorbeeld bekijken:
public class Main {
public static void main(String[] args) {
int x = 999;
int y = 33;
x += y;
System.out.println(x);
}
}
Console-uitvoer: 1032x += y betekent x = x + y. Kortheidshalve worden de twee symbolen na elkaar gebruikt. De combinaties -=, *=, /=en %=werken op een vergelijkbare manier.
Logische operatoren
Naast numerieke operatoren kent Java ook bewerkingen met booleaanse waarden ( true en false ). Deze bewerkingen worden uitgevoerd met behulp van logische operatoren
!- logisch NIET . Het draait de waarde van een boolean om
public class Main {
public static void main(String[] args) {
boolean x = true;
System.out.println(!x);
}
}
Console-uitvoer: onwaar
&&- logische EN . Het retourneert alleen waar als beide operanden waar zijn.
public class Main {
public static void main(String[] args) {
System.out.println(100 > 10 && 100 > 200);
System.out.println(100 > 50 && 100 >= 100);
}
}
Console-uitvoer: false true Het resultaat van de eerste bewerking is false, omdat een van de operanden false is, namelijk 100 > 200. Om waar te retourneren, &&vereist de operator dat beide operanden waar zijn (zoals het geval is in de tweede regel).
||- logische OF . Het retourneert waar als ten minste één van de operanden waar is.
Als we deze operator gebruiken, levert ons vorige voorbeeld een ander resultaat op:
public class Main {
public static void main(String[] args) {
System.out.println(100 > 10 || 100 > 200);
}
}
Console-uitvoer: true De uitdrukking 100 > 200is nog steeds false, maar voor de OR- operator is het voldoende dat het eerste deel ( 100 > 10) waar is.
GO TO FULL VERSION