If your method overrides one of its superclass's methods, you can invoke the overridden method through the use of the keyword super
. You can also use super
to refer to a hidden field [although hiding fields is discouraged]. Consider this class, Superclass
:
public class Superclass { public void printMethod[] { System.out.println["Printed in Superclass."]; } }
Here is a subclass, called Subclass
, that overrides printMethod[]
:
public class Subclass extends Superclass { // overrides printMethod in Superclass public void printMethod[] { super.printMethod[]; System.out.println["Printed in Subclass"]; } public static void main[String[] args] { Subclass s = new Subclass[]; s.printMethod[]; } }
Within Subclass
, the simple name printMethod[]
refers to the one declared in Subclass
, which overrides the one in Superclass
. So, to refer to printMethod[]
inherited from Superclass
, Subclass
must use a qualified name, using super
as shown. Compiling and executing Subclass
prints the following:
Printed in Superclass. Printed in Subclass
Subclass Constructors
The following example illustrates how to use the super
keyword to invoke a superclass's constructor. Recall from the
public class Subclass extends Superclass { // overrides printMethod in Superclass public void printMethod[] { super.printMethod[]; System.out.println["Printed in Subclass"]; } public static void main[String[] args] { Subclass s = new Subclass[]; s.printMethod[]; } }9 example that
Printed in Superclass. Printed in Subclass0 is a subclass of
public class Subclass extends Superclass { // overrides printMethod in Superclass public void printMethod[] { super.printMethod[]; System.out.println["Printed in Subclass"]; } public static void main[String[] args] { Subclass s = new Subclass[]; s.printMethod[]; } }9. Here is the
Printed in Superclass. Printed in Subclass0 [subclass] constructor that calls the superclass constructor and then adds initialization code of its own:
public MountainBike[int startHeight, int startCadence, int startSpeed, int startGear] { super[startCadence, startSpeed, startGear]; seatHeight = startHeight; }
Invocation of a superclass constructor must be the first line in the subclass constructor.
The syntax for calling a superclass constructor is
or:With
Printed in Superclass. Printed in Subclass3, the superclass no-argument constructor is called. With
Printed in Superclass. Printed in Subclass4, the superclass constructor with a matching parameter list is called.Note: If a constructor does not explicitly invoke a superclass constructor, the Java compiler automatically inserts a call to the no-argument constructor of the superclass. If the super class does not have a no-argument constructor, you will get a compile-time error.
Printed in Superclass. Printed in Subclass5 does have such a constructor, so if
Printed in Superclass. Printed in Subclass5 is the only superclass, there is no problem.
If a subclass constructor invokes a constructor of its superclass, either explicitly or implicitly, you might think that there will be a whole chain of constructors called, all the way back to the constructor of
Printed in Superclass. Printed in Subclass5. In fact, this is the case. It is called constructor chaining, and you need to be aware of it when there is a long line of class descent.
Inheritance is a core feature in object-oriented programming that allows a developer to define a new class from an existing class. For instance, a class to store the suppliers of meat at a local health foods store could be defined based on a class to store any product sold at the store.
When you’re working with inheritance in Java, you’ll likely encounter the super keyword. The super keyword is used to access superclass members inside a subclass, and has a variety of uses when inheriting superclass members.
Find Your Bootcamp Match
- Career Karma matches you with top tech bootcamps
- Access exclusive scholarships and prep courses
First name
Last name
Phone number
By continuing you agree to our Terms of Service and Privacy Policy, and you consent to receive offers and opportunities from Career Karma by telephone, text message, and email.
This tutorial will discuss, with references and examples, the basics of the Java super keyword and how you can use it in your code. By the end of reading this tutorial, you’ll be a master at using the super keyword in Java.
Java Inheritance
In Java, inheritance is used to define a new class from an existing one. Inheritance is a useful feature because it allows coders to reduce the amount of code they have to repeat because they can use existing code to create new classes.
Inheritance is used when there is an is-a
relationship between two classes. Here are a few examples of this type of relationship:
- Meat is a food
- An iPhone is a phone
- A lamp is an item of furniture
- A tire is part of a car
By inheriting code from another method, you can access the attributes, constructors, and methods stored in that function and use those in your new method. Here’s an example of inheritance being used to inherit the code stored in a BankAccount method for use in a new method called SavingsAccount:
class BankAccount { // Methods, attributes, constructors } class SavingsAccount extends BankAccount { // Methods, attributes, constructors }
In this example, we use the extends keyword to inherit all the methods, attributes, and constructors from the BankAccount method and apply them to the new SavingsAccount method. If you’re interested in learning more about Java inheritance, you can read our full guide on the topic here.
» MORE: How to Use Enum in Java
Java Super
The super keyword is used to access superclass members in a subclass. The members of a superclass are constructors, attributes, and methods.
In Java, the superclass, also known as the parent class
, is the class from which a child class [or a subclass] inherits its constructors, methods, and attributes. For instance, in our above example, BankAccount was the superclass from which our subclass SavingsAccount inherited its values.
The super keyword is used in three situations, which we will explore below.
Using Super to Access Superclass Attributes
In Java, attributes in a superclass and subclass can have the same name. If you want to explicitly access the contents of a superclass’ attribute, you have to use the super keyword.
Here’s an example of super being used with reference to our bank account example from above to access a class attribute:
class BankAccount { protected String accountType = "Bank Account"; } class SavingsAccount extends BankAccount { public String accountType = "Savings Account"; public void printAccountDetails[] { System.out.println["Account type: " + accountType]; System.out.println["Parent account type: " + super.accountType]; } } class Main { public static void main[String[] args] { SavingsAccount johnSavings = new SavingsAccount[]; johnSavings.printAccountDetails[]; } }
Our code returns:
Account type: Savings Account Parent account type: Bank Account
In our example, we have declared a superclass called BankAccount which has one attribute: accountType. accountType is equal to Bank Account
in this class.
We have also defined a subclass called SavingsAccount which inherits its values from BankAccount. In this subclass, we declare a variable called accountType which stores the type of account held by that class, which is
class BankAccount { protected String accountType = "Bank Account"; } class SavingsAccount extends BankAccount { public String accountType = "Savings Account"; public void printAccountDetails[] { System.out.println["Account type: " + accountType]; System.out.println["Parent account type: " + super.accountType]; } } class Main { public static void main[String[] args] { SavingsAccount johnSavings = new SavingsAccount[]; johnSavings.printAccountDetails[]; } }0 in this case.
Then we create a method called
class BankAccount { protected String accountType = "Bank Account"; } class SavingsAccount extends BankAccount { public String accountType = "Savings Account"; public void printAccountDetails[] { System.out.println["Account type: " + accountType]; System.out.println["Parent account type: " + super.accountType]; } } class Main { public static void main[String[] args] { SavingsAccount johnSavings = new SavingsAccount[]; johnSavings.printAccountDetails[]; } }1 which, when invoked, prints out the account type of the SavingsAccount, preceded by the label
class BankAccount { protected String accountType = "Bank Account"; } class SavingsAccount extends BankAccount { public String accountType = "Savings Account"; public void printAccountDetails[] { System.out.println["Account type: " + accountType]; System.out.println["Parent account type: " + super.accountType]; } } class Main { public static void main[String[] args] { SavingsAccount johnSavings = new SavingsAccount[]; johnSavings.printAccountDetails[]; } }2. We use the accountType variable to print out the account type of SavingsAccount because the accountType variable has local scope.
» MORE: Exception Handling with Try Catch in Java
After that has been printed,
class BankAccount { protected String accountType = "Bank Account"; } class SavingsAccount extends BankAccount { public String accountType = "Savings Account"; public void printAccountDetails[] { System.out.println["Account type: " + accountType]; System.out.println["Parent account type: " + super.accountType]; } } class Main { public static void main[String[] args] { SavingsAccount johnSavings = new SavingsAccount[]; johnSavings.printAccountDetails[]; } }3 is printed to the console, followed by the accountType of the BankAccount class. We use
class BankAccount { protected String accountType = "Bank Account"; } class SavingsAccount extends BankAccount { public String accountType = "Savings Account"; public void printAccountDetails[] { System.out.println["Account type: " + accountType]; System.out.println["Parent account type: " + super.accountType]; } } class Main { public static void main[String[] args] { SavingsAccount johnSavings = new SavingsAccount[]; johnSavings.printAccountDetails[]; } }4 to reference the value of accountType which is stored in the parent class default constructor.
In our main program, we first create an object of the SavingsAccount method called johnAccount which stores the details for his account. Then we call the method called
class BankAccount { protected String accountType = "Bank Account"; } class SavingsAccount extends BankAccount { public String accountType = "Savings Account"; public void printAccountDetails[] { System.out.println["Account type: " + accountType]; System.out.println["Parent account type: " + super.accountType]; } } class Main { public static void main[String[] args] { SavingsAccount johnSavings = new SavingsAccount[]; johnSavings.printAccountDetails[]; } }1 to retrieve information about John’s account.
Using Super to Access Superclass Method
Methods in a subclass and a superclass can have the same name. If you want to access the method stored in a superclass that has the same name as a subclass method, you have to use the super keyword.
Here’s an example of super being used to access a superclass method, using the example of a program that stores bank account information:
class BankAccount { public void displayAccountType[] { System.out.println["Account type: Bank Account"]; } } class SavingsAccount extends BankAccount { @Override public void displayAccountType[] { System.out.println["Account type: Savings Account"]; } public void displayParentAccountType[] { super.displayAccountType[]; } } class Main { public static void main[String[] args] { SavingsAccount johnSavings = new SavingsAccount[]; johnSavings.displayAccountType[]; johnSavings.displayParentAccountType[]; } }
Our code returns:
Account type: Savings Account Account type: Bank Account
In this example, we have declared a superclass called BankAccount which has one method:
class BankAccount { protected String accountType = "Bank Account"; } class SavingsAccount extends BankAccount { public String accountType = "Savings Account"; public void printAccountDetails[] { System.out.println["Account type: " + accountType]; System.out.println["Parent account type: " + super.accountType]; } } class Main { public static void main[String[] args] { SavingsAccount johnSavings = new SavingsAccount[]; johnSavings.printAccountDetails[]; } }6. When this method is invoked,
class BankAccount { protected String accountType = "Bank Account"; } class SavingsAccount extends BankAccount { public String accountType = "Savings Account"; public void printAccountDetails[] { System.out.println["Account type: " + accountType]; System.out.println["Parent account type: " + super.accountType]; } } class Main { public static void main[String[] args] { SavingsAccount johnSavings = new SavingsAccount[]; johnSavings.printAccountDetails[]; } }7 is printed to the console.
We have also declared a subclass called SavingsAccount which has two methods:
class BankAccount { protected String accountType = "Bank Account"; } class SavingsAccount extends BankAccount { public String accountType = "Savings Account"; public void printAccountDetails[] { System.out.println["Account type: " + accountType]; System.out.println["Parent account type: " + super.accountType]; } } class Main { public static void main[String[] args] { SavingsAccount johnSavings = new SavingsAccount[]; johnSavings.printAccountDetails[]; } }6 and
class BankAccount { protected String accountType = "Bank Account"; } class SavingsAccount extends BankAccount { public String accountType = "Savings Account"; public void printAccountDetails[] { System.out.println["Account type: " + accountType]; System.out.println["Parent account type: " + super.accountType]; } } class Main { public static void main[String[] args] { SavingsAccount johnSavings = new SavingsAccount[]; johnSavings.printAccountDetails[]; } }9.
When
class BankAccount { protected String accountType = "Bank Account"; } class SavingsAccount extends BankAccount { public String accountType = "Savings Account"; public void printAccountDetails[] { System.out.println["Account type: " + accountType]; System.out.println["Parent account type: " + super.accountType]; } } class Main { public static void main[String[] args] { SavingsAccount johnSavings = new SavingsAccount[]; johnSavings.printAccountDetails[]; } }6 is executed,
Account type: Savings Account Parent account type: Bank Account1 is printed to the console. When
class BankAccount { protected String accountType = "Bank Account"; } class SavingsAccount extends BankAccount { public String accountType = "Savings Account"; public void printAccountDetails[] { System.out.println["Account type: " + accountType]; System.out.println["Parent account type: " + super.accountType]; } } class Main { public static void main[String[] args] { SavingsAccount johnSavings = new SavingsAccount[]; johnSavings.printAccountDetails[]; } }9 is executed, we use the super keyword to invoke the
class BankAccount { protected String accountType = "Bank Account"; } class SavingsAccount extends BankAccount { public String accountType = "Savings Account"; public void printAccountDetails[] { System.out.println["Account type: " + accountType]; System.out.println["Parent account type: " + super.accountType]; } } class Main { public static void main[String[] args] { SavingsAccount johnSavings = new SavingsAccount[]; johnSavings.printAccountDetails[]; } }6 method from our parent class. So, instead of executing the
class BankAccount { protected String accountType = "Bank Account"; } class SavingsAccount extends BankAccount { public String accountType = "Savings Account"; public void printAccountDetails[] { System.out.println["Account type: " + accountType]; System.out.println["Parent account type: " + super.accountType]; } } class Main { public static void main[String[] args] { SavingsAccount johnSavings = new SavingsAccount[]; johnSavings.printAccountDetails[]; } }6 method in the SavingsAccount class, our program executes the
class BankAccount { protected String accountType = "Bank Account"; } class SavingsAccount extends BankAccount { public String accountType = "Savings Account"; public void printAccountDetails[] { System.out.println["Account type: " + accountType]; System.out.println["Parent account type: " + super.accountType]; } } class Main { public static void main[String[] args] { SavingsAccount johnSavings = new SavingsAccount[]; johnSavings.printAccountDetails[]; } }6 method in the BankAccount class.
In our main program, we first declare an instance of SavingsAccount called johnSavings. We then invoke the
class BankAccount { protected String accountType = "Bank Account"; } class SavingsAccount extends BankAccount { public String accountType = "Savings Account"; public void printAccountDetails[] { System.out.println["Account type: " + accountType]; System.out.println["Parent account type: " + super.accountType]; } } class Main { public static void main[String[] args] { SavingsAccount johnSavings = new SavingsAccount[]; johnSavings.printAccountDetails[]; } }6 method, which runs
class BankAccount { protected String accountType = "Bank Account"; } class SavingsAccount extends BankAccount { public String accountType = "Savings Account"; public void printAccountDetails[] { System.out.println["Account type: " + accountType]; System.out.println["Parent account type: " + super.accountType]; } } class Main { public static void main[String[] args] { SavingsAccount johnSavings = new SavingsAccount[]; johnSavings.printAccountDetails[]; } }6 from the SavingsAccount method. Finally, we invoke
class BankAccount { protected String accountType = "Bank Account"; } class SavingsAccount extends BankAccount { public String accountType = "Savings Account"; public void printAccountDetails[] { System.out.println["Account type: " + accountType]; System.out.println["Parent account type: " + super.accountType]; } } class Main { public static void main[String[] args] { SavingsAccount johnSavings = new SavingsAccount[]; johnSavings.printAccountDetails[]; } }9 which executes
Account type: Savings Account Parent account type: Bank Account9 and prints
class BankAccount { protected String accountType = "Bank Account"; } class SavingsAccount extends BankAccount { public String accountType = "Savings Account"; public void printAccountDetails[] { System.out.println["Account type: " + accountType]; System.out.println["Parent account type: " + super.accountType]; } } class Main { public static void main[String[] args] { SavingsAccount johnSavings = new SavingsAccount[]; johnSavings.printAccountDetails[]; } }7 to the console.
» MORE: What Is a Java Class?
Using Super to Access Superclass Constructor
The super keyword is also used to access a constructor from a superclass that shares the same name as a constructor in a subclass. You can learn more about Java constructors in our Java constructor tutorial here.
To call a superclass constructor from a subclass constructor, we need to use
class BankAccount { public void displayAccountType[] { System.out.println["Account type: Bank Account"]; } } class SavingsAccount extends BankAccount { @Override public void displayAccountType[] { System.out.println["Account type: Savings Account"]; } public void displayParentAccountType[] { super.displayAccountType[]; } } class Main { public static void main[String[] args] { SavingsAccount johnSavings = new SavingsAccount[]; johnSavings.displayAccountType[]; johnSavings.displayParentAccountType[]; } }1 inside the subclass constructor.
class BankAccount { public void displayAccountType[] { System.out.println["Account type: Bank Account"]; } } class SavingsAccount extends BankAccount { @Override public void displayAccountType[] { System.out.println["Account type: Savings Account"]; } public void displayParentAccountType[] { super.displayAccountType[]; } } class Main { public static void main[String[] args] { SavingsAccount johnSavings = new SavingsAccount[]; johnSavings.displayAccountType[]; johnSavings.displayParentAccountType[]; } }2 must be the first statement in the argument constructor.
"Career Karma entered my life when I needed it most and quickly helped me match with a bootcamp. Two months after graduating, I found my dream job that aligned with my values and goals in life!"
Venus, Software Engineer at Rockbot
Find Your Bootcamp MatchHere’s an example of
class BankAccount { public void displayAccountType[] { System.out.println["Account type: Bank Account"]; } } class SavingsAccount extends BankAccount { @Override public void displayAccountType[] { System.out.println["Account type: Savings Account"]; } public void displayParentAccountType[] { super.displayAccountType[]; } } class Main { public static void main[String[] args] { SavingsAccount johnSavings = new SavingsAccount[]; johnSavings.displayAccountType[]; johnSavings.displayParentAccountType[]; } }1 being used to call a superclass constructor, using our bank account example application:
class BankAccount { BankAccount[] { System.out.println["Parent account type: Bank Account"]; } } class SavingsAccount extends BankAccount { SavingsAccount[] { super[]; System.out.println["Main account type: Savings Account"]; } } class Main { public static void main[String[] args] { SavingsAccount johnAccount = new SavingsAccount[]; } }
Our code returns:
Parent account type: Bank Account Main account type: Savings Account
In this example, we have defined a superclass called BankAccount which includes a constructor. This constructor, when invoked, prints
class BankAccount { public void displayAccountType[] { System.out.println["Account type: Bank Account"]; } } class SavingsAccount extends BankAccount { @Override public void displayAccountType[] { System.out.println["Account type: Savings Account"]; } public void displayParentAccountType[] { super.displayAccountType[]; } } class Main { public static void main[String[] args] { SavingsAccount johnSavings = new SavingsAccount[]; johnSavings.displayAccountType[]; johnSavings.displayParentAccountType[]; } }4 to the console.
We have also defined a subclass called SavingsAccount which includes a constructor. This constructor, when invoked, uses
class BankAccount { public void displayAccountType[] { System.out.println["Account type: Bank Account"]; } } class SavingsAccount extends BankAccount { @Override public void displayAccountType[] { System.out.println["Account type: Savings Account"]; } public void displayParentAccountType[] { super.displayAccountType[]; } } class Main { public static void main[String[] args] { SavingsAccount johnSavings = new SavingsAccount[]; johnSavings.displayAccountType[]; johnSavings.displayParentAccountType[]; } }1 to invoke the BankAccount constructor in the BankAccount class. This prints
class BankAccount { public void displayAccountType[] { System.out.println["Account type: Bank Account"]; } } class SavingsAccount extends BankAccount { @Override public void displayAccountType[] { System.out.println["Account type: Savings Account"]; } public void displayParentAccountType[] { super.displayAccountType[]; } } class Main { public static void main[String[] args] { SavingsAccount johnSavings = new SavingsAccount[]; johnSavings.displayAccountType[]; johnSavings.displayParentAccountType[]; } }4 to the console. Then, the SavingsAccount constructor prints
class BankAccount { public void displayAccountType[] { System.out.println["Account type: Bank Account"]; } } class SavingsAccount extends BankAccount { @Override public void displayAccountType[] { System.out.println["Account type: Savings Account"]; } public void displayParentAccountType[] { super.displayAccountType[]; } } class Main { public static void main[String[] args] { SavingsAccount johnSavings = new SavingsAccount[]; johnSavings.displayAccountType[]; johnSavings.displayParentAccountType[]; } }7 to the console.
In our main program, we initialize an instance of the SavingsAccount object called johnAccount. When we initialize johnAccount, the
class BankAccount { public void displayAccountType[] { System.out.println["Account type: Bank Account"]; } } class SavingsAccount extends BankAccount { @Override public void displayAccountType[] { System.out.println["Account type: Savings Account"]; } public void displayParentAccountType[] { super.displayAccountType[]; } } class Main { public static void main[String[] args] { SavingsAccount johnSavings = new SavingsAccount[]; johnSavings.displayAccountType[]; johnSavings.displayParentAccountType[]; } }8 constructor is executed.
Conclusion
The Java super keyword has three uses. These are to:
- Access superclass attributes
- Access superclass methods
- Access superclass constructors
This tutorial discussed, with reference to examples, how to use the Java superclass keyword for those purposes. Now, after reading this tutorial, you’re ready to start using the Java super keyword like an expert!
1 Ratings
About us: Career Karma is a platform designed to help job seekers find, research, and connect with job training programs to advance their careers. Learn about the CK publication.