Upcasting: Treating a Subclass as Its Superclass

Upcasting occurs when a subclass instance is referenced through a superclass variable, treating the more specialized type as a more general one. Because every subclass is a kind of its parent, this conversion is always safe and requires no explicit cast.

Consider a geometry hierarchy. A Rectangle is a Shape. A method that accepts Shape can receive a Rectangle without any extra syntax. Here is an example that processes multiple shapes uniformly:

class Shape {
    public void render(Shape s) {
        System.out.println("Rendering shape");
    }
}

class Circle extends Shape {
    @Override
    public void render(Shape s) {
        System.out.println("Rendering circle");
    }

    public static void main(String[] args) {
        Circle c = new Circle();
        c.render(c);               // Circle treated as Shape
        // Equivalent to: Shape ref = new Circle();
    }
}

The core benefit is polymorphic behavior. Code written against the parent type can operate on any descendant without modification. A single method can accept a Shape parameter and automatically dispatch to the correct implementation based on the actual runtime object.

Downcasting: Narrowing the Reference

Downcasting moves a reference from a broader type to a more specific subclass. It is not implicitly safe because the actual object may not be an instance of the target subclass. For example, a Shape variable pointing to a Rectangle cannot be directly assigned to a Circle reference. The comipler rejects the plain asssignment, but an explicit cast suppresses the compile‑time check — shifting the verificasion to runtime.

class Animal {
    public void feed() {
        System.out.println("Feeding animal");
    }
}

class Dog extends Animal {
    public void bark() {
        System.out.println("Woof");
    }

    public static void main(String[] args) {
        Animal a = new Dog();         // Upcast
        Dog d = (Dog) a;              // Downcast, safe because a refers to Dog
        d.bark();

        Animal generic = new Animal();
        // Dog wrong = (Dog) generic; // Compiles but throws ClassCastException at runtime
    }
}

If the underlying object is not compatible with the target class, a ClassCastException is thrown. Therefore, verifying the actual type before downcasting is essential.

Type Checking with instanceof

The instanceof operator tests whether an object reference is an instance of a specific class (or a subclass thereof). It returns true if the object's runtime type matches, allowing safe downcasting.

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

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

class Boat extends Vehicle {
    public void anchor() {
        System.out.println("Boat anchoring");
    }
}

public class TransportDemo {
    public static void main(String[] args) {
        Vehicle v = new Car();

        if (v instanceof Car) {
            Car c = (Car) v;
            c.honk();
        }

        if (v instanceof Boat) {
            Boat b = (Boat) v;   // This branch is never entered
        }

        // The following line would cause a compile‑time error because Boat is not in Vehicle's hierarchy
        // System.out.println(v instanceof String);
    }
}

The expression evaluates to a boolean, enabling conditional downcasts that prevent runtime exceptions. It works only with types in the same inheritance tree; attempting to check an unrelated class results in a compilation error.

Correct use of upcasting, downcasting, and instanceof helps build flexible yet robust polymorphic designs, where general interfaces handle diverse implementations while specialized behaviors remain safely accessible when needed.