Datatyper omvandlingar

Datatyp omvandlingar i Java görs på tre olika sätt:

  • Automatiska typomvandlingar (implicit typomvandlingar)
  • Explicit typomvandlingar (uttryckliga typomvandlingar, på engelska typecasting)
  • Med hjälp av metoder (tas upp senare)

Automatiska typomvandlingar

Automatiska typomvandlingar utförs av kompilatorn ifall det inte finns en risk att informationen tappar sitt värde. Det innebär att omvandlingar kan göras enbart i en viss ordning:

heltal byte —> heltal short —> heltal int —> heltal long —> flyttal float —> flyttal double
eller
heltal 8 bitar –> heltal 16 bitar –> heltal 32 bitar –> heltal 64 bitar –> 32 bitar flyttal –> 64 bitar flyttal

Som exempel använder jag mig av två variabler av olika typer och jag adderar dem till en annan variabel:

int i1 = 20;
double d1 = 2.5;
double d2 = i1 + d1;
System.out.println(d2);  // utdata blir 22.5 Det som händer här är att i1 konverteras automatiskt till double, dvs från 20 till 20.0 och då additionen är av double typ.

Explicit typomvandlingar

En typomvandling av ett värde av en datatyp till ett värde av en mindre datatyp kan framtvingas. Detta är känd på engelska som typecasting.

Exempel:

double d1 = 2.5;
int i1 = (int) d1;
System.out.println(i1);  // utdata blir 2 Det visar att i omvandlingen på höger leden blev d1 2 i stället 2.5 och det resultatet lagras i variabeln i1, men variabeln double d1 är fortfarande 2.5

Hur lagras olika datatyper i datorns minne?

Tal lagras i datorns minne som binära tal, det bill säga en serie ettor och nollor. Till exempel heltal 5 lagras med olika antal bitar som datatyp byte och som datatyp short:

Exponent 31 30 29 . . . 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0
Bas 2 2 2 . . . 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2  2
Vikt       . . .                     128 64 32 16 8 4 2 1
byte . . . 0 0 0 0 0 1 0 1
short . . . 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1
int . . .                                

 
Datatyp byte lagrar tal i minnet på åtta minnesceller medan short lagrar ett tal på 16 minnesceller.

  • byte: 28 = 256 kombinationer av ettor och nollor som decimalt ger från 0 till 255. Om dessa kombinationer placeras i en tallinje med noll i mitten blir värdena till vänster av nollan negativa och till höger positiva. Så här -128  -127 -126 och så vidare fram till noll och därefter 1 2 3 4 och fram till 127. Det innebär att högre tal än 127 kommer att generera fel vid kompilering.

Hur Java definierar intervallvärde för datatypen byte behöver förklaras med hjälp av signerat och osignerat tal, vilket innebär att den första bit från vänster används för att markera talet som positiv eller negativ. En 0 säger att talet är positivt och en 1 att talet är negativt, det är just detta anledningen till namnet signerade tal. Från 8 bitar används den första för att ”signera” att talet är positivt eller negativt vilket ger 7 bitar för själva värde i talet. Till exempel decimal heltal 5 blir det binärt 0 000 0101 där den rödfärgade nollan säger att talet är positivt. För att skriva negativa tal i datatypen byte använder man första och andra komplement. Till exempel -128 kommer att räknas ut så här:

27 26 25 24 23 22 21 20
128 64 32 16 8 4 2 1
Heltal 127 kodad i byte 0 1 1 1 1 1 1 1
Heltal 128 (osignerat) 1 0 0 0 0 0 0 0
inverterat 0 1 1 1 1 1 1 1
plus 1 0 0 0 0 0 0 0 1
lika med -128 (signerat) 1 0 0 0 0 0 0 0