 |
| Super Keyword In Java With Examples |
What is Super keyword in Java? | Super keyword with example in java
In java, Super keyword is used to refer parent class object.
You are already familiar with inheritance in java. So super keyword is used when we extends any class and want to refer parent's class variable, method or constructor.
You can use super keyword with following condition :-
- Variables - refer parent class instant variable
- Methods - refer parent class methods
- Constructors - refer parent class constructors
So lets discuss each of one by one with example.
1. Super keyword with parent class instant variable
You can only refer instant variable directly using super keyword in java.
When you extends any class and want to use parent class instant variable then super keyword is used.
Syntax :-
super.parentClassInstantVariable
So lets see example for better understanding.
Example 1:- Call parent variable with super keyword
public class SuperClass {
String instanceVariable = "Super class";
}
public class SubClass extends SuperClass{
String instanceVariable = "Sub class";
public void print() {
System.out.println(instanceVariable);
System.out.println(super.instanceVariable);
}
public static void main(String[] args) {
SubClass obj = new SubClass();
obj.print();
}
}
Output :-
Sub class
Super class
You can see in above example first we print sub class instant variable and after call parent class instant variable using super keyword.
2. Super keyword with parent class method
You can refer parent class or base class method in child class using super keyword.
When you override any method and want to call parent class method then super keyword is so useful for calling parent class method.
Lets see example so you can easily understand.
Example 2 :- Without super keyword
public class SuperClass {
public void print() {
System.out.println("Inside super class");
}
}
public class SubClass extends SuperClass{
public void print() {
System.out.println("Inside sub class");
}
public static void main(String[] args) {
SubClass obj = new SubClass();
obj.print();
}
}
Output :-
Inside sub class
Example 3 :- With super keyword
public class SuperClass {
public void print() {
System.out.println("Inside super class");
}
}
public class SubClass extends SuperClass{
public void print() {
System.out.println("Inside sub class");
super.print();
}
public static void main(String[] args) {
SubClass obj = new SubClass();
obj.print();
}
}
Output :-
Inside sub class
Inside super class
Example 4 :- Call parameterized method with super keyword
public class SuperClass {
public void print(String str) {
System.out.println("Inside super class " + str);
}
}
public class SubClass extends SuperClass{
public void print(String str) {
System.out.println("Inside sub class " + str);
super.print(str);
}
public static void main(String[] args) {
SubClass obj = new SubClass();
obj.print("Method");
}
}
Output :-
Inside sub class Method
Inside super class Method
So you can see we can call parent class method that is override by child using super keyword.
So now one question is popup in minds.
What about if method is not overriding in child class?
So we can call directly not overrided method. means if parent class have method and child class does not have same method then we can call directly in child class.
Example 5 :- Calling parent class method that is non overrided
public class SuperClass {
public void printSuperClass() {
System.out.println("Inside super class");
}
}
public class SubClass extends SuperClass{
public void printSubClass() {
System.out.println("Inside sub class");
printSuperClass();
}
public static void main(String[] args) {
SubClass obj = new SubClass();
obj.printSubClass();
}
}
Output :-
Inside sub class
Inside super class
3. Super keyword with constructor
We can call parent class constructor with super keyword.
Using super keyword we can call both parameterized and non parameterized constructor.
If we create of child class then java compiler automatically call super class constructor and then child class constructor. means java compiler automatically add super keyword itself.
So lets see example of both.
Example 6 :- Super keyword with non parameterized constructor
public class SuperClass {
public SuperClass() {
System.out.println("Inside super class constructor");
}
}
public class SubClass extends SuperClass{
public SubClass() {
System.out.println("Inside sub class constructor");
}
public static void main(String[] args) {
SubClass obj = new SubClass();
}
}
Output :-
Inside super class constructor
Inside sub class constructor
You can see we does not add super keyword in sub class constructor's. but parent class constructor automatically call.
Example 7 :- Super keyword with non parameterized constructor
public class SuperClass {
public SuperClass() {
System.out.println("Inside super class constructor");
}
public SuperClass(String str) {
System.out.println("Inside super class parameterized "+ str);
}
}
public class SubClass extends SuperClass{
public SubClass() {
System.out.println("Inside sub class constructor");
}
public SubClass(String str) {
super(str);
System.out.println("Inside sub class parameterized " +str);
}
public static void main(String[] args) {
SubClass obj = new SubClass();
SubClass obj1 = new SubClass("Constructor");
}
}
Output :-
Inside super class constructor
Inside sub class constructor
Inside super class parameterized Constructor
Inside sub class parameterized Constructor
- Double Brace Initialization in Java
- BiFunction in Java
- Lambda Expression in Java
- Functional Interface in Java
- Abstraction in Java
- Static in Java (Static class, Method, Variable and Block)
- Final keyword in java
- Difference between Final, Finally and Finalize in Java
Comments
Post a Comment