What is Type Casting in JAVA with Example

Type casting in Java refers to the process of converting a value of one data type to another. It allows you to treat an object or variable as a different type temporarily. Java supports two types of casting: implicit casting (widening) and explicit casting (narrowing).

Implicit Casting (Widening):
Implicit casting happens when you assign a value of a smaller data type to a variable of a larger data type. It is done automatically by the Java compiler as it is considered safe. Here's an example:
java
Copy code
int num = 10;
long bigNum = num; // Implicit casting from int to long
In the example above, the value of the num variable (int) is assigned to the bigNum variable (long) without the need for explicit casting. Since a long can hold a wider range of values than an int, it is considered safe.

Explicit Casting (Narrowing):
Explicit casting occurs when you assign a value of a larger data type to a variable of a smaller data type. It requires explicitly specifying the target type in parentheses. Explicit casting is necessary because it may result in data loss or loss of precision. Here's an example:
java
Copy code
double bigNum = 3.14;
int num = (int) bigNum; // Explicit casting from double to int
In the example above, the value of bigNum (double) is assigned to num (int) by explicitly casting it to an int. Since an int has a smaller range and does not support decimal places, there may be a loss of precision.

It's important to note that explicit casting can lead to data loss or unexpected behavior if the value being casted is outside the range of the target data type.

Type casting is also applicable to object types, where you can cast between different classes or interfaces in the class hierarchy. However, type casting between unrelated types can result in a ClassCastException if the types are not compatible.

java
Copy code
class A {}
class B extends A {}

A objA = new B();
B objB = (B) objA; // Explicit casting from A to B
In the example above, an object of class B is implicitly upcasted to class A. Then, explicit casting is used to downcast it back to class B.

It's important to use type casting judiciously and ensure compatibility between types to avoid potential errors and exceptions.