Java Language
Type conversie

Syntaxis

• TargetType target = (SourceType) bron;

Niet-numeriek primitief gieten

Het boolean type kan niet van / naar een ander primitief type worden gegoten.

Een char kan naar / van elk numeriek type worden gegoten met behulp van de codepunttoewijzingen die zijn opgegeven door Unicode. Een char wordt in het geheugen weergegeven als een niet-ondertekende 16-bits gehele waarde (2 bytes), dus casten naar byte (1 byte) laat 8 van die bits vallen (dit is veilig voor ASCII-tekens). De hulpprogramma's van de klasse Character gebruiken int (4 bytes) om van / naar codepuntwaarden over te dragen, maar een short (2 bytes) zou ook voldoende zijn om een Unicode-codepunt op te slaan.

int badInt   = (int)  true; // Compiler error: incompatible types

char char1   = (char)   65; // A
byte byte1   = (byte)  'A'; // 65
short short1 = (short) 'A'; // 65
int int1     = (int)   'A'; // 65

char char2   = (char) 8253; // ‽
byte byte2   = (byte)  '‽'; // 61 (truncated code-point into the ASCII range)
short short2 = (short) '‽'; // 8253
int int2     = (int)   '‽'; // 8253

Numeriek primitief gieten

Numerieke primitieven kunnen op twee manieren worden gegoten. Impliciete casting vindt plaats wanneer het brontype een kleiner bereik heeft dan het doeltype.

//Implicit casting
byte byteVar = 42;
short shortVar = byteVar;
int intVar = shortVar;
long longVar = intvar;
float floatVar = longVar;
double doubleVar = floatVar;

Expliciete casting moet worden uitgevoerd wanneer het brontype een groter bereik heeft dan het doeltype.

//Explicit casting
double doubleVar = 42.0d;
float floatVar = (float) doubleVar;
long longVar = (long) floatVar;
int intVar = (int) longVar;
short shortVar = (short) intVar;
byte byteVar = (byte) shortVar;

Bij het gieten van drijvende-komma-primitieven ( float , double ) naar hele aantal primitieven, wordt het nummer naar beneden afgerond .

Object gieten

Net als bij primitieven kunnen objecten zowel expliciet als impliciet worden gegoten.

Impliciete casting vindt plaats wanneer het brontype het doeltype uitbreidt of implementeert (casten naar een superklasse of interface).

Expliciete casting moet worden gedaan wanneer het brontype wordt uitgebreid of geïmplementeerd door het doeltype (casten naar een subtype). Dit kan een runtime-uitzondering veroorzaken ( ClassCastException ) wanneer het te casten object niet van het doeltype (of het subtype van het doel) is.

Float floatVar = new Float(42.0f);
Number n = floatVar;                //Implicit (Float implements Number)
Float floatVar2 = (Float) n;        //Explicit
Double doubleVar = (Double) n;      //Throws exception (the object is not Double)

Basis numerieke promotie

 static void testNumericPromotion() {

    char char1 = 1, char2 = 2;
    short short1 = 1, short2 = 2;
    int int1 = 1, int2 = 2;
    float float1 = 1.0f, float2 = 2.0f;

    // char1 = char1 + char2;      // Error: Cannot convert from int to char;
    // short1 = short1 + short2;   // Error: Cannot convert from int to short;
    int1 = char1 + char2;          // char is promoted to int.
    int1 = short1 + short2;        // short is promoted to int.
    int1 = char1 + short2;         // both char and short promoted to int.
    float1 = short1 + float2;      // short is promoted to float.
    int1 = int1 + int2;            // int is unchanged.
}

Testen of een object kan worden gecast met behulp van instanceof

Java biedt de instanceof operator om te testen of een object van een bepaald type is, of een subklasse van dat type. Het programma kan dan kiezen om dat object al dan niet te casten.

Object obj = Calendar.getInstance();
long time = 0;

if(obj instanceof Calendar)
{
    time = ((Calendar)obj).getTime();
}
if(obj instanceof Date)
{
    time = ((Date)obj).getTime(); // This line will never be reached, obj is not a Date type.
}