Java super 关键字

In questo tutorial, impareremo la parola chiave super in Java attraverso esempi.

La parola chiave super in Java viene utilizzata nella sottoclasse per accedere ai membri della superclasse (proprietà, costruttori e metodi).

Prima di studiare la parola chiave super, assicurati di aver capitoEreditarietà Java.

Uso della parola chiave super

1. 　Chiamare il metodo sovrascritto del padre nella sottoclasse.
   

2. Se la superclasse (superclass) e la sottoclasse (subclass) hanno attributi con lo stesso nome, accedere agli attributi della superclasse (campo).

3. Chiamare esplicitamente il costruttore senza parametri o con parametri della superclasse dal costruttore della sottoclasse.

　 Facciamo un passo indietro per comprendere tutti questi utilizzi.

1. Accesso al metodo sovrascritto della superclasse

Se viene definito lo stesso metodo con lo stesso nome sia nella superclasse che nella sottoclasse, il metodo nella sottoclasse sovrascrive il metodo nella superclasse. Questo si chiamaSoverascrittura di metodo.

Esempio 1: Soverascrittura di metodo

class Animal {
　　// Metodo
　　public void display(){
　　　　System.out.println("Io sono un animale");
　　}
}
class Dog extends Animal {
　　// Metodo sovrascritto
　　@Override
　　public void display(){
　　　　System.out.println("Io sono un cane");
　　}
　　public void printMessage(){
　　　　display();
　　}
}
class Main {
　　public static void main(String[] args) {
　　　　Dog dog1 = new Dog();
　　　　dog1.printMessage();
　　}
}

Risultato di output

Io sono un cane

In questo esempio, creando un oggetto della classe Dog chiamato dog1, possiamo chiamare il suo metodo printMessage(), che esegue quindi la语句display().

Poiché display() è definito in entrambe le classi, il metodo della sottoclasse Dog sovrascrive il metodo della superclasse Animal. Pertanto, viene chiamato il metodo display() della sottoclasse.

Cosa fare se si deve chiamare il metodo sovrascritto della superclasse?

Se è necessario chiamare il metodo sovraccaricato display() della superclasse Animal, utilizzare super.display().

Esempio 2: Chiamata del metodo della superclasse super

class Animal {
　　// Metodo
　　public void display(){
　　　　System.out.println("Io sono un animale");
　　}
}
class Dog extends Animal {
　　// Metodo sovrascritto
　　@Override
　　public void display(){
　　　　System.out.println("Io sono un cane");
　　}
　　public void printMessage(){
　　　　// Questa chiamata chiama il metodo sovrascritto
　　　　display();
　　　　// Questa chiamata chiama il metodo della superclasse
　　　　super.display();
　　}
}
class Main {
　　public static void main(String[] args) {
　　　　Dog dog1 = new Dog();
　　　　dog1.printMessage();
　　}
}

Risultato di output

Io sono un cane
Io sono un animale

Ecco come funziona il programma menzionato sopra.

2. Accesso agli attributi del super(-padre)

La superclasse e la sottoclasse possono avere attributi con lo stesso nome. Utilizziamo la parola chiave super per accedere agli attributi della superclasse.

Esempio 3: Accesso agli attributi della superclasse

class Animal {
　　protected String type="Animale";
}
class Dog extends Animal {
　　public String type="Mammifero";
　　public void printType() {
　　　　System.out.println("Sono " + type);
　　　　System.out.println("Sono un " + super.type);
　　}
}
class Main {
　　public static void main(String[] args) {
　　　　Dog dog1 = new Dog();
　　　　dog1.printType();
　　}
}

Output:

Sono un mammifero
Sono un animale

In questo esempio, abbiamo definito lo stesso tipo di campo di istanza sia nella superclasse Animal che nella sottoclasse Dog.
poi abbiamo creato l'oggetto dog1 della classe Dog. Poi, abbiamo chiamato il metodo printType() utilizzando questo oggetto.

All'interno della funzione printType(),

• type - Indica l'attributo della sottoclasse Dog.

• super.type - Indica l'attributo della superclasse Animal.

Pertanto, System.out.println("Sono " + type);Output "Sono un mammifero"e, System.out.println("Sono un " + super.type); viene stampatoOutput "Sono un animale".

3. Utilizzo di super() per accedere al costruttore della superclasse

Noto a tutti, quando si crea un oggetto di una classe, viene automaticamente chiamato il suo costruttore di default.

Per chiamare esplicitamente il costruttore della superclasse dal costruttore della sottoclasse, utilizziamo super(). Questo è un'uso speciale della parola chiave super.

Attenzione: super() può essere utilizzato solo nel costruttore della sottoclasse e deve essere la prima istruzione.

Esempio 4: utilizzo di super()

class Animal {
　　//Costruttore di default o senza parametri della classe Animal
　　Animal() {
　　　　System.out.println("Io sono un animale");
　　}
}
class Dog extends Animal {
　　//Costruttore di default o senza parametri della classe Dog
　　Dog() {
　　　　//Chiamata al costruttore di default della superclasse
　　　　super();
　　　　System.out.println("Io sono un cane");
　　}
}
class Main {
　　public static void main(String[] args) {
　　　　Dog dog1 = new Dog();
　　}
}

Risultato di output

Io sono un animale
Io sono un cane

Quindi, quando viene creato l'oggetto dog1 della classe Dog, viene automaticamente chiamato il costruttore di default o senza parametri di questa classe.
Nel costruttore della sottoclasse, la frase super() chiama il costruttore della superclasse e esegue le istruzioni al suo interno. Pertanto, otteniamo il risultato"Io sono un animale".

Poi, il flusso del programma torna al costruttore della sottoclasse e esegue il resto delle istruzioni. Pertanto, viene stampato "Io sono un cane".

Ma non è necessario utilizzare super(). Anche se non viene utilizzato super() nel costruttore della sottoclasse, il compilatore chiama implicitamente il costruttore di default della superclasse.

Allora, se il compilatore chiama automaticamente super(), perché utilizzarlo esplicitamente e generare codice ridondante?

Se è necessario chiamare il costruttore della superclasse dal costruttore della sottoclasseCostruttore parametrizzato (costruttore con parametri)quindi deve essere utilizzato esplicitamente.

un super() con parametrideve sempre essereil corpo del costruttore della sottoclassecontieneLa prima istruzionealtrimenti, verrà generato un errore di compilazione.

Esempio 5: chiamata al costruttore parametrizzato tramite super()

class Animal {
　　//默认或无参数的构造函数
　　Animal() {
　　　　System.out.println("Io sono un animale");
　　}
　　//参数化构造函数
　　Animal(String type) {
　　　　System.out.println("Tipo: " + type);}
　　}
}
class Dog extends Animal {
　　//Costruttore di default
　　Dog() {
　　　　//Chiamata al costruttore parametrizzato della superclasse
　　　　super("Animal");
　　　　System.out.println("Io sono un cane");
　　}
}
class Main {
　　public static void main(String[] args) {
　　　　Dog dog1 = new Dog();
　　}
}

Risultato di output

Tipo: Animal
Io sono un cane

Il compilatore può chiamare automaticamente il costruttore senza parametri. Ma non può chiamare il costruttore con parametri.

Se è necessario chiamare il costruttore parametrizzato, deve essere definito esplicitamente nel costruttore della sottoclasse, come nella seguente istruzione di codice:

super("Animal");

Attenzione, nell'esempio sopra, abbiamo utilizzato super("Animal") per chiamare esplicitamente il costruttore parametrizzato. In questo caso, il compilatore non chiama il costruttore di default della superclasse.