Introduction:

Java is a powerful programming language that supports type casting, allowing developers to convert variables from one type to another. Type casting plays a crucial role in programming, enabling the manipulation and transformation of data. In this blog, we will explore typecasting in Java through real-world scenarios, providing a comprehensive explanation and demonstrating its usage with example programs.

Method 1: Casting Primitives

Java supports both implicit and explicit casting for primitive types. Implicit casting occurs when a smaller data type is assigned to a larger data type, whereas explicit casting involves explicitly converting a larger data type to a smaller data type. Let's consider a scenario where we need to calculate the average temperature using integers:

int temperature1 = 25;
int temperature2 = 30;
double average = (temperature1 + temperature2) / 2.0;
System.out.println("Average temperature: " + average);

Output:

Average temperature: 27.5

In the example above, we explicitly cast the sum of temperature1 and temperature2 to a double by dividing it with 2.0. This ensures that the average value is calculated with decimal precision, resulting in an accurate output.

Method 2: Casting Objects

Java also allows casting between object types, primarily through inheritance relationships. Let's consider a scenario where we have a Vehicle class and two subclasses, Car and Bike:

class Vehicle {
    public void start() {
        System.out.println("Vehicle started.");
    }
}

class Car extends Vehicle {
    public void start() {
        System.out.println("Car started.");
    }
}

class Bike extends Vehicle {
    public void start() {
        System.out.println("Bike started.");
    }
}

Vehicle vehicle = new Car();
vehicle.start();

Car car = (Car) vehicle;
car.start();

Output:

Car started.
Car started.

In the example above, we create an instance of the Car class and assign it to a variable of type Vehicle. We can then call the start() method on the vehicle object, which invokes the overridden method in the Car class. This is an example of polymorphism. However, since the vehicle variable is of type Vehicle, we cannot directly access the Car class-specific methods. By explicitly casting vehicle to type Car, we can access and invoke the start() method of the Car class.

Method 3: Upcasting and Downcasting

Java also supports upcasting and downcasting, which are casting operations between related classes in an inheritance hierarchy. Upcasting is implicitly done by the compiler, while downcasting must be explicitly performed by the developer. Let's consider a scenario where we have an inheritance hierarchy of employees:

class Employee {
    protected String name;
    
    public Employee(String name) {
        this.name = name;
    }
    
    public void displayInfo() {
        System.out.println("Employee: " + name);
    }
}

class Manager extends Employee {
    private String department;
    
    public Manager(String name, String department) {
        super(name);
        this.department = department;
    }
    
    public void displayInfo() {
        System.out.println("Manager: " + name + ", Department: " + department);
    }
}

Employee emp = new Manager("John", "Sales");
emp.displayInfo();

Manager manager = (Manager) emp;
manager.displayInfo();

Output:

Manager: John, Department: Sales
Manager: John, Department: Sales

In the above example, we create an instance of the Manager class and assign it to a variable of type Employee. When we call the displayInfo() method on the emp object, it invokes the overridden method in the Manager class, displaying the appropriate information. By explicitly downcasting the emp object to type Manager, we regain access to the displayInfo() method specific to the Manager class.

Conclusion:

Type casting is a powerful feature in Java that allows developers to manipulate data and work with different types. In this blog, we explored various scenarios, including casting primitives, casting objects, upcasting, and downcasting. Understanding typecasting is crucial for writing efficient and flexible code, enabling the seamless transformation of data to meet the requirements of different scenarios.