🔧 Using a Superclass Reference for a Subclass Object

Consider a scenario where we create a class named User and then create a subclass that extends User called Employee.
Typically, we create an instance of User with:

User user = new User();

Here User is the type of the variable user, user is the variable that holds the instance of the class, and new User() creates a new instance of User.
Simply put, the user is an instance of User.

But what if the superclass User needs to use methods defined in its subclass Employee? Can this happen?
The short answer is yes, but only for overridden methods (methods that exist in both the superclass and the subclass). This is what enables polymorphism.
Since the relationship in inheritance is "is-a" relationship, Employee is-a User. so, nothing prevents User from holding a reference to an instance of its subclass Employee, as long as it is a compatible type.

This is done as follows:

User user = new Employee();

Now, let’s say the User class has two methods:

1. getUserName()
2. getUserSalary().

while the Employee class has an additional method called getEmployeeInformation() and overrides the getUserSalary() method.

THen with User user = new Employee();:

1. user.getUserName() will work, as it's defined in the User class.
2. user.getUserSalary() will also work, but the output will be from the overridden getUserSalary() method in the Employee class, not from the one in User. This is the essence of polymorphism.
3. user.getEmployeeInformation() will not work. It will throw a compilation error as it's specific to the Employee class.

A compilation error occurs when the compiler finds issues such as syntax errors, type mismatches, or other violations that prevent successful code compilation.

If we try to do the reverse and reference a subclass object Employee with a superclass reference User, it will not work without manual casting! This requires explicit casting, as User is not necessarily an Employee.

Upcasting VS. Downcasting

After explaining this in a simple way, with a simple example, let's focus on the terms.

"Superclass reference to subclass object" is typically called upcasting. Simply put, upcasting is typecasting a child object to a parent object, and it happens implicitly (meaning the compiler handles it automatically, so we do not need any specific casting syntax). It's like when we did User user = new Employee();.

What About Downcasting?

Downcasting is the exact opposite of upcasting.

Remember when we said that creating an Employee reference from a User instance is invalid? This is called downcasting, and it must be done explicitly using casting syntax. While upcasting is very safe, downcasting causes risks. This does not mean it's not useful, but it must be used with caution.

I won’t go into too much detail about downcasting since this article is focused on upcasting, but the key point is showing the main difference between downcasting and upcasting.

And that’s a wrap! :)