Upcasting and downcasting in Java - Time & Space Complexity

Time Complexity: Upcasting and downcasting

O(n)

Understanding Time Complexity

We want to understand how the time it takes to run code changes when using upcasting and downcasting in Java.

Specifically, we ask: does casting affect how long the program runs as the input size grows?

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

class Animal { }
class Dog extends Animal { void bark() {} }

public class Main {
  public static void main(String[] args) {
    Animal[] animals = new Dog[1000];
    for (int i = 0; i < animals.length; i++) {
      animals[i] = new Dog(); // upcasting
    }
    for (Animal a : animals) {
      Dog d = (Dog) a; // downcasting
      d.bark();
    }
  }
}
    

This code creates an array of Dogs stored as Animals (upcasting), then converts each back to Dog (downcasting) to call a Dog method.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: Two loops each running through the array of animals.
• How many times: Each loop runs once over all elements, so 1000 times in this example.

How Execution Grows With Input

As the number of animals grows, the loops run more times, so the work grows proportionally.

Input Size (n)	Approx. Operations
10	About 20 operations (2 loops x 10)
100	About 200 operations
1000	About 2000 operations

Pattern observation: The total work grows directly with the number of elements, doubling the input doubles the work.

Final Time Complexity

Time Complexity: O(n)

This means the time to run the code grows in a straight line with the number of elements processed.

Common Mistake

[X] Wrong: "Casting objects takes extra loops or slows down the program significantly."

[OK] Correct: Casting is a simple check or reference change done once per object, it does not add extra loops or big work as input grows.

Interview Connect

Understanding how casting fits into time complexity helps you explain performance clearly and shows you know what parts of code affect speed.

Self-Check

"What if we added a nested loop inside the downcasting loop to check each Dog against all others? How would the time complexity change?"

Practice

1. What is upcasting in Java?
Upcasting means:

easy

A. Changing the value of a variable

B. Treating a specific object as a more general type

C. Creating a new object from a class

D. Converting a general type to a specific type

Solution

1. Step 1: Understand object type hierarchy

   In Java, classes can inherit from other classes, making some types more general (superclass) and others more specific (subclass).

2. Step 2: Define upcasting

   Upcasting means treating a subclass object as if it were an instance of its superclass, which is more general.

3. Final Answer:

   Treating a specific object as a more general type -> Option B

4. Quick Check:

   Upcasting = Treat specific as general [OK]

Hint: Upcasting = subclass object as superclass type [OK]

Common Mistakes:

• Confusing upcasting with downcasting
• Thinking upcasting creates a new object
• Believing upcasting changes the actual object type

2. Which of the following is the correct syntax for downcasting in Java?

Animal a = new Dog();
// Downcast here

easy

A. Dog d = (Dog) a;

B. Dog d = a;

C. Dog d = a.toDog();

D. Dog d = (Animal) a;

Solution

1. Step 1: Understand downcasting syntax

   Downcasting requires an explicit cast to convert a superclass reference back to a subclass type.

2. Step 2: Apply correct cast

   The correct syntax is: SubclassType var = (SubclassType) superClassVar; so here: Dog d = (Dog) a;

3. Final Answer:

   Dog d = (Dog) a; -> Option A

4. Quick Check:

   Downcasting needs explicit cast [OK]

Hint: Downcast with (Subclass) before variable [OK]

Common Mistakes:

• Omitting the cast operator
• Casting to wrong type
• Using methods like toDog() which don't exist

3. What will be the output of this code?

class Animal { void sound() { System.out.println("Animal sound"); } }
class Dog extends Animal { void sound() { System.out.println("Bark"); } void fetch() { System.out.println("Fetching"); } }
public class Test {
  public static void main(String[] args) {
    Animal a = new Dog(); // upcasting
    a.sound();
    // a.fetch(); // line A
    ((Dog) a).fetch(); // line B
  }
}

medium

A. Bark\nFetching

B. Bark\nAnimal sound

C. Animal sound\nFetching

D. Compilation error at line A

Solution

1. Step 1: Understand method overriding and upcasting

   Variable a is of type Animal but refers to a Dog object. Calling a.sound() calls Dog's overridden method, printing "Bark".

2. Step 2: Analyze method call fetch()

   Method fetch() is not in Animal, so a.fetch() is invalid (commented out). Downcasting (Dog) a allows calling fetch(), printing "Fetching".

3. Final Answer:

   Bark Fetching -> Option A

4. Quick Check:

   Upcast calls overridden method, downcast calls subclass method [OK]

Hint: Upcast calls overridden; downcast needed for subclass-only methods [OK]

Common Mistakes:

• Thinking a.sound() calls Animal's method
• Trying to call fetch() without downcasting
• Confusing compile vs runtime errors

4. Identify the error and fix it in this code:

class Animal {}
class Cat extends Animal { void meow() { System.out.println("Meow"); } }
public class Test {
  public static void main(String[] args) {
    Animal a = new Animal();
    Cat c = (Cat) a; // line X
    c.meow();
  }
}

medium

A. No error, code runs fine

B. Syntax error; fix by removing cast

C. ClassCastException at runtime; fix by checking instanceof before casting

D. Change Animal to Cat in line X

Solution

1. Step 1: Identify the casting problem

   Variable a refers to an Animal object, not a Cat. Casting Animal to Cat without checking causes ClassCastException at runtime.

2. Step 2: Fix with instanceof check

   Before casting, check if (a instanceof Cat) to ensure safe downcasting and avoid runtime error.

3. Final Answer:

   ClassCastException at runtime; fix by checking instanceof before casting -> Option C

4. Quick Check:

   Downcast only if instanceof true [OK]

Hint: Use instanceof before downcasting to avoid errors [OK]

Common Mistakes:

• Ignoring runtime ClassCastException
• Assuming cast always works
• Trying to fix with syntax changes only

5. Given these classes:

class Vehicle { void start() { System.out.println("Vehicle started"); } }
class Car extends Vehicle { void start() { System.out.println("Car started"); } void openTrunk() { System.out.println("Trunk opened"); } }
class Bike extends Vehicle { void start() { System.out.println("Bike started"); } void kickStart() { System.out.println("Kickstarted"); } }

Which code snippet correctly upcasts and downcasts to call openTrunk() safely?

hard

A. Vehicle v = new Vehicle();
if (v instanceof Car) {
((Car) v).openTrunk();
}

B. Vehicle v = new Bike();
((Car) v).openTrunk();

C. Car c = new Vehicle();
c.openTrunk();

D. Vehicle v = new Car();
if (v instanceof Car) {
((Car) v).openTrunk();
}

Solution

1. Step 1: Understand upcasting and downcasting here

   Variable v is declared as Vehicle but assigned a Car object (upcasting). To call Car-specific method openTrunk(), downcast is needed.

2. Step 2: Check safe downcasting

   Using instanceof ensures v is actually a Car before downcasting and calling openTrunk(). This avoids runtime errors.

3. Final Answer:

   Vehicle v = new Car(); if (v instanceof Car) { ((Car) v).openTrunk(); } -> Option D

4. Quick Check:

   Upcast then instanceof check before downcast [OK]

Hint: Always check instanceof before downcasting [OK]

Common Mistakes:

• Downcasting without instanceof check
• Assigning superclass object to subclass variable
• Calling subclass methods on superclass references without cast