IL super La parola chiave in Java è una variabile di riferimento che viene utilizzata per fare riferimento all'oggetto della classe genitore immediata.
Ogni volta che crei l'istanza della sottoclasse, viene creata implicitamente un'istanza della classe genitore a cui fa riferimento la variabile super riferimento.
Utilizzo della super parola chiave Java
- super può essere utilizzato per fare riferimento alla variabile di istanza della classe genitore immediata.
- super può essere utilizzato per invocare il metodo della classe genitore immediata.
- super() può essere utilizzato per invocare il costruttore immediato della classe genitore.
1) super viene utilizzato per fare riferimento alla variabile di istanza della classe genitore immediata.
Possiamo usare la super parola chiave per accedere al membro dati o al campo della classe genitore. Viene utilizzato se la classe genitore e la classe figlia hanno gli stessi campi.
è una relazione
class Animal{ String color='white'; } class Dog extends Animal{ String color='black'; void printColor(){ System.out.println(color);//prints color of Dog class System.out.println(super.color);//prints color of Animal class } } class TestSuper1{ public static void main(String args[]){ Dog d=new Dog(); d.printColor(); }} Provalo adesso Produzione:
black white
Nell'esempio sopra, Animale e Cane, entrambe le classi hanno una proprietà comune, il colore. Se stampiamo la proprietà color, per impostazione predefinita verrà stampato il colore della classe corrente. Per accedere alla proprietà genitore, dobbiamo utilizzare la super parola chiave.
2) super può essere utilizzato per invocare il metodo della classe genitore
La parola chiave super può essere utilizzata anche per invocare il metodo della classe genitore. Dovrebbe essere utilizzato se la sottoclasse contiene lo stesso metodo della classe genitore. In altre parole, viene utilizzato se il metodo viene sovrascritto.
class Animal{ void eat(){System.out.println('eating...');} } class Dog extends Animal{ void eat(){System.out.println('eating bread...');} void bark(){System.out.println('barking...');} void work(){ super.eat(); bark(); } } class TestSuper2{ public static void main(String args[]){ Dog d=new Dog(); d.work(); }} Provalo adesso Produzione:
eating... barking...
Nell'esempio sopra Animale e Cane entrambe le classi hanno il metodo eat() se chiamiamo il metodo eat() dalla classe Dog, chiamerà il metodo eat() della classe Dog per impostazione predefinita perché la priorità è data a local.
Per chiamare il metodo della classe genitore, dobbiamo usare la super parola chiave.
3) super viene utilizzato per invocare il costruttore della classe genitore.
La parola chiave super può essere utilizzata anche per invocare il costruttore della classe genitore. Vediamo un semplice esempio:
class Animal{ Animal(){System.out.println('animal is created');} } class Dog extends Animal{ Dog(){ super(); System.out.println('dog is created'); } } class TestSuper3{ public static void main(String args[]){ Dog d=new Dog(); }} Provalo adesso Produzione:
animal is created dog is created
Nota: super() viene aggiunto automaticamente in ogni costruttore di classe dal compilatore se non c'è super() o this().
Come sappiamo bene, il costruttore predefinito viene fornito automaticamente dal compilatore se non esiste un costruttore. Ma aggiunge anche super() come prima istruzione.
Un altro esempio di parola chiave super in cui super() viene fornito implicitamente dal compilatore.
class Animal{ Animal(){System.out.println('animal is created');} } class Dog extends Animal{ Dog(){ System.out.println('dog is created'); } } class TestSuper4{ public static void main(String args[]){ Dog d=new Dog(); }} Provalo adesso Produzione:
animal is created dog is created
super esempio: uso reale
Vediamo il reale utilizzo della super parola chiave. Qui, la classe Emp eredita la classe Person, quindi tutte le proprietà di Person verranno ereditate da Emp per impostazione predefinita. Per inizializzare tutta la proprietà, stiamo utilizzando il costruttore della classe genitore dalla classe figlio. In questo modo, stiamo riutilizzando il costruttore della classe genitore.
class Person{ int id; String name; Person(int id,String name){ this.id=id; this.name=name; } } class Emp extends Person{ float salary; Emp(int id,String name,float salary){ super(id,name);//reusing parent constructor this.salary=salary; } void display(){System.out.println(id+' '+name+' '+salary);} } class TestSuper5{ public static void main(String[] args){ Emp e1=new Emp(1,'ankit',45000f); e1.display(); }} Provalo adesso Produzione:
1 ankit 45000