What is the difference between up-casting and down-casting with respect to class variable

java

casting

instanceof

polymorphism

byAlex Kataev·Mar 11, 2025

Up-casting is an automatic process of converting a reference from a subclass to a superclass. In contrast, down-casting is explicitly performed by the programmer to convert a superclass reference to a subclass type. Both processes are essential with respect to object-oriented programming in Java.

class Animal {}
class Dog extends Animal {}

// Up-casting: widening type conversion (no special syntax required)
Animal animal = new Dog(); 

// Down-casting: narrowing type conversion (explicit syntax is needed)
Dog dog = (Dog) animal;

While up-casting is always safe, down-casting can result in a ClassCastException if the actual object referenced is not of the expected subclass.

Casting scenarios: when and why

Up-casting:

Up-casting is virtually everywhere in Java as it provides a simple, safe way to:

Leverage polymorphism: Up-casting allows Java to treat an instance of a subclass as if it were an instance of a superclass, enabling polymorphism.
Ensure compatibility: It's used when an API demands a superclass type and you need to pass in a subclass object.

Down-casting:

Down-casting comes up less often, but is vital when:

Accessing subclass features: Superclass references can only be used to call methods and access variables that are part of the superclass. When you need to use methods that are only present in the subclass, down-casting becomes necessary.
Implementing custom behavior: When grouped objects of a superclass type need to implement subclass specific behavior, down-casting is required.

Safeguarding your code with `instanceof`

To avoid the infamous ClassCastException, you're always recommended to check the object's actual type using the instanceof operator, before attempting to down-cast it:

if (animal instanceof Dog) {
  Dog dog = (Dog) animal; //Safe! No "ruff" side effects here.
}

With Java 16, this instanceof check can be simplified using 'pattern matching' for improved readability:

if (animal instanceof Dog dog) {
  // Now you can refer to 'animal' as 'dog'! Less syntax, more semantic!
}

Method overriding and polymorphism

In the world of Java, methods are virtual by default, which means that a subclass can override a method in the superclass. Consequently, even when an instance is referred to by a superclass variable, the subclass's overridden method will be invoked:

class Animal {
  void makeSound() {
    System.out.println("Generic sound (mute button broken?)");
  }
}

class Dog extends Animal {
  void makeSound() {
    System.out.println("Woof woof (Translation: I'm a good boy!)");
  }
}

Animal pet = new Dog();
pet.makeSound(); // Output: Woof woof (Translation: I'm a good boy!)

Best practices for casting

To champion casting, remember to:

Confidently use **instanceof** before down-casting to avoid **ClassCastException**
Embrace new language features like pattern matching in Java 16 to improve readability
Understand the context in which methods are invoked to ensure successful upcasting and downcasting
Auto(donut)box = Autobox: They might sound similar, but understand their differences. Autoboxing is about wrapping primitive types into their corresponding wrapper classes
Strive for code maintainability. Clear, well-structured, and judiciously cast code is easy to read, debug, and extend