dubbel typ — reella tal

1. doubletyp

Java tillhandahåller doubletypen för att arbeta med reella (bråktal) tal. Den upptar 8 bytesi minnet (dubbelt så många som inttypen) och kan lagra värden i intervallet från till . Som jämförelse: typen kan lagra ett värde i intervallet från till .-1.7*10308+1.7*10308int-2*109+2*109

I reella tal skrivs bråkdelen efter en decimalkomma. Till exempel 123,456 eller 2,5 eller 100,00 eller 0,01. När datorer hanterar sådana nummer kallar vi dem flyttal .

Förresten, förutom typen doublehar vi även floattypen (som bara är 4 byte stor). Dess namn kommer från floating point . Och namnet doublekommer från double float . A doubleär dubbelt så stor som a float: 8 byteskontra 4. Det kallas också för ett flyttal med dubbel precision .

2. Skapa en doubletyp

Dubbeltypen används för att lagra reella tal. För att skapa en variabel i kod som kan lagra reella tal, måste du använda en sats som denna:

double name;

Där namn är namnet på variabeln. Exempel:

double price;

double weight;

double lightSpeed;

Som med inttypen kan du använda stenografi för att skapa flera doublevariabler samtidigt:

double name 1, name 2, name 3;

Och till och med omedelbart tilldela dem värden:

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

Exempel:

double price = 5.0;

double weight = 2;

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

3. Tilldela heltal och reella tal

Det skulle vara dåligt om heltal bara kunde tilldelas intvariabler och reella tal - bara till doublevariabler. Vi vill kunna konvertera mellan de två sorterna av tal. Och Java ger denna förmåga.

För det första kan både reella tal och heltal tilldelas doublevariabler. När man tilldelar heltal omvandlas de helt enkelt till reella tal. Viss noggrannhet kan naturligtvis gå förlorad i processen.

double price = 5.0;

double weight = 2;

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

För det andra, om ett heltal och ett reellt tal är inblandade i något uttryck, så konverteras heltal först till ett reellt tal och först därefter utförs operationen med det andra reella talet.

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

System.out.println(5 * 2);

System.out.println(5 * 2.0);

Och slutligen är det också möjligt att tilldela reella tal till intvariabler. När vi gör detta kasseras bråkdelen av det reella talet — talet avrundas nedåt till närmaste heltal.

Dessutom kräver kompilatorn att programmeraren explicit dokumenterar vad som händer (för att vara säker på att andra programmerare förstår att bråkdelen släpps). I allmänhet ser en sådan konvertering ut så här i kod:

integer_variable = (int)(real_number);

Exempel:

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. Dela heltal och reella tal i Java

När man dividerar ett heltal med ett heltal, kasseras alltid resten. Hur kan vi då dividera 5med 2för att få 2.5?

Till en början verkar det som att det rätta alternativet är:

double d = 5 / 2;

Men det är inte så enkelt. Problemet här är att Java-maskinen först beräknar värdet på 5 / 2och först sedan tilldelar resultatet till dvariabeln. Och 5 / 2operationen är heltalsdelning. Det betyder d kommer att innehålla 2eller, för att vara mer exakt,2.0

Den korrekta lösningen är att skriva minst ett av talen som ingår i divisionen som ett reellt tal (dvs med en decimalkomma):

double d = 5.0 / 2;

double d = 5 / 2.0;

double d = 5.0 / 2.0;

I varje uttryck d kommer att innehålla2.5

Men vad händer om vi arbetar med variabler? Vad händer om vi har en sådan kod?:

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

Det finns en smart (och uppenbar) lösning här - tvinga Java-maskinen att konvertera variabler till reella tal genom att multiplicera dem med ett som ett reellt tal ( 1.0)

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

Observera att multiplikation och division har samma företräde och utförs från vänster till höger. Det betyder att det spelar roll var vi multiplicerar 1,0.

Exempel:

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;