1. Introduction
The super keyword in Java is a reference used inside a subclass to refer to its immediate superclass. It is used to access parent class fields or methods that have been shadowed or overridden, and to invoke the parent class's constructor.
Cricket analogy: A state cricket academy's junior coach refers back to the senior national coach's playbook when a drill name clashes with the academy's own version, and always starts a new player's training by first completing the national program's basic induction—like super accessing shadowed members and calling the parent constructor.
Using super is essential whenever a subclass needs to build on top of, rather than completely replace, its parent's behavior or state.
Cricket analogy: A young all-rounder who wants to add a signature reverse-swing variation still needs the base fast-bowling technique taught by the senior academy first—building on top of, not replacing, the fundamentals, just as super lets a subclass extend rather than discard parent behavior.
2. Syntax
class Parent {
int value = 10;
Parent() {
System.out.println("Parent constructor");
}
void show() {
System.out.println("Parent show()");
}
}
class Child extends Parent {
int value = 20;
Child() {
super(); // calls Parent() constructor, must be first statement
System.out.println("Child constructor");
}
void show() {
super.show(); // calls Parent's show()
System.out.println("Child show(), super.value = " + super.value);
}
}3. Explanation
super has three main uses. First, super.fieldName accesses a field in the parent class that is shadowed by a field of the same name in the subclass. Second, super.methodName(...) explicitly calls the parent class's version of a method that the subclass has overridden. Third, super(...) invokes a constructor of the parent class.
Cricket analogy: super.fieldName is like referring to the senior team's official strike rate when the junior team has its own separate stat with the same name; super.methodName() is like a junior bowler explicitly performing the senior academy's classic bowling action instead of their own tweaked version; super(...) is like a rookie completing the national fitness test before starting any team-specific training.
When used to call a constructor, super(...) must be the very first statement in the subclass constructor. If you do not write a call to super(...) explicitly, the compiler automatically inserts a no-argument super() call as the first statement — this only works if the parent class has a no-argument constructor.
Cricket analogy: A cricketer must pass the board's mandatory fitness certification (super()) before any team-specific training begins, and if they don't explicitly schedule it, the academy automatically enrolls them in the default certification first—just as the compiler inserts a no-arg super() call automatically.
Exam tip: Only one of super(...) or this(...) may appear in a constructor, and it must be the first statement — you cannot use both, and you cannot place either after other statements.
If the parent class does NOT define a no-argument constructor and the subclass does not explicitly call super(args) with matching arguments, the code fails to compile with 'no default constructor available'.
4. Example
class Parent {
int value = 10;
Parent(String msg) {
System.out.println("Parent constructor: " + msg);
}
void show() {
System.out.println("Parent show()");
}
}
class Child extends Parent {
int value = 20;
Child() {
super("initializing");
System.out.println("Child constructor");
}
void show() {
super.show();
System.out.println("Child show(), child value=" + value + ", parent value=" + super.value);
}
}
public class Main {
public static void main(String[] args) {
Child c = new Child();
c.show();
}
}5. Output
Parent constructor: initializing
Child constructor
Parent show()
Child show(), child value=20, parent value=106. Key Takeaways
- super refers to the immediate parent class from within a subclass.
- super.field accesses a shadowed field in the parent class.
- super.method() calls the parent's version of an overridden method.
- super(...) invokes the parent constructor and must be the first statement in the subclass constructor.
- If omitted, the compiler inserts an implicit no-argument super() call automatically.
Practice what you learned
1. Where must a super(...) constructor call appear in a subclass constructor?
2. What happens if a subclass constructor does not call super(...) explicitly and the parent class has no no-argument constructor?
3. What does super.methodName() do when the subclass has overridden that method?
4. Can both super(...) and this(...) be used together as separate statements in the same constructor?
5. What is super.value used for when a subclass field shadows a parent field of the same name?
Was this page helpful?
You May Also Like
Inheritance in Java
Understand Java inheritance using the extends keyword, the super keyword, single inheritance rules, and the Object root class.
Method Overriding in Java
Understand how Java subclasses override inherited methods, the rules governing overriding, and how runtime polymorphism resolves the actual method called.
Constructors in Java
Understand Java constructors — default, parameterized, overloaded, and chained — with syntax rules and worked examples.
Related Reading
Related Study Notes in Programming
Browse all study notesApache Spark Study Notes
Programming · 30 topics
ProgrammingApache Flink Study Notes
Programming · 30 topics
ProgrammingHadoop Study Notes
Programming · 30 topics
ProgrammingSnowflake Study Notes
Programming · 30 topics
ProgrammingApache Airflow Study Notes
Programming · 30 topics
Programmingdbt (Data Build Tool) Study Notes
Programming · 30 topics