What Are Upcasting and Downcasting?

An upcast converts a reference to a subtype into a reference to a supertype. A downcast converts a reference to a supertype back into one to a subtype.

Upcasting is always safe and is always implicit. Every Dog is an Animal, so assigning a Dog reference to an Animal variable needs no cast and no annotation. The compiler allows it because the relationship is guaranteed by the type system, and the runtime type of the object does not change — the object is still a Dog, it is simply being referred to through a less specific type.

Downcasting is the reverse and it is explicit, because the compiler cannot know whether the object really is the subtype. If you hold an Animal reference that actually points at a Dog, the downcast succeeds and gives you a Dog reference. If it points at a Cat, the cast throws ClassCastException at run time. The cast is a promise you make to the compiler, and the JVM checks the promise when it executes.

public class Main {
    public static void main(String[] args) {
        // Upcasting: widening reference conversion, always safe, implicit.
        Animal animal = new Dog();
        System.out.println("upcast   : " + animal.speak());

        // Downcasting: narrowing, needs an explicit cast.
        Dog dog = (Dog) animal;
        System.out.println("downcast : " + dog.fetch());

        // The runtime type never changes, only the reference's view of it.
        System.out.println("runtime  : " + animal.getClass().getSimpleName());
    }
}

class Animal {
    String speak() {
        return "...";
    }
}

class Dog extends Animal {
    @Override
    String speak() {
        return "woof";
    }

    String fetch() {
        return "fetching the ball";
    }
}

The output shows the three things that matter. The upcast compiles with no ceremony. The downcast lets you call the Dog-specific method. And the runtime type is still Dog even after the upcast, which is why the downcast succeeds and why polymorphic dispatch still calls the Dog implementation of speak.

The one case where a downcast is not needed is a cast to the same type, or a cast to Object — but that is just an upcast, and it is written without parentheses.

The JVM throws a ClassCastException. It is an unchecked exception, so the compiler will not stop you — the cast is checked only when the code runs, and the check is whether the object's runtime type is compatible with the target type.

The safe pattern is to test with instanceof first. instanceof returns true only if the object is an instance of the named type or one of its subtypes, and it returns false rather than throwing when the reference is null. That last property makes it safe to use on a reference that might be null.

public class Main {
    public static void main(String[] args) {
        Object value = "a string";

        // The safe way: check first.
        if (value instanceof String) {
            String text = (String) value;
            System.out.println("length : " + text.length());
        }

        // The wrong cast throws ClassCastException.
        try {
            Integer number = (Integer) value;
            System.out.println(number);
        } catch (ClassCastException e) {
            System.out.println("ClassCastException: the object is not an Integer");
        }

        // instanceof returns false for null rather than throwing.
        Object nothing = null;
        System.out.println("null instanceof String : " + (nothing instanceof String));
    }
}

The output makes the contrast explicit. The guarded path prints the length of the string. The unguarded cast into an Integer throws. And the null check returns false, which is why instanceof doubles as a null check.

Two further points. Casting to an interface type is always allowed at compile time, even if no implementation could exist, so the ClassCastException can appear at a point far from where you expected it. And a cast to a final class is checked by the compiler in some situations, which can turn what looks like a run-time failure into a compile-time error.

The modern replacement for the manual check-and-cast is pattern matching for instanceof, which is now a standard part of the language. It combines the test and the cast into one step, removes the possibility of forgetting the cast, and avoids the double evaluation that the classic pattern can cause.