APCSA Question of the Week: Inheritance 1

The first ever ~Question of the Week~

This year, we'll be sharing the most difficult AP Computer Science A questions from the week. These multiple-choice questions will not only be difficult (based on the accuracy from Passionfruit students) but will use a question format that you'll almost certainly see on the real exam.

This week's question is from Unit 9: Inheritance, which represents 5-10% of the entire multiple-choice section.

Here's the link to the question on Passionfruit.

Only 12% of students correctly answer this question on their first try.

Try it for yourself before scrolling to see the answer and explanation below!

Explanation and Solution

Before diving into the solution, let's establish the fundamental principles at play:

1. Inheritance Basics

Think of inheritance like a family tree. When Child extends Parent, it inherits all public and protected methods. The Child class can:

• Use parent methods exactly as they are

• Override parent methods with its own implementations

• Add entirely new methods

2. The IS-A Relationship

This is a fundamental concept in inheritance. A Child IS-A Parent, but a Parent IS NOT necessarily a Child. It's like saying "every square is a rectangle, but not every rectangle is a square." This relationship affects how we can use these objects in our code.

3. Reference Types vs Object Types

This is where many students get tripped up. In Java:

• The reference type (left side of the declaration) determines what methods you can call

• The actual object type (right side after new) determines which implementation runs

Now let's analyze Each Method Call

I. p1.funC();

Parent p1 = new Parent();

p1.funC(); // Error!

• p1 is a Parent reference pointing to a Parent object

• Parent class doesn't have funC()

• This will fail at compilation

II. p2.funC()

Parent p2 = new Child();

p2.funC(); // Error!

• p2 is a Parent reference pointing to a Child object

• Even though the actual object (Child) has funC(), we can't access it through a Parent reference

• This will fail at compilation

III. p3.funB()

Child p3 = new Child();

p3.funB(); // Success!

• p3 is a Child reference pointing to a Child object

• Child inherits funB() from Parent

• This works perfectly fine

Therefore, the correct answer is Option C. Only III will execute without error.

Key Takeaways and Tips

1. The reference type determines method visibility

2. Inheritance creates an IS-A relationship

3. Objects can do everything their parent can do (and more)

4. Just because an object CAN do something doesn't mean you can access it through any reference type

I like to think of it like using different TV remotes:

• p1 is like having a basic TV with a basic remote

• p2 is like having a smart TV but using a basic remote (can't access smart features)

• p3 is like having a smart TV with the correct smart remote (full access)

This concept isn't just academic—it's fundamental to many programming patterns:

• Building flexible and maintainable systems

• Implementing plugin architectures

• Working with framework hierarchies

• Designing extensible APIs

Understanding these principles helps you write more robust and maintainable code, as you'll better understand how objects interact and what limitations exist when working with different reference types.

If you have any additional questions, feel free to ask Passionfruit's AI Tutor or email us at jason@passionfruitlearning.com.

See you next time!