Typkonvertering i Java

Typkonvertering i Java används för att konvertera en datatyp till en annan. Grundregeln är att ett tal automatisk kan konverteras till ett tal av vidare representation, annars kan typkonverteringen ske med hjälp av inbyggda funktioner.

Java och många andra kodspråk är så kallade typade språk. Med det menas att vi behöver hålla koll på vilken datatyp variabler har då vi använder dem till olika operationer. Om problemet med att en operation inte kan utföras på grund av datatyperna inte överensstämmer så går det att lösa på tre olika sätt.

• Automatisk typkonvertering
• Explicit typkonvertering
• Konvertera med hjälp av metoder

Vi ska nedan se hur vi använder de tre olika sätten samt även några saker som kan vara bra att tänka på vid typkonvertering i Java

Java och många andra kodspråk är så kallade typade språk. Med det menas att vi behöver hålla koll på vilken datatyp variabler har då vi använder dem till olika operationer.

Automatisk typkonvertering

Automatisk konvertering, kallas även Implicit konvertering, är väldigt smidigt och utförs automatisk av kompilatorn då det inte finns en risk att information går förlorad. Det medför då restriktionen att vi endast kan använda automatisk konvertering för att konvertera uppåt enligt

Vilket känns rimligt om vi ser en datatyp som en behållare och tänker att vid en automatisk konvertering går det att placera data från en liten behållare i en större, men inte tvärtom

int a = 2; 
double x = a;

Operationen ovan ger variabeln x värdet 2.0 och är tillåten att utföra på grund av att double är en större datatyp.

Vidare, om vi istället skriver

int num = 8 + 7.0;

Operationen ovan är ej tillåten att utföra på grund av att variabeln num som ska tilldelas värdet av operationen 8 + 7.0 är av datatypen int och operanden 7.0 är av datatypen double.

Explicit typkonvertering

När en datatyp inte automatiskt kan konverteras till en annan typ kan detta istället ske genom en explicit typkonvertering. Den måste beordras av utvecklaren och ifall vi har ett uttryck med flera datatyper och vi då riskerar förlora noggrannhet vid en operation så behöver vi använda oss av explicit typomvandling. En explicit typkonvertering kallas även för att casta (omtypning). 

Vid de tillfällen då vi måste konvertera en variabel med högre precision till en variabel med lägre, måste vi tvinga fram denna. Som vi ska se nedan så gör vi detta genom att inom parenteser ange till vilken datatyp vi vill konvertera

double a = 10.8; 
int num = (int) a; // double (64 bit) --> int (32 bit)

Operationen ovan kommer ge variabeln num värdet 10. Viktigt att notera att det tappade en stor del av noggrannheten (decimaldelen) när det gick från en double till en int.

Vidare, exemplet från avsnittet om automatisk typkonvertering som inte kunde genomföras skulle då kunna lösas enligt

int num = 8 + (int)7.0;

Hjälp av metoder för typkonvertering i Java

När vi tar in information från en användare vid t.ex. en Scanner så hamnar informationen från användaren i en String. För att kunna konvertera en String till ett tal (int, double, osv) för att sedan kunna använda det till t.ex. matematiska beräkningar så tar vi hjälp av inbyggda metoder i Java.

Java har en metod till respektive omslagsklass, t.e.x klassen Integer har metoden parseInt() som gör om en String till en int-variabel.

Vi ska se ett exempel nedan,

String str = "123"; 
int intVariabel = Integer.parseInt(str); 
double doubleVariabel = Double.parseDouble(str);

Vi kan även med hjälp av inbyggda metoder gå åt andra hållet, dvs från ett tal till en string. Varje omslagsklass har en metod som heter  toString() som hjälper oss med den konverteringen, där vi helt enkelt skriver Omslagsklass.toString(variabel namn);

// int --> String 
int intVariabel = 24; 
String strI = Integer.toString(intVariabel); 

// double --> String 
double doubleVariabel = 385.98; 
String strD = Double.toString(doubleVariabel);

Att tänka på vid typkonvertering i Java

Det är viktigt att vara uppmärksam på noggrannhet i de olika datatyperna vid olika konverteringar. Kom ihåg att när vi konverterar från ett decimaltal till ett heltal så tappar vi decimaldelen. Vi ska se några exempel nedan på enkla fel som kan uppstå om vi är lite ouppmärksamma

double d = 7,99999999; 

int i = (int)d; 
// i = 7

Där har vi ett decimaltal d som uppenbart är väldigt nära talet 8, men när vi typkonverterar d till ett heltal (int) så tappar vi decimaldelen och i = 7 eftersom en int inte kan ha decimaltal.

Ett till exempel vi ska se på har med division att göra

int x = 4; 
int y = 5; 

double d = x / y; 
// d = 0

Här blir d = 0. Det beror helt enkelt på att divisionen utförs på två heltal (int) och eftersom de inte kan hålla några decimaler så blir d = 0.  Om vi däremot konverterar x och y innan vi utför divisionen

double d = (double)x / y; 
// d = 0.8

så får vi svaret d = 0.8