Java Language Uso di parole chiave super con esempi


Esempio

la parola chiave super svolge un ruolo importante in tre punti

  1. Livello costruttore
  2. Livello del metodo
  3. Livello variabile

Livello costruttore

super parola chiave super viene utilizzata per chiamare il costruttore della classe genitore. Questo costruttore può essere costruttore predefinito o costruttore parametrizzato.

  • Costruttore predefinito: super();

  • Costruttore parametrizzato: super(int no, double amount, String name);

     class Parentclass
     {
        Parentclass(){
           System.out.println("Constructor of Superclass");
        }
     }
     class Subclass extends Parentclass
     {
        Subclass(){
         /* Compile adds super() here at the first line
          * of this constructor implicitly
          */
         System.out.println("Constructor of Subclass");
        }
        Subclass(int n1){
         /* Compile adds super() here at the first line
          * of this constructor implicitly
          */
         System.out.println("Constructor with arg");
        }
        void display(){
         System.out.println("Hello");
        }
        public static void main(String args[]){
         // Creating object using default constructor
         Subclass obj= new Subclass();
         //Calling sub class method 
            obj.display();
            //Creating object 2 using arg constructor
            Subclass obj2= new Subclass(10);
            obj2.display();
       }
     }
    

Nota : super() deve essere la prima istruzione nel costruttore altrimenti otterremo il messaggio di errore di compilazione.

Livello del metodo

super parola chiave super può anche essere utilizzata in caso di sovrascrittura del metodo. super parola chiave super può essere utilizzata per invocare o chiamare il metodo della classe genitore.

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(); 
   }
}

Nota : se non esiste una modalità di sovrascrittura, non è necessario utilizzare la parola chiave super per chiamare il metodo della classe genitore.

Livello variabile

super è usato per riferirsi alla variabile istanza della classe genitore immediata. In caso di ereditarietà, potrebbe esserci la possibilità che la classe base e la classe derivata possano avere membri di dati simili. Per differenziare tra il membro dati della classe base / genitore e classe derivata / figlia, nel contesto della classe derivata i dati della classe base i membri devono essere preceduti da una super parola chiave.

//Parent class or Superclass
class Parentclass
{
    int num=100;
}
//Child class or subclass
class Subclass extends Parentclass
{
    /* I am declaring the same variable 
     * num in child class too.
     */
    int num=110;
    void printNumber(){
     System.out.println(num); //It will print value 110
     System.out.println(super.num); //It will print value 100
    }
    public static void main(String args[]){
       Subclass obj= new Subclass();
       obj.printNumber();    
    }
}

Nota : se non scriviamo la parola chiave super prima del nome del membro dei dati della classe di base, verrà riferito come membro dei dati della classe corrente e i membri dei dati della classe di base sono nascosti nel contesto della classe derivata.