In Java, type casting is the process of converting one data type into another. This is often necessary when you're working with different types of data in your programs.
Java supports two types of casting:
Primitive Type Casting
Reference Type Casting (for objects and classes)
In this tutorial, we will cover:
Primitive type casting (automatic and explicit)
Reference type casting (upcasting and downcasting)
Code examples for each type of casting
Key considerations and common pitfalls
Table of Contents
1. Primitive Type Casting
Primitive type casting involves converting between primitive data types (e.g., int, float, double, char). There are two types of primitive casting:
Widening Casting (Automatic Type Conversion): This happens when a smaller data type is converted into a larger one (e.g., int to double). It is done automatically by the compiler.
Narrowing Casting (Explicit Type Conversion): This happens when a larger data type is converted into a smaller one (e.g., double to int). You need to perform this conversion manually.
Widening Casting (Automatic)
In widening casting, the smaller type is automatically promoted to a larger type without data loss.
Example 1: Widening Casting
public class WideningCastingExample {
public static void main(String[] args) {
int myInt = 100;
double myDouble = myInt; // Automatic conversion from int to double
System.out.println("Integer value: " + myInt); // 100
System.out.println("Double value: " + myDouble); // 100.0
}
}
Explanation:
The int value myInt is automatically cast to a double without any explicit type conversion.
Widening casting does not result in data loss.
Narrowing Casting (Explicit)
Narrowing casting involves manually converting a larger data type to a smaller data type. This can result in data loss if the larger type has more precision than the smaller type.
Example 2: Narrowing Casting
public class NarrowingCastingExample {
public static void main(String[] args) {
double myDouble = 9.78;
int myInt = (int) myDouble; // Manual conversion from double to int
System.out.println("Double value: " + myDouble); // 9.78
System.out.println("Integer value: " + myInt); // 9 (fractional part is lost)
}
}
Explanation:
The double value myDouble is explicitly cast to an int using (int).
The fractional part (0.78) is lost during the conversion since int cannot hold decimal values.
2. Reference Type Casting
Reference type casting is used when working with objects and classes. It involves casting between objects of different classes that share an inheritance relationship.
There are two types of reference type casting:
Upcasting: Casting a subclass to its superclass.
Downcasting: Casting a superclass to a subclass.
Upcasting
Upcasting is casting an object of a subclass to its superclass type. This is safe and is often done automatically by the compiler.
Example 3: Upcasting
class Animal {
public void sound() {
System.out.println("Animal makes a sound");
}
}
class Dog extends Animal {
public void sound() {
System.out.println("Dog barks");
}
}
public class UpcastingExample {
public static void main(String[] args) {
Dog dog = new Dog();
Animal animal = dog; // Upcasting (Dog to Animal)
animal.sound(); // Dog barks (runtime polymorphism)
}
}
Explanation:
The Dog object is upcast to its superclass type Animal.
Although the reference is of type Animal, the Dog class method sound() is called because of runtime polymorphism.
Downcasting
Downcasting is casting an object of a superclass back to its subclass type. This requires an explicit cast and can result in a ClassCastException if the object being cast is not actually an instance of the subclass.
Example 4: Downcasting
class Animal {
public void sound() {
System.out.println("Animal makes a sound");
}
}
class Dog extends Animal {
public void bark() {
System.out.println("Dog barks");
}
}
public class DowncastingExample {
public static void main(String[] args) {
Animal animal = new Dog(); // Upcasting
Dog dog = (Dog) animal; // Downcasting (Animal to Dog)
dog.bark(); // Dog barks
}
}
Explanation:
The Animal reference is cast back to the Dog type using an explicit cast (Dog).
Once downcast, you can access Dog-specific methods such as bark().
Example 5: Downcasting with instanceof Check
To avoid ClassCastException, it is a good practice to use the instanceof operator to check whether an object can be safely downcast.
class Animal {
public void sound() {
System.out.println("Animal makes a sound");
}
}
class Dog extends Animal {
public void bark() {
System.out.println("Dog barks");
}
}
class Cat extends Animal {
public void meow() {
System.out.println("Cat meows");
}
}
public class SafeDowncastingExample {
public static void main(String[] args) {
Animal animal = new Dog(); // Upcasting
if (animal instanceof Dog) {
Dog dog = (Dog) animal; // Safe downcasting
dog.bark(); // Dog barks
} else {
System.out.println("The object is not a Dog");
}
Animal anotherAnimal = new Cat();
if (anotherAnimal instanceof Dog) {
Dog dog = (Dog) anotherAnimal; // Unsafe, will not execute
dog.bark();
} else {
System.out.println("The object is not a Dog"); // This will execute
}
}
}
Explanation:
instanceof is used to check if the animal object can be safely cast to the Dog type.
In the second case, anotherAnimal is a Cat, so downcasting to Dog is not allowed, and the check prevents a ClassCastException.
3. Mixed Type Casting (Combining Primitive and Reference Casting)
Sometimes, you may encounter situations where both primitive and reference type casting are involved. For example, using wrapper classes for primitive types.
Example 6: Using Wrapper Classes for Mixed Casting
public class WrapperCastingExample {
public static void main(String[] args) {
// Primitive to wrapper class (autoboxing)
int primitiveInt = 42;
Integer wrapperInt = primitiveInt; // int to Integer (autoboxing)
// Wrapper class to primitive (unboxing)
int unboxedInt = wrapperInt; // Integer to int (unboxing)
// Using wrapper class in reference type casting
Object obj = wrapperInt; // Upcasting to Object
if (obj instanceof Integer) {
Integer castedInt = (Integer) obj; // Downcasting to Integer
System.out.println("Casted value: " + castedInt); // 42
}
}
}
Explanation:
Autoboxing: Automatically converting a primitive type (int) to its corresponding wrapper class (Integer).
Unboxing: Automatically converting a wrapper class (Integer) back to its primitive type (int).
Wrapper classes can also be cast as reference types like Object, and you can downcast them back to the original wrapper type.
4. Key Considerations and Pitfalls
1. Data Loss in Narrowing Casting
When narrowing primitive data types, there can be data loss, especially when converting floating-point types to integer types.
double myDouble = 9.999; int myInt = (int) myDouble; // Narrowing, fractional part lost System.out.println(myInt); // Outputs: 9
2. ClassCastException in Downcasting
Downcasting without proper checks can lead to a ClassCastException at runtime.
Animal animal = new Animal(); Dog dog = (Dog) animal; // This will throw ClassCastException
To avoid this, always use the instanceof operator before downcasting.
3. Upcasting is Safe
Upcasting is always safe because the subclass object contains all the properties of the superclass. The compiler handles it automatically.
4. Use of Wrapper Classes
Autoboxing and unboxing allow seamless conversions between primitives and their corresponding wrapper classes. However, be cautious with performance when dealing with large amounts of autoboxing/unboxing.
Conclusion
In this tutorial, we covered the basics of type casting in Java, including:
Primitive type casting: Widening (automatic) and narrowing (explicit) casting.
Reference type casting: Upcasting (safe) and downcasting (requires care).
Mixed casting using wrapper classes.
Best practices and common pitfalls such as data loss and ClassCastException.
Understanding type casting is crucial for working with different types of data in Java, and following best practices can help avoid runtime exceptions and data loss.