In questo tutorial, impareremo la parola chiave super in Java con l'aiuto di esempi.
La superparola chiave in Java viene utilizzata nelle sottoclassi per accedere ai membri della superclasse (attributi, costruttori e metodi).
Prima di conoscere la superparola chiave, assicurati di conoscere l'ereditarietà di Java.
Usi di super parola chiave
- Per chiamare i metodi della superclasse che viene sovrascritta nella sottoclasse.
- Per accedere agli attributi (campi) della superclasse se sia la superclasse che la sottoclasse hanno attributi con lo stesso nome.
- Per chiamare esplicitamente il costruttore della superclasse no-arg (predefinito) o parametrizzato dal costruttore della sottoclasse.
Comprendiamo ciascuno di questi usi.
1. Accesso ai metodi sostituiti della superclasse
Se metodi con lo stesso nome sono definiti sia nella superclasse che nella sottoclasse, il metodo nella sottoclasse sostituisce il metodo nella superclasse. Questo è chiamato override del metodo.
Esempio 1: sostituzione del metodo
class Animal ( // overridden method public void display()( System.out.println("I am an animal"); ) ) class Dog extends Animal ( // overriding method @Override public void display()( System.out.println("I am a dog"); ) public void printMessage()( display(); ) ) class Main ( public static void main(String() args) ( Dog dog1 = new Dog(); dog1.printMessage(); ) )
Produzione
io sono un cane
In questo esempio, creando un oggetto dog1 della classe Dog, possiamo chiamare il suo metodo printMessage () che quindi esegue l' display()istruzione.
Poiché display()è definito in entrambe le classi, il metodo della sottoclasse Dog prevale sul metodo della superclasse Animal. Quindi, display()viene chiamato il della sottoclasse.
Cosa succede se il metodo sovrascritto della superclasse deve essere chiamato?
Usiamo super.display()se il metodo sovrascritto display()della superclasse Animal deve essere chiamato.
Esempio 2: super to Call Superclass Method
class Animal ( // overridden method public void display()( System.out.println("I am an animal"); ) ) class Dog extends Animal ( // overriding method @Override public void display()( System.out.println("I am a dog"); ) public void printMessage()( // this calls overriding method display(); // this calls overridden method super.display(); ) ) class Main ( public static void main(String() args) ( Dog dog1 = new Dog(); dog1.printMessage(); ) )
Produzione
Sono un cane, sono un animale
Ecco come funziona il programma di cui sopra.
2. Attributi di accesso della Superclass
La superclasse e la sottoclasse possono avere attributi con lo stesso nome. Usiamo la superparola chiave per accedere all'attributo della superclasse.
Esempio 3: accesso all'attributo superclasse
class Animal ( protected String; ) class Dog extends Animal ( public String; public void printType() ( System.out.println("I am a " + type); System.out.println("I am an " + super.type); ) ) class Main ( public static void main(String() args) ( Dog dog1 = new Dog(); dog1.printType(); ) )
Uscita :
Sono un mammifero, sono un animale
In questo esempio, abbiamo definito lo stesso tipo di campo istanza sia nella superclasse Animal che nella sottoclasse Dog.
Abbiamo quindi creato un oggetto dog1 della classe Dog. Quindi, il printType()metodo viene chiamato utilizzando questo oggetto.
All'interno della printType()funzione,
- tipo si riferisce all'attributo della sottoclasse Dog.
- super.type si riferisce all'attributo della superclasse Animal.
Quindi, System.out.println("I am a " + type);impronte sono un mammifero. E le System.out.println("I am an " + super.type);stampe sono un animale.
3. Uso di super () per accedere al costruttore della superclasse
Come sappiamo, quando viene creato un oggetto di una classe, il suo costruttore predefinito viene chiamato automaticamente.
Per chiamare esplicitamente il costruttore della superclasse dal costruttore della sottoclasse, usiamo super(). È una forma speciale della superparola chiave.
super() può essere utilizzato solo all'interno del costruttore della sottoclasse e deve essere la prima istruzione.
Esempio 4: utilizzo di super ()
class Animal ( // default or no-arg constructor of class Animal Animal() ( System.out.println("I am an animal"); ) ) class Dog extends Animal ( // default or no-arg constructor of class Dog Dog() ( // calling default constructor of the superclass super(); System.out.println("I am a dog"); ) ) class Main ( public static void main(String() args) ( Dog dog1 = new Dog(); ) )
Produzione
Sono un animale, sono un cane
Qui, quando viene creato un oggetto dog1 della classe Dog, chiama automaticamente il costruttore predefinito o no-arg di quella classe.
All'interno del costruttore della sottoclasse, l' super()istruzione chiama il costruttore della superclasse ed esegue le istruzioni al suo interno. Quindi, otteniamo l'output che sono un animale.
Il flusso del programma ritorna quindi al costruttore della sottoclasse ed esegue le istruzioni rimanenti. Quindi, io sono un cane verrà stampato.
Tuttavia, l'utilizzo super()non è obbligatorio. Anche se super()non viene utilizzato nel costruttore della sottoclasse, il compilatore chiama implicitamente il costruttore predefinito della superclasse.
Allora, perché usare codice ridondante se il compilatore invoca automaticamente super ()?
È richiesto se il costruttore parametrizzato (un costruttore che accetta argomenti) della superclasse deve essere chiamato dal costruttore della sottoclasse.
Il parametrizzato super()deve essere sempre la prima istruzione nel corpo del costruttore della sottoclasse, altrimenti si ottiene un errore di compilazione.
Esempio 5: chiamare il costruttore parametrizzato usando super ()
class Animal ( // default or no-arg constructor Animal() ( System.out.println("I am an animal"); ) // parameterized constructor Animal(String type) ( System.out.println("Type: "+type); ) ) class Dog extends Animal ( // default constructor Dog() ( // calling parameterized constructor of the superclass super("Animal"); System.out.println("I am a dog"); ) ) class Main ( public static void main(String() args) ( Dog dog1 = new Dog(); ) )
Produzione
Tipo: Animale Sono un cane
Il compilatore può chiamare automaticamente il costruttore no-arg. Tuttavia, non può chiamare costruttori parametrizzati.
Se un costruttore parametrizzato deve essere chiamato, dobbiamo definirlo esplicitamente nel costruttore della sottoclasse.
Si noti che nell'esempio precedente abbiamo chiamato esplicitamente il costruttore parametrizzato super("Animal"). In questo caso, il compilatore non chiama il costruttore predefinito della superclasse.
