Rekenen met gehele getallen
Rekenen met gehele getallen |
|
De karakters *, /, +, - en % geven de bekende rekenkundige bewerkingen aan en worden in Java operatoren genoemd. In Java is ook het = teken een operator.
| + | optellen |
| - | aftrekken |
| * | vermenigvuldigen |
| / | delen |
| % | modulo (rest van een deling) |
| = | toekenning (kopieren) |
De rekenkundige operatoren werken hetzelfde als in de wiskunde. Optellen is een plusteken en aftrekken is een min-teken.
c = a + b; d = (a- b) + c;
Vermenigvuldigen gaat met het sterretje *.
a = b * c;
Bij het vermenigvuldigen van grote getallen kan het buiten de maximale waarde van het gegevenstype vallen. Er ontstaat geen foutmelding.
Een deling van twee gehele getallen met het / teken levert een ander resultaat op dan je misschien zou verwachten. Het resultaat is altijd een geheel getal afgerond naar beneden.
int a, b, quotient, rest; a = 9; b = 5; quotient = a / b; /* quotient is 1 */ rest = a % b; /* rest is 4 */
Voor het delen met gebroken getallen moeten double of float gebruikt worden.
In rekenkundige uitdrukkingen is de betekenis: de rest van een deling van twee hele getallen.
25 % 3 = 1 (25/3=8 rest 1)
18 % 7 = 4 (18/7=2 rest 4)
De modulo operator heeft geen betekenis bij gebroken getallen en is dan ook niet toegestaan
Het = teken is ook een operator. De volgende constructies zijn toegestaan
int a, b, som1, som2, som3;
som1 = som2 = a + b;
som3 = som2 + (som1 = a + b );
De toekenningsoperator associeert van rechts naar links. Bij het eerste statement wordt daarom eerst de som a + b berekend en toegekend aan som2 en de waarde van som2 wordt weer toegekend aan som1. Dus som1 en som2 krijgen dezelfde waarde. Bij het tweede statement wordt eerst a + b berekend en de som toegekend aan som1. Daarna wordt de waarde van de expressie som1 = a + b vermeerderd met som2 en de nieuwe som toegekend aan som3. Als we de haakjes weglaten zal de compiler proberen de waarde a + b toe te kennen aan som2 + som1 en dat kan niet. Je kunt alleen een waarde toekennen aan een variabele, niet aan een som. De compiler zal dan ook een foutmelding geven.
Alle berekeningen van gehele getallen worden uitgevoerd met alleen integer of long. Dus als getallen van het type byte of short worden opgeteld dan worden ze eerst getypecast naar int, waarna de berekening wordt uitgevoerd. Dus een berekening geeft altijd een int of long als resultaat.
byte b1 = 2, b2= 5; byte resultaat; resultaat = b1 + b2; // FOUT resultaat = (byte)(b1 + b2); //GOED
De optelling geeft een integer als resultaat deze moet expliciet getypecast worden om deze in een byte weg te schrijven.
Bij berekeningen gelden de prioriteitsregels uit de normale rekenkunde. Onderstaande rekenkundige operatoren hebben van boven naar beneden een aflopende prioriteit.
| ( ) | beïnvloedt de volgorde van bewerkingen | associatie links naar rechts |
| * / % | vermenigvuldigen, delen, modulus | associatie links naar rechts |
| + - | optellen, aftrekken | associatie links naar rechts |
| = | toekennen aan (assignment) | associatie rechts naar links |
Associatie van links naar rechts wil zeggen dat bij gelijke prioriteit eerst de berekening aan de linkerzijde van de operator wordt uitgevoerd.
5 * 3 * 2 = ((5 * 3) * 2) /* eerst 5*3, daarna produkt*2 */ 5 * 3 / 2 = ((5 * 3) / 2) 5 + 4 - 3 = ((5 + 4) - 3)
In Java kunnen we aan variabelen een constante waarde
toekennen, bijv. a = 5; b = 7;
En constantes gebruiken in expressies, bijv. a = 5 * b + c
Het is zelfs toegestaan om bij de declaratie een variabele een
beginwaarden toe te kennen met een rekenkundige expressie.
int som = 0, waarde = 6 * 8;
De waarden kunnen later in het programma weer worden veranderd.
De operatoren *, /, %, +, - en = zijn binaire operatoren. In uitdrukkingen staan steeds ter weerszijden van de operatoren operanden. + en - komen ook als unaire operatoren voor, bijv in de uitdrukking a = +3 of b = -a.
Omdat in programma's nogal vaak uitdrukkingen als a=a+3 of a=a*2 voorkomen is voor dit type expressies een verkorte schrijfwijze bedacht.
| a = a + 3 | a += 3 |
| a = a - 3 | a -= 3 |
| a = a * 3 | a *= 3 |
| a = a / 3 | a /= 3 |
| a = a % 3 | a %= 3 |
Omdat deze operatoren de laagste prioriteit hebben moet een
expressie als a *= c + 5 * d
worden geïnterpreteerd als a = (a * (c + 5 * d)).
Vrijwel alle processoren zijn voorzien van machine-instructies waarmee getallen snel met één vermeerderd of verminderd kunnen worden. Java speelt daarop in met de increment (++) en decrement (--) operatoren. De drie expressies zijn gelijk:
| teller++ | teller = teller + 1 | teller += 1 |
| teller-- | teller = teller -1 | teller -=1 |
De operatoren kunnen zowel vóór, pre-increment en pre-decrement, als achter, post-increment en post-decrement, de variabelenaam worden geplaatst. In bepaalde situaties kan het voor of achter de naam plaatsen van de operatoren van invloed zijn op het resultaat van bewerkingen of gevolgen hebben voor het programmaverloop.
a = 5;
b = 8 + a++;
c = 5 + ++a;
Bij het tweede statement berekent eerst b = 8 + a en
onmiddelllijk daarna a met één vermeerderd. Dus krijgt b de
waarde 13 en wordt a = 6. Bij het derde statement vermeerdert
eerst a met 1 en berekent daarna c = 5 + a. Dus a wordt 7 en c
krijgt de waarde 12. Hoewel het op grond van de prioriteitregels
niet nodig is kun je voor de duidelijkheid 5 + (++a) schrijven.
Een ander voorbeeld van het gebruik van pre- en post increment is
de onderstaande while-lus
| a=0; while(a++ < 5) System.out.println(Integer.toString(a) ); /* 1 2 3 4 5 */ |
a=0; while(++a < 5) System.out.println(Integer.toString(a) ); /* 1 2 3 4 */ |
In het linker fragment wordt eerst a met 5 vergeleken en
beslist of println moet worden uitgevoerd, daarna wordt a met 1
vermeerderd en dan wordt a afgedrukt. Afgedrukt wordt: 1 2 3 4 5
In het rechter fragment wordt eerst a met 1 vermeerderd en daarna
vergeleken met 5 en wordt beslist of println moet worden
uitgevoerd. Afgedrukt wordt: 1 2 3 4