Java Type Casting
In Java, type casting is the process of converting one data type into another. Since Java is a strongly typed language, you cannot directly assign a value of one data type to another if they are incompatible. For instance, assigning a double value to an int variable requires explicit conversion.
Type casting is mainly useful when working with variables of different data types in expressions, method calls, or collections.
Types of Type Casting in Java
Java supports two kinds of type casting:
- Widening Type Casting (Implicit Casting)
- Narrowing Type Casting (Explicit Casting)
1. Widening Type Casting (Implicit Casting)
Widening occurs when a smaller data type is automatically converted into a larger data type.
- Also called upcasting.
- It is done automatically by Java, so no explicit cast is required.
- No data is lost during widening conversion.
Conversion Order (from smaller to larger type):
byte → short → int → long → float → double
Example of Widening (Implicit Casting):
public class WideningExample {
public static void main(String[] args) {
int num = 100; // int type
double result = num; // int is converted to double automatically
System.out.println(“Integer value: ” + num);
System.out.println(“Double value (after widening): ” + result);
}
}
Output:
Integer value: 100
Double value (after widening): 100.0
Here, int (4 bytes) is automatically promoted to double (8 bytes).
2. Narrowing Type Casting (Explicit Casting)
Narrowing occurs when a larger data type is explicitly converted into a smaller data type.
- Also called downcasting.
- It must be done manually using the cast operator (type).
- There may be data loss or precision loss.
Conversion Order (from larger to smaller type):
double → float → long → int → short → byte
Example of Narrowing (Explicit Casting):
public class NarrowingExample {
public static void main(String[] args) {
double num = 99.99; // double type
int result = (int) num; // explicitly cast double to int
System.out.println(“Double value: ” + num);
System.out.println(“Integer value (after narrowing): ” + result);
}
}
Output:
Double value: 99.99
Integer value (after narrowing): 99
Here, the fractional part .99 is lost during conversion from double to int.
Type Casting with Primitive Data Types
Let’s look at more practical conversions:
public class PrimitiveCasting {
public static void main(String[] args) {
byte b = 10;
int i = b; // Widening (automatic)
int x = 300;
byte y = (byte) x; // Narrowing (manual) – possible data loss
System.out.println(“Byte to int (Widening): ” + i);
System.out.println(“Int to byte (Narrowing): ” + y);
}
}
Output:
Byte to int (Widening): 10
Int to byte (Narrowing): 44
Here, 300 does not fit into the byte range (-128 to 127), so the result becomes 44 due to overflow.
Type Casting with Objects (Upcasting and Downcasting)
Java also supports object typecasting with classes and interfaces.
- Upcasting: Converting a subclass reference into a superclass reference. (Implicit)
- Downcasting: Converting a superclass reference into a subclass reference. (Explicit, requires casting).
Example – Object Type Casting:
class Animal {
void sound() {
System.out.println(“Animal makes a sound”);
}
}
class Dog extends Animal {
void sound() {
System.out.println(“Dog barks”);
}
void fetch() {
System.out.println(“Dog fetches the ball”);
}
}
public class ObjectCasting {
public static void main(String[] args) {
// Upcasting (implicit)
Animal a = new Dog();
a.sound(); // Calls overridden method in Dog
// Downcasting (explicit)
Dog d = (Dog) a;
d.fetch(); // Access subclass-specific method
}
}
Output:
Dog barks
Dog fetches the ball
Here,
- Upcasting allows a Dog object to be treated as an Animal.
- Downcasting is required when we want to access subclass-specific methods like fetch().
Key Points to Remember
- Widening is safe and automatic; narrowing is manual and may cause data loss.
- Use explicit casting when converting from a larger to a smaller type.
- Object casting allows you to use polymorphism (upcasting) and access subclass-specific methods (downcasting).
- Always check for possible overflow or precision loss when narrowing.
Conclusion
Type casting in Java plays a vital role in both primitive data type conversion and object hierarchy handling. Understanding widening and narrowing conversions ensures safe and effective coding practices. By mastering typecasting, you can write cleaner, more flexible, and more efficient Java programs.