Computer Science A · Unit 9: Inheritance · 16 min read · Updated 2026-05-13

Inheritance — AP Computer Science A — AP Computer Science A

AP Computer Science A · Unit 9: Inheritance · 16 min read

1. Introduction to Inheritance, Superclasses, and Subclasses ★★☆☆☆ ⏱ 3 min

Inheritance is a core object-oriented programming (OOP) mechanism that lets you create new classes from existing classes, reusing shared code, extending functionality, and modeling hierarchical real-world relationships. It eliminates redundant code by centralizing shared attributes and methods in a single parent class, rather than rewriting the same logic across multiple related classes. Per the AP CS A CED, inheritance makes up 10-15% of your total AP CS A exam score, tested on both multiple-choice and free-response questions.

2. `extends` and `super` Keyword Usage ★★☆☆☆ ⏱ 4 min

To declare that a class inherits from another class, you use the `extends` keyword in Java. The `super` keyword has two critical use cases for subclasses: calling a superclass constructor, and accessing an overridden superclass method.

**Call superclass constructor**: `super()` must be the first line of a subclass constructor. If you do not explicitly write a `super()` call, Java automatically inserts a no-argument `super()` call. If your superclass does not have a no-argument constructor, you *must* explicitly call a parameterized `super()` to avoid a compile error.
**Call an overridden superclass method**: Use `super.methodName()` to access the superclass version of a method that you have overridden in the subclass.

📐 Worked Example

Extend the `Pet` superclass to create a `Dog` subclass with a unique `breed` attribute and `bark()` method. Correctly initialize inherited attributes.

Declare the subclass with `extends`, then use `super` to call the superclass constructor:
```java public class Dog extends Pet { private String breed; public Dog(String n, int a, String b) { // Call superclass constructor to initialize shared attributes super(n, a); breed = b; } public void bark() { System.out.println(getName() + " the " + breed + " barks: Woof!"); } public String getDetails() { // Use superclass getters for private superclass attributes return getName() + " is a " + getAge() + " year old " + breed; } } ```
If `super(n, a)` was omitted, the code would fail to compile: `Pet` has no no-argument constructor, so Java's implicit `super()` call would not match any existing constructor.

3. Method Overriding and `@Override` Annotation ★★★☆☆ ⏱ 3 min

Method overriding occurs when a subclass provides a specific implementation of a method that is already defined in its superclass. For a valid override, the method signature (name, parameter count, parameter types) must be exactly identical to the superclass method, the return type must be compatible, and the access modifier cannot be more restrictive than the superclass method.

4. Polymorphism and the IS-A Relationship ★★★★☆ ⏱ 3 min

Inheritance creates an **IS-A relationship**: every subclass instance is a type of its superclass. For example, a `Dog` IS-A `Pet`, but a `Pet` is not necessarily a `Dog`.

Polymorphism (meaning "many forms") leverages this relationship: a superclass reference variable can refer to an object of any subclass type. At runtime, the JVM calls the method version matching the actual object type, not the reference type: this is runtime polymorphism, the primary form tested on AP CS A.

📐 Worked Example

Demonstrate runtime polymorphism with an array of `Pet` references pointing to mixed subclass objects. What is the output when calling `makeSound()` on each element?

Create the array of superclass references holding mixed subclass objects:
```java Pet[] shelterPets = { new Dog("Buddy", 3, "Golden Retriever"), new Cat("Mittens", 2, "Tabby"), new Pet("Generic", 1) }; for (Pet p : shelterPets) { p.makeSound(); } ```
The output, determined by the actual object type at runtime, is:
``` Woof! Meow! Generic pet sound ```
A common exam rule: you cannot call a subclass-specific method on a superclass reference without casting. For example, `shelterPets[0].bark()` throws a compile error, because the `Pet` reference type has no `bark()` method. To access it, cast first: `((Dog) shelterPets[0]).bark();`

5. Introduction to Abstract Classes ★★★★☆ ⏱ 3 min

Common Pitfalls

Why: Students forget Java only inserts an implicit no-argument `super()` call, which will fail if no such constructor exists

Why: Students do not remember the method signature must be exactly identical for an override

Why: Students assume all inherited members are directly accessible

Why: Students confuse reference type (which determines allowed methods) with actual object type (which determines method implementation)

Why: Students confuse abstract blueprint classes with concrete instantiable classes

Quick Reference Cheatsheet

← Back to topic

Stuck on a specific question?
Snap a photo or paste your problem — Ollie (our AI tutor) walks through it step-by-step with diagrams.
Try Ollie free →