Unit 9: Inheritance

Unit 9 introduces inheritance, the mechanism that lets a class reuse and specialize another class. It covers superclasses and subclasses, constructor chaining with super, method overriding, polymorphic method dispatch, and the Object superclass that sits above every class.

9.1 Creating Superclasses and Subclasses

Inheritance models an is-a relationship between classes. A Dog is an Animal, so Dog can extend Animal and reuse what Animal already defines. The superclass holds the shared behavior, and each subclass adds or changes only what is specific to it.

public class Animal {
    private String name;
    public Animal(String name) {
        this.name = name;
    }
    public String getName() {
        return name;
    }
}

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

The keyword extends goes on the class header, and a class extends exactly one superclass. The subclass inherits the accessible members of the superclass: public, protected, and package-level members in the same package. Two things are never inherited. Constructors are not inherited, so the subclass declares its own. Private members are not inherited either, which means the subclass cannot name them directly. If the subclass needs a private superclass field, it goes through a public or protected accessor, like getName() above.

9.2 Writing Constructors for Subclasses

A subclass constructor builds the superclass part of the object first, then the subclass part. The call super(...) invokes a superclass constructor, and it must be the first statement in the subclass constructor. Any statement before it is a compile error.

public class Dog extends Animal {
    private String breed;
    public Dog(String name, String breed) {
        super(name);
        this.breed = breed;
    }
}

If a constructor omits the super call, the compiler inserts super() with no arguments as the first line. That only works if the superclass has a no-argument constructor. Once a superclass declares any constructor with parameters and no no-arg constructor, the default no-arg constructor disappears, and every subclass constructor must call super(...) with matching arguments. The rule is simple. The subclass constructor hands the superclass constructor whatever arguments it needs, on the first line.

9.3 Overriding Methods

Overriding replaces an inherited method with a subclass version. The requirements are strict. The new method must have the same name and the exact same parameter list as the superclass method, the same signature. A different parameter list does not override. It creates an overload, a separate method that happens to share the name, and the inherited method still runs when the superclass signature is called.

public class Animal {
    public String speak() {
        return "generic sound";
    }
}
public class Dog extends Animal {
    @Override
    public String speak() {
        return "woof";
    }
}

Write @Override above every method you intend to override. The annotation is optional, but it turns a silent mistake into a compile error. Without it, a typo like Speak with a capital S compiles as a brand-new method while the inherited speak keeps running, and the bug shows up only in wrong output.

Three more limits apply. Private methods are not inherited, so a subclass cannot override them; a same-named method in the subclass is an unrelated method. Constructors cannot be overridden because they are not inherited. The overriding method cannot use a more restrictive access level than the original, so a public method stays public in the subclass.

9.4 The super Keyword

super reaches up to the superclass from inside the subclass, and it has two jobs. The first is super(...), the constructor call from topic 9.2, which is legal only as the first statement of a constructor. The second is super.method(), which calls the superclass version of an overridden method from inside the subclass.

public class Animal {
    public String getDescription() {
        return "an animal";
    }
}
public class Dog extends Animal {
    @Override
    public String getDescription() {
        return super.getDescription() + " that barks";
    }
}

Calling super.getDescription() runs the Animal version and lets Dog extend it instead of rewriting it. If the override called getDescription() without super, it would call itself and recurse forever. There is also super.field for reaching a hidden superclass field, but that situation is rare in AP code. The method form is the one the exam tests.

9.5 Creating References Using Inheritance Hierarchies

A reference variable has a declared type, from its declaration, and an actual type, the class of the object it points to at runtime. Java allows the actual type to be the declared type or any subclass of it.

Animal a = new Dog();      // legal: a Dog is an Animal
Dog d = new Animal();      // compile error: not every Animal is a Dog

Assigning a subclass object to a superclass reference is upcasting. It is always safe and needs no cast. The reverse is downcasting and needs an explicit cast, because the compiler cannot be sure the object is really a Dog.

Animal a = new Dog();
Dog d = (Dog) a;           // legal: the object really is a Dog
a.fetch();                 // compile error: Animal has no fetch method
((Dog) a).fetch();         // legal after the cast

The compiler checks casts against declared types. The JVM checks them against the actual object at runtime. A cast the compiler can prove impossible fails at compile time. A cast that looks possible but is wrong fails at runtime with a ClassCastException.

Animal a = new Animal();
Dog d = (Dog) a;           // compiles, throws ClassCastException at runtime

There is one more compile-time rule. A reference can only call methods its declared type knows. Animal a = new Dog() can call speak(), which Animal declares, but not fetch(), which only Dog declares, until a is cast to Dog.

9.6 Polymorphism

Polymorphism means the method that runs is chosen by the object's actual type at runtime, not by the reference's declared type. This choice is called dynamic dispatch.

Animal a = new Dog();
System.out.println(a.speak());   // prints "woof"

The reference says Animal, the object is a Dog, and Dog's version of the overridden instance method runs. This is why upcasting is useful. One reference type can hold many object types, and each object behaves like itself.

Three things do not dispatch polymorphically. Fields use the declared type at compile time.

public class Animal {
    public String label = "animal";
}
public class Dog extends Animal {
    public String label = "dog";
}
Animal a = new Dog();
System.out.println(a.label);     // prints "animal"

Static methods also bind to the declared type at compile time, and private methods and constructors are never overridden, so there is nothing to dispatch.

This is the unit's most tested idea. AP FRQs 2 and 3 use class hierarchies every year, and the tracing questions come down to one rule: for an overridden instance method, read the object's type. For a field or a static method, read the reference's type.

9.7 Object Superclass

Every class extends Object, directly or through its superclass chain, so every object inherits Object's methods. Two of them appear on the exam.

public String toString() returns a string representation of the object. The default version returns the class name followed by the object's hash code, something like Dog@1a2b3c. Classes override it to produce readable output, and println calls it automatically when you print an object.

public boolean equals(Object other) compares two objects. The default version checks identity, whether both references point to the same object, which is exactly what == does. To compare by content, a class overrides equals with the exact signature public boolean equals(Object other).

Confusions That Cost Points

Practice Questions

Original questions written for this guide in the style of the AP exam. Answers and explanations are on the next page, so complete the questions before checking them.

public class Dog extends Animal {
    private String breed;
    public Dog(String name, String breed) {
        this.breed = breed;
        super(name);
    }
}

public class Animal {
    private String name;
    public Animal(String name) { this.name = name; }
    public String getName() { return name; }
}
public class Dog extends Animal {
    public Dog(String name) { super(name); }
    public void printName() {
        System.out.println("Dog: " + name);
    }
}

Answer Key

1. B. The call to super must be the first statement in the constructor, and here an assignment comes first, so the code does not compile. A is wrong because Java never reorders your statements. C is wrong because the compiler never moves code; it only inserts a no-arg super() when no super call is present, and that is not this case. D is wrong because subclass constructors routinely declare their own parameters.

2. B. The field name is private in Animal, so printName cannot name it directly in the subclass. The error is reported at compile time. A assumes inheritance grants access to private fields, which it does not. C is wrong because the failure happens at compile time, so nothing ever runs. D gives the wrong reason; declaring a name field in Dog is legal, but the error here is access, not a missing declaration.

3. B. speak is an overridden instance method, so the object's actual type decides. The object is a Dog, so "woof" prints. This is dynamic dispatch. A reads the reference type, which only decides fields and static methods. C is wrong because speak is declared in Animal, so it is callable through an Animal reference. D is wrong because assigning a subclass object to a superclass reference is legal upcasting.

4. B. equals(Dog other) has a different parameter type than equals(Object other), so it overloads rather than overrides. Through the Object references d1 and d2, the call resolves to Object's equals, which compares identity, and two distinct objects are not identical, so it prints false. A assumes the name comparison runs, but it never gets called. C is wrong because the code compiles fine as an overload; only an override requires the Object parameter. D is wrong because every class extends Object, which defines equals(Object).

5. A. Fields do not dispatch polymorphically. The access a.label uses the declared type Animal at compile time, which holds "animal". B applies the method-dispatch rule to a field, which is the trap this question tests. C is wrong because a hidden field is legal and unambiguous through a typed reference. D is wrong because label is initialized in both classes.

6. C. The cast from Animal to Dog is plausible, so it compiles, but at runtime the object is a plain Animal, not a Dog, so the JVM throws a ClassCastException. A describes a successful downcast, which this is not. B is wrong because narrowing casts between related classes compile; the real check happens at runtime. D is wrong because nothing here is null.

7. A. Dispatch picks Dog's override because the object is a Dog. The override calls super.getDescription() for "an animal" and appends " that barks". B ignores the override entirely. C would happen only if the method called getDescription() without super, recursing into itself. D is wrong because super.method() is legal in any instance method; only super(...) is restricted to constructors.

8. B. Each object's own version of the overridden method runs: Dog prints "runs", Fish prints "swims", and the plain Animal prints "moves". A reads the reference type for all three elements. C assumes the first object's method applies to the whole array. D is wrong because any number of classes can extend one superclass; only multiple inheritance of classes is banned.

One-Page Recall Check

Say each answer out loud before you look back, and mark the ones you cannot finish. Anything you cannot say out loud yet belongs in your flashcard deck. In Rycal, add those items to the Inheritance deck and let spaced review bring them back over the next few days.

• Explain the is-a relationship and what extends means in a class header.
• List what a subclass inherits and what it does not inherit.
• State the super()-first rule and what the compiler inserts when you omit super(...).
• Write a subclass constructor that passes arguments up through super(...).
• State the exact requirements for overriding a method.
• Explain what @Override buys you.
• Distinguish overriding from overloading.
• Explain both uses of super.
• State which reference-to-object assignments compile and which need a cast.
• Trace a method call through a superclass reference to a subclass object.
• List what does not dispatch polymorphically.
• Explain what happens at runtime when a downcast is wrong.
• State what toString() and equals() do by default, and how to override each correctly.

Key terms for this unit

Inheritance, is-a relationship, Superclass, Subclass, extends, Constructor, super(), Overriding, @Override annotation, Overloading, Signature, Dynamic dispatch, Polymorphism, Declared type, Actual type, Upcasting, Downcasting, ClassCastException, instanceof, super.method(), Object superclass, toString(), equals(Object).

About this guide. Written for Rycal and aligned to the College Board AP Computer Science A course framework, Unit 9. All questions and explanations are original Rycal writing. Rycal is independent and is not affiliated with or endorsed by the College Board.