Upcasting Vs DownCasting in Java

In OOP, “flexibility” and “reusability” are the kings. Type casting in Java is one of the powerful tools a Java developer uses on a daily basis. We’ve all cast basic data types (putting an int into a double), and that’s what I think of when using the word “cast” but the real power comes from casting object references.

In this complete guide, we will discuss Upcasting Vs Downcasting in Java (or generalization and specialization). It is important to have a clear concept of Java object casting so you can learn Java polymorphism casting and you will also be able to write good, clean ans scalable code.

What is Type Casting in Java?

First, let's break down our topic before we dig further into each detail. Type casting is a method to change the data type of a particular value or variable. When we are talking about objects, it’s a reference of one class type to another in the same inheritance hierarchy. And this is called Java OOP casting.

Object Casting’s Two Pillars:

Target Base: Walking up the inheritance graph (Child to Parent).

Downcasting: Moving down the hierarchy (Parent to Child).

Upcasting in Java: Why you can exchange between parent and child and how it works!

Upcasting in Java Upcasting is writing a subclass object to a superclass object. It is an example of Runtime type casting in Java that is done implicitly by the compiler.

Why is Upcasting Implicit?

Upcasting is inherently safe. A "Dog" is an "Animal," so every method and property of Animal will be found in Dog. Thu,s there is no need for a special syntax in the Java compiler to do this conversion.

class Employee {

String name = "Generic Employee";

public void work() {

System. out. println("Employee is working...");

}

}

class Manager extends Employee {

int teamSize = 10;

@Override

public void work() {

System. out. println("Manager is leading a team of " + teamSize);

}

public void conductMeeting() {

System. out. println("Manager is conducting a meeting." );

}

}

public class Main {

Image public static void main(String[] args) {

// Upcasting: Child object to Parent reference 10.

Employee emp = new Manager();

emp. work(); // Calls overridden method in Manager

System. out. println(emp. name);

// emp. conductMeeting(); // COMPILE ERROR: and employee reference does not know about manager methods

}

}

Upcasting and Downcasting Examples:

Let's say we have an inheritance relationship like this: Manager extends Employee.

class Employee {

String name = "Generic Employee";

public void work() {

System. out. println("Employee is working...");

}

}

class Manager extends Employee {

int teamSize = 10;

@Override

public void work() {

System. out. println("Manager has a team of " + teamSize);

}

public void conductMeeting() {

System. out. println("Manager is conducting a meeting." );

}

}

public class Main {

public static void main (String[] args) {

// Upcasting: Child object to Parent reference package Casting; public class Actor { String name; void work() { System.out.println(name + " is an actor!"); } } class Superstar extends Actor { String majorWork; void dance() { System.out.println("Dancing makes everything better."); } } class JuniorArtist extends Actor { void getDialogues() { System.out.println("Please give me some dialogues to speak!"); } } class TestCasting { /** * Handles upcasting */ public static void main(String[] args) { Superstar ss = new Superstar(); JuniorArtist ja = new JuniorArtist(); //Step 1 ss.work(); ja.work(); //Will call the parent's work method. System.out.println(ss.majorWork); // valid ///System.out.print( ((Actor)ss).majorWork); Invalid compilation error as compile time type decides which field can be accessed. ss = (Superstar) ja; //upcast ((Actor)ja).work(); // runtime? will always call the grandparent method only. System.out.print(ja.getClass().getSimpleName());   /juniorartst } }

Employee emp = new Manager();

emp. work(); // Invokes override method in Manager

System. out. println(emp. name);

// emp. conductMeeting(); // COMPILE ERROR: Employee reference is unaware of the Manager methods

}

}

Key Characteristics of Upcasting:

Restricting the Set of Method: Now, even though the true object is a Manager, the reference emp can only "see" those members defined in the Employee class.

Polymorphic: When a method is overridden in the subclass (like work()) runtime of Java will call the child version. This is the crux of Java polymorphism casting.

Downcasting in Java

Downcasting in Java is the reverse of Upcasting. It is a way to cast a reference of parent class similar to a subclass.

Characteristics of Downcasting

Manual: It has to be done manually with the cast operator (ClassName).

Unsafe: Yeah, it’s not safe on its face. If the object you are casting is not an instance of that target subclass, Java will cause a ClassCastException.

Runtime Check: It is also known as Runtime type casting in Java because the cast will be checked at run time.

Downcasting Example

To handle downcasting safely, we commonly employ the instanceof operator:

Animal myAnimal = new Dog(); // First upcast it.

// Downcasting: Animal reference returned to Dog let act: Dog = new return; }{return;}

if (myAnimal instanceof Dog) {

Dog myDog = (Dog) myAnimal;

myDog. bark(); //Can access to Dog specific methods now.

}

The Role of Polymorphism

Java polymorphism casting is the reason we do such tricks. Upcasting lets us write to the interface. For example, a method void makeAnimalSpeak(Animal a) can take just as well a Dog, Cat, or Lion through upcasting.

But does that method really need to do "Fetch" (which exists only in the Dog implementation), so you need to have Java Runtime casting (downcast type of the object after it has been checked for its identity).

Popular Java type casting interview questions

If you are in the process of preparing for a Java-related role, you will appreciate that there is a substantial body of difficult Java type-casting interview questions. Here are a few common ones:

Upcasting is implicit, so why is downcasting explicit?

Answer: Upcasting is guaranteed to succeed because every subclass is an instance of its superclass. Downcasting is dangerous because the reference to a superclass might not be to that specific subclass at all.

What happens when you down-cast but this time without an explicit cast?

Answer: The code will not compile. Java makes downcasting explicit by requiring the developer to recognise the risk of casting an int in plain syntax.

What is a ClassCastException?

Answer: It is the runtime exception thrown by the compiler if you try to typecast an object of one type to another type, which is not actually an instance of the latter type.

How do you prevent ClassCastException?

Answer: By verifying the type of object using instanceof keyword before casting it.

Do watch the video on Java: SevenMentor