Upcasting, Downcasting and instanceof

New words in this topic, in plain English. Come back here whenever one feels fuzzy.

Cast

Writing (Type) expression to view a value as another type. For references, it changes only the view, not the object.

Upcasting

Treating an object as one of its parent types, like Animal a = dog;. Automatic and always safe.

Downcasting

Treating a parent-typed reference as a more specific child type, like (Dog) animal. Needs the cast syntax and is checked at run time.

ClassCastException

The exception the JVM throws when a downcast is wrong: the object isn't an instance of the target type.

instanceof

An operator that answers 'is this object a T (or a subtype of T)?' with true or false. Always false for null.

Pattern variable

The new variable in x instanceof Dog d. It is declared and assigned only when the test succeeds.

checkcast

The bytecode instruction a downcast compiles to. It verifies the object's type at run time.

1. 1

   Rewrite play() with patterns

   In the first example, rewrite play() using if (a instanceof Dog d) d.fetch(); else if (a instanceof Cat c) c.purr();. The output must not change.

2. 2

   Cause and read a ClassCastException

   In the second example, remove the try/catch around (Integer) o and run. Read the full message: it names java.lang.String, java.lang.Integer, and the module java.base both come from.

3. 3

   Find the compile-time refusals

   Add Cat c = (Cat) new Dog(); to main and compile. Then try Runnable r = (Runnable) new Dog();: it compiles (Dog isn't final). Mark Dog as final and compile again to see the error appear.

Errors are the best teachers. Make each change, read the error, guess what went wrong, then reveal the answer.

class Animal { } class Dog extends Animal { } class Cat extends Animal { }
public class Main { public static void main(String[] a) { Dog d = new Dog(); Cat c = (Cat) d; } }

class Animal { }
class Dog extends Animal { }
class Cat extends Animal { }
public class Main { public static void main(String[] a) { Animal x = new Cat(); Dog d = (Dog) x; } }

1. 1

   Casting a reference never changes the object. It only changes the *declared type* through which you look at it. (Dog) animal doesn't convert anything; it tells the compiler 'trust me, treat this as a Dog' and asks the JVM to verify that claim. (Casting *primitives*, like (int) 3.9, is different: it really converts the value; see Topic 1.6.)

2. 2

   Upcasting goes from a subtype to a supertype: Animal a = new Dog();. It's implicit (no cast syntax needed) and can never fail, because every Dog is an Animal. You lose access to Dog-only methods through that reference, but the object keeps them.

3. 3

   Downcasting goes from a supertype to a subtype: Dog d = (Dog) a;. It needs explicit cast syntax and compiles to a checkcast bytecode instruction. At run time, if the object isn't a Dog (or a subclass of Dog), the JVM throws ClassCastException. A null reference passes any cast and stays null.

4. 4

   x instanceof T returns true if x is not null and its object could be cast to T without an exception. It is false for null, so it doubles as a null check. The compiler rejects instanceof tests and casts that could never succeed, such as String to Integer, or between two sibling classes.

5. 5

   Pattern matching for instanceof (Java 16) combines the test and the cast: if (a instanceof Dog d) { d.fetch(); }. The variable d exists only where the test is known to be true, and it works with && and with negation (if (!(o instanceof String s)) return; s.length();). It removes the repeated type name and the risk of casting to the wrong type.

6. 6

   Frequent downcasting is a design smell. If code keeps asking 'are you a Dog? are you a Cat?', the behaviour probably belongs in an overridden method (Topic 5.4), or the type should be sealed and handled with an exhaustive switch (Topic 5.11).

• ↔

  instanceof chains are quick to write but every new subtype means finding and updating every chain. Overridden methods (or sealed types with exhaustive switches) let the compiler find the places for you.

• ↔

  Downcasting is sometimes unavoidable at boundaries (deserialisation, equals, legacy APIs returning Object). Keep the casts at the edge and work with precise types inside.

• Done when you can explain why upcasting is free and downcasting is checked.

• Done when you can predict whether a cast fails to compile, fails at run time, or succeeds.

• Done when you can use instanceof patterns with && and negation.

• Done when you know null instanceof X is false and (X) null is allowed.

• Done when you can recognise downcast-heavy code as a design smell and suggest overriding instead.