Super Keyword in Java

Super keyword parent class के objects को refer करता है। Super keyword के बारे जानने से पहले आपको java में inheritance का ज्ञान होना चाहिए ताकि आप इस गाइड में दिए गए उदाहरणों को समझ सकें।

Java में Super keyword

Super keyword parent class के objects को refer करता है। Super keyword के बारे जानने से पहले आपको java में inheritance का ज्ञान होना चाहिए ताकि आप इस गाइड में दिए गए उदाहरणों को समझ सकें।

Super keyword का उपयोग (Use of Super Keyword)

  1. जब parent class और child class दोनों के पास एक ही नाम के members होते हैं तब parent class के data members को access किया जा सकता है|
  2. Parent class के no-args और parameterized constructor को explicitly call किया जा सकता है|
  3. Parent class की method का उपयोग करने के लिए जब child class ने उस method को override किया हो तब Super keyword का उपयोग किया जाता है|

Parent class के variable को access करने के लिए super keyword का उपयोग कैसे करें?

जब आपके पास child class में एक variable होता है जो पहले से ही parent class में मौजूद होता है तो parent class के variable को access करने के लिए आपको super keyword का इस्तेमाल करना होगा।

इसे समझने के लिए एक उदाहरण लेते हैं:

निम्नलिखित program में, हमने child class में एक data member num को declare किया है, उसी नाम वाला data member num parent class में पहले से मौजूद है। super keyword का उपयोग किए बिना कोई भी तरीका नहीं है जिससे आप parent class के num variable को access कर सकते हैं ।

//Parent class or Superclass or base class
class Superclass
{
int num = 100;
}
//Child class or subclass or derived class
class Subclass extends Superclass
{
/* The same variable num is declared in the Subclass
* which is already present in the Superclass
*/
int num = 110;
void printNumber(){
System.out.println(num);
}
public static void main(String args[]){
Subclass obj= new Subclass();
obj.printNumber();
}
}

परिणाम (Output) :
110


Parent class के num variable को access करना

निम्न तरह से variable को call करके हम parent class के variable को access कर सकते हैं यदि दोनों classes (parent और child class ) में एक ही variable हो ।
super.variable_name

चलिए वही उदाहरण लेते हैं जो हमने ऊपर देखा लेकिन इस print statement में हम num के बजाय super.num पास कर रहे हैं ।
class Superclass
{
int num = 100;
}
class Subclass extends Superclass
{
int num = 110;
void printNumber(){
/* Note that instead of writing num we are
* writing super.num in the print statement
* this refers to the num variable of Superclass
*/
System.out.println(super.num);
}
public static void main(String args[]){
Subclass obj= new Subclass();
obj.printNumber();
}
}

परिणाम (Output) :
100

उपर्युक्त program में आप देख सकते है कि super.num का उपयोग करके आप parent class के num variable को access कर सकते है|

Parent class के constructor को call करने के लिए super keyword का उपयोग

जब हम sub class का object बनाते हैं, तो new keyword child class के constructor को invoke करता है, जो कि parent class के constructor को implement करता है। इसलिए जब हम child class का object बनाते हैं तो parent class का constructor को पहले निष्पादित (execute) किया जाता है और फिर child class constructor को निष्पादित (execute) किया जाता है। ऐसा इसलिए होता है क्योंकि कंपाइलर ही सुपर () को चाइल्ड क्लास के कंस्ट्रक्टर में पहले स्टेटमेंट के रूप में जोड़ता है। (यह parent class के no-args constructor को call करता है)

आइए एक उदाहरण देखें कि ऊपर क्या समझाया गया है :


class Parentclass
{
Parentclass(){
System.out.println(“Constructor of parent class”);
}
}
class Subclass extends Parentclass
{
Subclass(){
/* Compile implicitly adds super() here as the
* first statement of this constructor.
*/
System.out.println(“Constructor of child class”);
}
Subclass(int num){
/* Even though it is a parameterized constructor.
* The compiler still adds the no-arg super() here
*/
System.out.println(“arg constructor of child class”);
}
void display(){
System.out.println(“Hello!”);
}
public static void main(String args[]){
/* Creating object using default constructor. This
* will invoke child class constructor, which will
* invoke parent class constructor
*/
Subclass obj= new Subclass();
//Calling sub class method
obj.display();
/* Creating second object using arg constructor
* it will invoke arg constructor of child class which will
* invoke no-arg constructor of parent class automatically
*/
Subclass obj2= new Subclass(10);
obj2.display();
}
}

परिणाम (Output)
Constructor of parent class
Constructor of child class
Hello!
Constructor of parent class
arg constructor of child class
Hello!

Parameterized super() parent class के parameterized constructor को invoke करने के लिए call करता है

हम super() को स्पष्ट रूप से child class के constructor के रूप में call कर सकते हैं, लेकिन इसका कोई मतलब नहीं होगा क्योंकि यह redundant होगा।
हालाँकि जब हमारे पास parent class में एक constructor होता है जो argument लेता है तो हम super(100) की तरह parameter वाले super का उपयोग कर सकते हैं|
child class के constructor से parent class के parameterized constructor को invoke करना।
आइए इसे समझने के लिए एक उदाहरण देखें:

class Parentclass
{
//no-arg constructor
Parentclass(){
System.out.println(“no-arg constructor of parent class”);
}
//arg or parameterized constructor
Parentclass(String str){
System.out.println(“parameterized constructor of parent class”);
}
}
class Subclass extends Parentclass
{
Subclass(){
/* super() must be added to the first statement of constructor
* otherwise you will get a compilation error. Another important
* point to note is that when we explicitly use super in constructor
* the compiler doesn’t invoke the parent constructor automatically.
*/
super(“Hahaha”);
System.out.println(“Constructor of child class”);

}
void display(){
System.out.println(“Hello”);
}
public static void main(String args[]){
Subclass obj= new Subclass();
obj.display();
}
}
परिणाम (Output) :
parameterized constructor of parent class
Constructor of child class
Hello

इस उदाहरण में ध्यान देने योग्य कुछ महत्वपूर्ण बिंदु हैं:

  1. super() या parameterized super constructor में पहला statement होना चाहिए अन्यथा आपको compilation error – ” Constructor call must be the first statement in a constructor ” मिलेगी|
  2. जब हमने स्पष्ट रूप से (explicitly ) constructor में super रखा है, तो java compiler, parent class के default और no-args constructors को call नहीं करता है ।

Method overridding के case में super keyword का कैसे उपयोग करे?

जब एक child class वही method declare करता है जो पहले से ही parent class में मौजूद होती है तो इसे method overridding कहा जाता है। हम इस श्रृंखला के अगले tutorial में overridding का तरीका सीखेंगे।
Super keyword का उपयोग करके super.method_name के द्वारा आप parent class की method (जिस method को override किया जाता है) को call कर सकते हैं।

method overriding के case में इन शब्दावली का उपयोग किया जाता है:

overridden method : parent class की method|
overriding method : child class की method|

इस अवधारणा को समझने के लिए एक उदाहरण लेते है:

class Parentclass
{
//Overridden method
void display(){
System.out.println(“Parent class method”);
}
}
class Subclass extends Parentclass
{
//Overriding method
void display(){
System.out.println(“Child class method”);
}
void printMsg(){
//This would call Overriding method
display();
//This would call Overridden method
super.display();
}
public static void main(String args[]){
Subclass obj= new Subclass();
obj.printMsg();
}
}

परिणाम (Output)
Child class method
Parent class method

जब child class parent class की किसी भी method को override नहीं करती है तब हमे parent class की method को call करने के लिए super keyword की आवश्यकता नहीं होती, ऐसा इसलिए होता है क्योकि इस मामले में हमारे पास प्रत्येक method का केवल एक संस्करण(version) होता है और child class parent class की method को access कर सकता है, इसलिए हम super का उपयोग किए बिना सीधे parent class की method को call कर सकते हैं।

class Parentclass
{
void display(){
System.out.println(“Parent class method”);
}
}
class Subclass extends Parentclass
{
void printMsg(){
/* This would call method of parent class,
* no need to use super keyword because no other
* method with the same name is present in this class
*/
display();
}
public static void main(String args[]){

Subclass obj= new Subclass();
obj.printMsg();
}
}

परिणाम (Output)

Parent class method

error: Content is protected !!