Java Type Casting

Was ist Type Casting in Java?

Ein Datentyp ist ein vordefinierter Satz von Werten, der die Art der darin speicherbaren Werte sowie die damit ausführbare Operation angibt. Beim Java Type Casting handelt es sich um einen Prozess, bei dem ein Datentyp in einen anderen umgewandelt wird. Es kann sowohl implizit als auch explizit sein . Die implizite Typumwandlung, auch automatische Typumwandlung genannt, wird vom Compiler durchgeführt. Die explizite Typumwandlung erfolgt manuell durch den Programmierer im Code.

Warum ist Type Casting erforderlich?

Java verfügt über verschiedene primitive Datentypen, die unterschiedliche Speicherplätze erfordern. Dies kann zu Kompatibilitätsproblemen führen, wenn ein Wert eines Datentyps einem anderen zugewiesen wird. Wenn die Datentypen bereits kompatibel sind, erfolgt die Typumwandlung automatisch durch den Compiler. Somit löst die Typumwandlung ein großes Kompatibilitätsproblem beim Umgang mit verschiedenen Datentypen in unserem Programm.

Arten von Java Type Casting

In Java gibt es zwei Arten der Typumwandlung.

1. Widening Type Casting – Auch bekannt als implizites oder automatisches Type Casting
2. Einengende Typumsetzung – Auch bekannt als explizite oder manuelle Typumsetzung

Aufweitender Guss

Die erweiternde Typumwandlung bezieht sich, wie der Name schon sagt, auf die Erweiterung eines kleineren Datentyps zu einem größeren Datentyp. Wir führen diese Typumwandlung durch, wenn wir einen kleinen Typ in einen großen Typ konvertieren möchten. Die Datentypen müssen miteinander kompatibel sein. Es gibt keine implizite Konvertierung vom numerischen in den char- oder booleschen Typ. In Java sind die Typen char und boolean nicht kompatibel. Diese Art der Umwandlung wird vom Compiler automatisch und ohne Informationsverlust durchgeführt. Es ist kein externer Auslöser durch den Programmierer erforderlich.

Beispiel

//Automatic type conversion
public class WideningExample {
   public static void main(String[] args) {

       int i = 100;
       System.out.println("int value: " + i);

       // int to long type
       long l = i;
       System.out.println("int to long value: " + l);

       // long to float type
       float f = l;
       System.out.println("int to float value: " + f);


       byte b = 1;
       System.out.println("byte value: " + b);

       // byte to int type
       i = b;
       System.out.println("byte to int value: " + i);

       char c = 'a';
       System.out.println("char value: " + c);

       // char to int type
       i = c;

       // prints the ASCII value of the given character
       // ASCII value of 'a' = 97
       System.out.println("char to int value: " + i);
   }
}

Ausgabe

Erläuterung

Im obigen Code haben wir die erweiterte Typumwandlung gezeigt, die vom Compiler automatisch durchgeführt wird. Zunächst haben wir einem int , byte und char Werte zugewiesen . Anschließend haben wir die int-Werte einem long und einem float zugewiesen , die beide größer als int sind . Wir haben int auch die Byte- und Char- Werte zugewiesen . Sowohl byte als auch char sind kleinere Datentypen als int , daher waren diese Konvertierungen implizit.

Verengender Typguss

Einschränkende Typumwandlung bezieht sich, wie der Name schon sagt, auf die Eingrenzung eines größeren Datentyps auf einen kleineren Datentyp. Wir führen diese Typumwandlung durch, wenn wir einen großen Typ in einen kleinen Typ konvertieren möchten. Für diese Art der Umwandlung überschreiben wir die Standardkonvertierung von Java, indem wir unsere eigene Konvertierung angeben. Um dies zu erreichen, schreiben wir die Variable oder den Wert, die bzw. der typisiert werden muss, vor dem Zieldatentyp in Klammern „()“. Allerdings kann es bei dieser Gussart zu einem möglichen Präzisionsverlust kommen.

Beispiel

//Manual Type Conversion
public class NarrowingExample {
   public static void main(String[] arg) {

       // double data type
       double d = 97.04;
       // Print statements
       System.out.println("double value: " + d);

       // Narrowing type casting from double to long
       // implicitly writing the target data type in () followed by initial data type
       long l = (long) d;

       // fractional part lost - loss of precision
       System.out.println("long value: " + l);

       // Narrowing type casting from double to int
       // implicitly writing the target data type in () followed by initial data type
       int i = (int) l;

       // fractional part lost - loss of precision
       System.out.println("int value: " + i);

       // Narrowing type casting from double to int
       // implicitly writing the target data type in () followed by initial data type
       char c = (char) i;

       // displaying character corresponding to the ASCII value of 100
       System.out.println("char value: " + c);
   }
}

Ausgabe

Erläuterung

Die eingrenzende Typumwandlung muss vom Programmierer explizit mithilfe einer Standardsyntax durchgeführt werden. Im obigen Programm haben wir mit einem Double- Wert begonnen, der größer ist als die Datentypen long und int . Wir haben dieses Double in Long und Int umgewandelt , indem wir Klammern mit den gewünschten Zieldatentypen verwendet haben. Wir haben „int“ auch manuell in „char“ umgewandelt.

Abschluss

Wir hoffen, dass Sie sich am Ende dieses Beitrags ausführlich mit dem Java Type Casting vertraut gemacht haben. Sie haben die beiden Arten der Typumwandlung in Java kennengelernt. Sie haben außerdem gelernt, wie Sie die nicht kompatiblen Datentypen mithilfe der Typumwandlung „Narrowing“ manuell umwandeln. Sie können selbst andere Kombinationen von Datentypen mit unterschiedlichen Werten ausprobieren, um die Sache besser zu verstehen. Üben Sie weiter, um das Konzept besser zu beherrschen. Bis dahin wachsen Sie weiter und strahlen Sie weiter!