dubbel type — reële getallen

1. doubletypen

Java biedt het doubletype voor het werken met reële (fractionele) getallen. Het neemt 8 bytesgeheugen in beslag (twee keer zoveel als het inttype) en kan waarden opslaan in het bereik van tot . Ter vergelijking: het type kan een waarde opslaan in het bereik van tot .-1.7*10308+1.7*10308int-2*109+2*109

In reële getallen wordt het breukdeel achter een komma geschreven. Bijvoorbeeld 123,456, of 2,5, of 100,00, of 0,01. Wanneer computers met dergelijke getallen omgaan, noemen we ze drijvende-kommagetallen .

Trouwens, naast het doubletype hebben we ook het floattype (dat maar 4 bytes groot is). De naam komt van drijvende komma . En de naam doublekomt van dubbele vlotter . A doubleis twee keer zo groot als een float: 8 bytesversus 4. Het wordt ook wel een drijvende-kommagetal met dubbele precisie genoemd .

2. Een doubletype maken

Het dubbele type wordt gebruikt om reële getallen op te slaan. Om een ​​variabele in code te maken die reële getallen kan opslaan, moet u een instructie als deze gebruiken:

double name;

Waar naam de naam van de variabele is. Voorbeelden:

double price;

double weight;

double lightSpeed;

Net als bij het inttype kunt u steno gebruiken om meerdere doublevariabelen tegelijk te maken:

double name 1, name 2, name 3;

En wijs er zelfs meteen waarden aan toe:

double name 1 = value 1, name 2 = value 2, name 3 = value 3;

Voorbeelden:

double price = 5.0;

double weight = 2;

double x = 1.0, y = 2.0, z = 3.0;

3. Toekennen van gehele getallen en reële getallen

Het zou slecht zijn als gehele getallen alleen aan variabelen konden worden toegewezen int, en reële getallen alleen aan doublevariabelen. We willen kunnen converteren tussen de twee soorten getallen. En Java biedt deze mogelijkheid.

Ten eerste kunnen zowel reële als gehele getallen aan doublevariabelen worden toegewezen. Bij het toekennen van gehele getallen worden deze eenvoudig omgezet in reële getallen. Natuurlijk kan tijdens het proces enige nauwkeurigheid verloren gaan.

double price = 5.0;

double weight = 2;

int t = 1000;
double x =  t * t;

Ten tweede, als een geheel getal en een reëel getal betrokken zijn bij een uitdrukking, dan wordt het gehele getal eerst geconverteerd naar een reëel getal en pas daarna wordt de bewerking met het andere reële getal uitgevoerd.

int t = 1000;
double x = t * 5.0;

System.out.println(5 * 2);

System.out.println(5 * 2.0);

En tot slot is het ook mogelijk om reële getallen toe te wijzen aan intvariabelen. Wanneer we dit doen, wordt het gebroken deel van het reële getal weggegooid — het getal wordt naar beneden afgerond naar het dichtstbijzijnde gehele getal.

Bovendien vereist de compiler dat de programmeur expliciet documenteert wat er gebeurt (om er zeker van te zijn dat andere programmeurs begrijpen dat het fractionele deel wordt weggelaten). Over het algemeen ziet zo'n conversie er in code zo uit:

integer_variable = (int)(real_number);

Voorbeelden:

int x = (int)(5.5);

double a = 5.999;
int x = (int)(a);

double a = 5.999;
int b = 2;
int x = (int)(a * b);

4. Gehele getallen en reële getallen delen in Java

Bij het delen van een geheel getal door een geheel getal wordt de rest altijd weggegooid. Hoe kunnen we dan delen 5door 2om te krijgen 2.5?

In eerste instantie lijkt het erop dat de juiste optie is:

double d = 5 / 2;

Maar zo eenvoudig is het niet. Het probleem hier is dat de Java-machine eerst de waarde berekent van 5 / 2en pas daarna het resultaat toewijst aan de dvariabele. En de 5 / 2bewerking is deling door gehele getallen. Dat betekent d zal bevatten 2of, om preciezer te zijn,2.0

De juiste oplossing is om ten minste één van de getallen die betrokken zijn bij de deling te schrijven als een reëel getal (dwz met een decimaalteken):

double d = 5.0 / 2;

double d = 5 / 2.0;

double d = 5.0 / 2.0;

In elk van de uitdrukkingen d zal bevatten2.5

Maar wat als we met variabelen werken? Wat als we code als deze hebben?:

int a = 5;
int b = 2;
double d = a / b;

Er is hier een gelikte (en voor de hand liggende) oplossing: dwing de Java-machine om variabelen om te zetten in reële getallen door ze met één te vermenigvuldigen als een reëel getal ( 1.0)

int a = 5;
int b = 2;
double d = a * 1.0 / b;

Merk op dat vermenigvuldigen en delen dezelfde prioriteit hebben en van links naar rechts worden uitgevoerd. Dat betekent dat het uitmaakt waar we de 1,0 vermenigvuldigen.

Voorbeelden:

int a = 5;
int b = 2;
double d = 1.0 * a / b;

int a = 5;
int b = 2;
double d = a * 1.0 / b;

int a = 5;
int b = 2;
double d = a / b * 1.0;