Rekenen met gebroken getallen
Rekenen met gebroken getallen |
|
* |
/ |
+ |
- |
% |
= |
De behandelde rekenkundige operatoren: + - * / voor het bewerken van integers kunnen ook worden gebruikt in combinatie met gebroken getallen. We hebben gezien dat bij deling van getallen van het type int met de operator / in Java alleen het hele deel van het quotient wordt berekend, dus 14 / 3 = 4. Moet het quotient een gebroken getal zijn dan moet één van de getallen, of moeten beide, van het type float of double zijn, bijv. 14.0 / 3 = 4.666667. De modulo operator is ook voor gebroken getallen gedefinieerd.
double x, y, quotient, rest; x = 16.0; y = 5.0; quotient = x / y; // quotient krijgt de waarde 3.2 rest = x % y; // rest = 1.0
modulo
De modulo operator is ook voor gebroken getallen
gedefinieerd. Het geeft ook de rest van een deling alsof de
deling alleen een geheel getal als resultaat had.
6.2 % 2.3 = 0.6 8.3 % 3.0 = 2.3
Het is mogelijk om het ene gegevens type om te zetten in het andere door middel van een typecast. Dat kan impliciet als het linker getal een grotere getalsformaat heeft dan het rechter zoals hier:
int i = 1; double d = 3.14; d = i; // d = 1
Dus i = d; mag niet, omdat integer i een kleiner getalsformaat heeft dan double d.
De char kan worden gewisseld met een char. De volgorde op een rijtje.
byte |
short |
int
|
long |
float |
double |
int x, y; double quotient; x = 16; y = 5; quotient = x / y; //LET OP! quotient krijgt de waarde 3.0
Eerst worden de integers x en y op elkaar gedeeld. Het quotient daarvan is ook weer een integer, dus 3. Daarna wordt de waarde 3 toegekend aan de variabele quotient, en omdat quotient een double is wordt 3 eerst geconverteerd naar een double met de waarde 3.0.
Neem aan dat we twee integers op elkaar willen delen en als quotient een gebroken getal willen hebben. Dan kunnen we typecasting gebruiken. In deze context wordt daarmee bedoeld: het veranderen van type. Bijvoorbeeld
int x, y; double quotient, rest; x = 16; y = 5; quotient = (double)x / y; /*quotient = 3.2*/
(double)x geeft de compiler opdracht te zorgen dat de waarde van x wordt geconverteerd naar een double. Het gereserveerde woord double moet tussen haakjes staan. Omdat typecasts een hogere prioriteit hebben dan de rekenkundige bewerkingen wordt eerst de waarde van x geconverteerd naar een double en daarna het quotient (nu van een double en een int) bepaald. Het quotient is dus een double met waarde 3.2 Een alternatief voor typecasting is bijv. quotient = (1.0 * x) / y;
Door typecasting kan een gegeven van het type double, aannemend dat de waarde in het bereik van een int valt, geconverteerd worden naar een int. Bij een gebroken getal treedt dan informatieverlies op. De waarde achter de komma vervalt, er wordt dus niet afgerond.