Super Java
Super Java
Dans ce didacticiel, nous allons découvrir le super mot-clé en Java à l'aide d'exemples.
Le super Le mot clé en Java est utilisé dans les sous-classes pour accéder aux membres de la superclasse (attributs, constructeurs et méthodes).
Avant d'en savoir plus sur le super mot-clé, assurez-vous de connaître l'héritage Java.
Utilisations du super mot-clé
- Pour appeler les méthodes de la superclasse qui est remplacée dans la sous-classe.
- Pour accéder aux attributs (champs) de la superclasse si la superclasse et la sous-classe ont des attributs portant le même nom.
- Pour appeler explicitement la superclasse no-arg (par défaut) ou le constructeur paramétré à partir du constructeur de la sous-classe.
Comprenons chacune de ces utilisations.
1. Accéder aux méthodes surchargées de la superclasse
Si des méthodes portant le même nom sont définies à la fois dans la superclasse et dans la sous-classe, la méthode de la sous-classe remplace la méthode de la superclasse. C'est ce qu'on appelle le remplacement de méthode.
Exemple 1 :remplacement de méthode
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();
}
}
Sortie
I am a dog
Dans cet exemple, en créant un objet dog1 de chien classe, nous pouvons appeler sa méthode printMessage() qui exécute alors le display() déclaration.
Depuis display() est défini dans les deux classes, la méthode de la sous-classe Dog remplace la méthode de la superclasse Animal . D'où le display() de la sous-classe est appelée.
Et si la méthode surchargée de la superclasse doit être appelée ?
Nous utilisons super.display() si la méthode surchargée display() de la superclasse Animal doit être appelé.
Exemple 2 :super pour appeler la méthode de la superclasse
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();
}
}
Sortie
I am a dog I am an animal
Ici, comment fonctionne le programme ci-dessus.
2. Accéder aux attributs de la superclasse
La superclasse et la sous-classe peuvent avoir des attributs portant le même nom. Nous utilisons le super mot clé pour accéder à l'attribut de la superclasse.
Exemple 3 :Accéder à l'attribut de la superclasse
class Animal {
protected String type="animal";
}
class Dog extends Animal {
public String type="mammal";
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();
}
}
Sortie :
I am a mammal I am an animal
Dans cet exemple, nous avons défini le même champ d'instance type à la fois dans la superclasse Animal et la sous-classe Chien .
Nous avons ensuite créé un objet dog1 du Chien classer. Ensuite, le printType() méthode est appelée à l'aide de cet objet.
À l'intérieur du printType() fonction,
- typer fait référence à l'attribut de la sous-classe Chien .
- super.type fait référence à l'attribut de la superclasse Animal.
Par conséquent, System.out.println("I am a " + type); imprime
Je suis un mammifère
. Et, System.out.println("I am an " + super.type); imprime
Je suis un animal
.
3. Utilisation de super() pour accéder au constructeur de la superclasse
Comme nous le savons, lorsqu'un objet d'une classe est créé, son constructeur par défaut est automatiquement appelé.
Pour appeler explicitement le constructeur de la superclasse à partir du constructeur de la sous-classe, nous utilisons super() . C'est une forme spéciale du super mot-clé.
super() ne peut être utilisé qu'à l'intérieur du constructeur de la sous-classe et doit être la première instruction.
Exemple 4 :Utilisation de 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();
}
}
Sortie
I am an animal I am a dog
Ici, lorsqu'un objet dog1 de chien est créée, elle appelle automatiquement le constructeur par défaut ou sans argument de cette classe.
Dans le constructeur de la sous-classe, le super() L'instruction appelle le constructeur de la superclasse et exécute les instructions qu'elle contient. Par conséquent, nous obtenons la sortie
Je suis un animal
.
Le déroulement du programme revient ensuite au constructeur de la sous-classe et exécute les instructions restantes. Ainsi, je suis un chien sera imprimé.
Cependant, en utilisant super() n'est pas obligatoire. Même si super() n'est pas utilisé dans le constructeur de la sous-classe, le compilateur appelle implicitement le constructeur par défaut de la superclasse.
Alors, pourquoi utiliser du code redondant si le compilateur invoque automatiquement super() ?
Il est obligatoire si le constructeur paramétré (un constructeur qui prend des arguments) de la superclasse doit être appelée depuis le constructeur de la sous-classe.
Le super() paramétré doit toujours être la première instruction dans le corps du constructeur de la sous-classe, sinon, nous obtenons une erreur de compilation.
Exemple 5 :appel d'un constructeur paramétré à l'aide de 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();
}
}
Sortie
Type: Animal I am a dog
Le compilateur peut appeler automatiquement le constructeur no-arg. Cependant, il ne peut pas appeler de constructeurs paramétrés.
Si un constructeur paramétré doit être appelé, nous devons le définir explicitement dans le constructeur de la sous-classe.
Notez que dans l'exemple ci-dessus, nous avons explicitement appelé le constructeur paramétré super("Animal") . Le compilateur n'appelle pas le constructeur par défaut de la superclasse dans ce cas.
Java