The super.method() call.
When a subclass needs to keep the parent's behavior while adding its own, this single Java construct is the bridge.
An overriding method can invoke its parent's version using super.method(). This pattern reuses the parent's logic and combines it with new subclass behavior.
Without super, you would have to either duplicate the parent's code (brittle) or sacrifice the parent's behavior entirely (loses reuse).
On the AP exam, the super.method() call is required in many FRQ rubrics — particularly for accessor overrides that combine inherited fields with new ones.
Use super to bypass dynamic dispatch.
Call the parent's literal implementation, not the overridden version.
Syntax
@Override
public ReturnType method(args) {
// ... maybe pre-work
ReturnType base = super.method(args);
// ... maybe post-work
return modifiedResult;
}Without super — infinite recursion
@Override
public String toString() {
return toString() + " extra"; // calls itself forever!
}The fix is the explicit super:
@Override
public String toString() {
return super.toString() + " extra";
}Where super resolves to
super.method() always calls the version defined in the immediate parent class. There's no need to specify which class — Java follows the inheritance chain upward until it finds the method.
super vocabulary.
Used in every override-with-reuse problem.
- super — keyword referring to the parent class.
- super.method() — invokes the parent's implementation of method.
- super(args) — invokes the parent's constructor (first line of subclass constructor).
- Reuse — leveraging parent logic in a subclass.
- Override — replacing a parent method in a subclass.
- Bypass dispatch — using super to skip the subclass's own version.
How super.method() is tested.
Recognizing when to call super and avoiding recursion dominate.
- Use super in the override. Required when the rubric says "build on the inherited result".
- Don't call the method directly inside itself. Causes infinite recursion.
- super for methods, this for fields. Different qualifiers.
- super() in constructors must be the first line. Java rule.
Override toString that calls super.
Standard pattern for adding to inherited output.
Setup. Animal has toString() returning the name; Dog adds a breed.
public class Animal {
private String name;
public Animal(String n) { name = n; }
public String toString() { return "Animal: " + name; }
}
public class Dog extends Animal {
private String breed;
public Dog(String n, String b) {
super(n);
breed = b;
}
@Override
public String toString() {
return super.toString() + " (breed: " + breed + ")";
}
}Trace. new Dog("Rex", "Labrador").toString():
- Dog.toString() runs.
- super.toString() returns "Animal: Rex".
- Append " (breed: Labrador)".
Answer: "Animal: Rex (breed: Labrador)".
super pitfalls.
Most cause recursion or compile errors.
- Self-call without super. Causes infinite recursion → stack overflow.
- super() not on first line of constructor. Compile error.
- Using super on a field. Fields use
this, not super (for normal access). - Calling super on a non-existent method. Compile error.
super patterns.
When and how.
super Reference
AP Quick Reference| Form | Meaning | Where |
|---|---|---|
super(args) | Parent constructor | First line of constructor. |
super.method(args) | Parent method | Inside any method. |
| No super | Subclass version (or self) | Beware recursion. |
How to master super.
Recognize when reuse beats rewrite.
- MCQ Practice — for each override, check whether super is needed to avoid recursion.
- Java Lab — write Animal/Dog, Employee/Manager. Override toString and accessors with super.
- FRQ Practice — use super whenever the rubric mentions "in addition to" the inherited behavior.
Practice — attempt these now.
AP-style assessments aligned to this lesson. Time them.
AP CSA Unit 08 Topic 03 Overriding That Calls the Superclass Method FRQ Practice
AP-style topic practice assessment