super () en Java

222

Est super()utilisé pour appeler le constructeur parent? Veuillez expliquer super().

Mohan
la source
1
Doit être plus précis ou simplement lire la documentation ...
Manu
Dans le cadre d'un appel super (), vérifiez également cette réponse. stackoverflow.com/questions/34349164/…
Vishrant
Expliqué ici: Java: Calling super ()
aioobe

Réponses:

267

super() appelle le constructeur parent sans arguments.

Il peut également être utilisé avec des arguments. C'est à dire super(argument1)et il appellera le constructeur qui accepte 1 paramètre du type de argument1(s'il existe).

Il peut également être utilisé pour appeler des méthodes à partir du parent. C'est à diresuper.aMethod()

Plus d'informations et tutoriel ici

pakore
la source
9
REMARQUE: dans le premier cas, la classe parent doit avoir un constructeur sans argument qui échouera et qui générera une erreur de compilation.
KNU
Nit: La terminologie parent / enfant n'est pas très bonne pour les hiérarchies de classes. (Un enfant n'est pas un père.)
aioobe
Existe-t-il des restrictions sur les endroits où Super peut être utilisé?
Aaron Franke
2
@VivekChavda, bien sûr, un enfant peut être un parent, tout comme un étudiant peut être un enseignant, etc. Mais je pense que vous comprenez la différence par rapport à Animal -> Dog par exemple. Un chien est nécessairement un animal. Le parent / enfant est généralement a une relation («Un parent a un enfant») tandis qu'un animal / chien est une relation «est une» . Voir aioo.be/2016/06/29/a-child-is-not-always-a-parent.html
aioobe
2
@AaronFranke, "Existe-t-il des restrictions sur l'endroit où Super peut être utilisé?" - Oui, super(...)ne peut être utilisé que comme première instruction dans un constructeur.
aioobe
154

Quelques faits:

  1. super() est utilisé pour appeler le parent immédiat.
  2. super() peut être utilisé avec des membres d'instance, c'est-à-dire des variables d'instance et des méthodes d'instance.
  3. super() peut être utilisé dans un constructeur pour appeler le constructeur de la classe parente.

OK, maintenant implémentons pratiquement ces points de super().

Découvrez la différence entre le programme 1 et 2. Ici, le programme 2 vérifie notre première déclaration super()en Java.

Programme 1

class Base
{
    int a = 100;
}

class Sup1 extends Base
{
    int a = 200;
    void Show()
    {
        System.out.println(a);
        System.out.println(a);
    }
    public static void main(String[] args)
    {
        new Sup1().Show();
    }
}

Production:

200
200

Maintenant, consultez le programme 2 et essayez de comprendre la principale différence.

Programme 2

class Base
{
    int a = 100;
}

class Sup2 extends Base
{
    int a = 200;
    void Show()
    {
        System.out.println(super.a);
        System.out.println(a);
    }
    public static void main(String[] args)
    {
        new Sup2().Show();
    }
}

Production:

100
200

Dans le programme 1, la sortie était uniquement de la classe dérivée. Il n'a pas pu imprimer la variable ni de la classe de base ni de la classe parente. Mais dans le programme 2, nous avons utilisé super()avec variable alors de l'impression de sa sortie, et au lieu d'imprimer la valeur de variable ade la classe dérivée, il a imprimé la valeur de variable ade la classe de base. Cela prouve donc que l' super()on utilise pour appeler le parent immédiat.

OK, vérifiez maintenant la différence entre le programme 3 et le programme 4.

Programme 3

class Base
{
    int a = 100;
    void Show()
    {
        System.out.println(a);
    }
}

class Sup3 extends Base
{
    int a = 200;
    void Show()
    {
        System.out.println(a);
    }
    public static void Main(String[] args)
    {
        new Sup3().Show();
    }
}

Production:

200

Ici, la sortie est 200. Lorsque nous avons appelé Show(), la Show()fonction de la classe dérivée a été appelée. Mais que devons-nous faire si nous voulons appeler la Show()fonction de la classe parente? Consultez le programme 4 pour la solution.

Programme 4

class Base
{
    int a = 100;
    void Show()
    {
        System.out.println(a);
    }
}

class Sup4 extends Base
{
    int a = 200;
    void Show()
    {
        super.Show();
        System.out.println(a);
    }
    public static void Main(String[] args)
    {
        new Sup4().Show();
    }
}

Production:

100
200

Ici, nous obtenons deux sorties, 100 et 200. Lorsque la Show()fonction de la classe dérivée est invoquée, elle appelle d'abord la Show()fonction de la classe parente, car à l'intérieur de la Show()fonction de la classe dérivée, nous avons appelé la Show()fonction de la classe parente en mettant le supermot - clé avant le nom de la fonction.

SimonGates
la source
4
Pourquoi n'avez-vous pas mis en retrait vos exemples de code source? Y a-t-il une raison précise?
erikbwork
NON erikb, je veux connaître l'utilisation de super (). Ci-après seulement je vais
Mohan
Dans ma classe de base, je surcharge le constructeur avec un, deux, ... arguments
Mohan
mais dans ma classe dérivée, j'utilise super () sans aucun argument. alors que se passera-t-il s'il appelle automatiquement un constructeur par défaut d'une classe de base
Mohan
2
super()n'est pas un mot-clé. Il s'agit d'une invocation de constructeur. superest un mot-clé, et # 1 et # 2 n'ont de sens qu'avec cette définition.
Marquis de Lorne
37

Article d'origine: Java: Calling super ()


Oui. super(...)invoquera le constructeur de la super-classe.

Illustration:

entrez la description de l'image ici


Exemple autonome:

class Animal {
    public Animal(String arg) {
        System.out.println("Constructing an animal: " + arg);
    }
}

class Dog extends Animal {
    public Dog() {
        super("From Dog constructor");
        System.out.println("Constructing a dog.");
    }
}

public class Test {
    public static void main(String[] a) {
        new Dog();
    }
}

Tirages:

Constructing an animal: From Dog constructor
Constructing a dog.
aioobe
la source
Dans ma classe de base, je surcharge le constructeur avec un, deux, ... arguments dans ma classe dérivée, j'utilise super () sans aucun argument. alors que se passera-t-il s'il appelle automatiquement un constructeur par défaut d'une classe de base
Mohan
Oui. Si vous l'appelez, super()il invoquera le constructeur de la super-classe qui ne prend aucun argument. De même, il invoquera le constructeur à 1 argument si vous le faites super(arg1), et ainsi de suite.
aioobe
s'il n'y avait pas de constructeur sans argu dans la classe de base, que se passe-t-il si la classe dérivée appelle super ().
Mohan
1
Rien. Il ne compilera pas. Si vous fournissez vous-même un constructeur, le constructeur automatique / par défaut / sans argument ne sera pas généré et super()ne sera donc pas un appel valide.
aioobe
29

Est-ce que super () est utilisé pour appeler le constructeur parent?

Oui.

Veuillez expliquer Super ().

super()est une utilisation spéciale du supermot - clé où vous appelez un constructeur parent sans paramètre. En général, le supermot - clé peut être utilisé pour appeler des méthodes substituées, accéder à des champs masqués ou invoquer le constructeur d'une superclasse.

Voici le tutoriel officiel

Heinzi
la source
5
super()est utilisé pour appeler le constructeur parent, super.myMethod()est utilisé pour appeler une méthode redéfinie.
Sean Patrick Floyd
2
@seanizer ou toute autre méthode de la superclasse (y compris la statique) si sa portée. super n'est qu'une référence à votre classe de base.
atamanroman
3
Je ne pense pas que super () soit utilisé pour appeler des méthodes de classe de base. Vous pouvez cependant utiliser super.method ().
Dheeraj Joshi
@seanizer, @Dheeraj: Merci pour vos commentaires, j'ai adapté ma réponse.
Heinzi
7

L'appel du super constructeur sans arguments n'est qu'une perte d'espace d'écran et de temps de programmation. Le compilateur génère exactement le même code, que vous l'écriviez ou non.

class Explicit() {
    Explicit() {
        super();
    }
}

class Implicit {
    Implicit() {
    }
}
Roland Illig
la source
Je l'ai trouvé utilisé dans quelques classes, je ne savais pas quel était le but. Votre réponse est utile.
iprashant
6

Oui, super()(en minuscules) appelle un constructeur de la classe parent. Vous pouvez inclure des arguments:super(foo, bar)

Il existe également un supermot - clé que vous pouvez utiliser dans les méthodes pour appeler une méthode de la superclasse

Un rapide Google pour obtenir des résultats « Java super » dans ce

Bozho
la source
4

C'est exact. Super est utilisé pour appeler le constructeur parent. Supposons donc que vous ayez un bloc de code comme ça

class A{
    int n;
    public A(int x){
        n = x;
    }
}

class B extends A{
    int m;
    public B(int x, int y){
        super(x);
        m = y;
    }
}

Vous pouvez ensuite affecter une valeur à la variable membre n.

Sagar V
la source
2

J'ai vu toutes les réponses. Mais tout le monde a oublié de mentionner un point très important:

super () doit être appelé ou utilisé dans la première ligne du constructeur.

Pritam Banerjee
la source
1

Juste super (); seul appellera le constructeur par défaut, s'il existe de la superclasse d'une classe. Mais vous devez explicitement écrire vous-même le constructeur par défaut. Si vous n'avez pas Java, vous en générerez une sans implémentation, enregistrez super (); , faisant référence à l'objet Superclass universel, et vous ne pouvez pas l'appeler dans une sous-classe.

public class Alien{
   public Alien(){ //Default constructor is written out by user
   /** Implementation not shown…**/
   }
}

public class WeirdAlien extends Alien{
   public WeirdAlien(){
   super(); //calls the default constructor in Alien.
   }

}
TheArchon
la source
Sans argument .
Marquis de Lorne
1

Par exemple, dans l'automatisation au sélénium, vous avez un PageObject qui peut utiliser le constructeur de son parent comme ceci:

public class DeveloperSteps extends ScenarioSteps {

public DeveloperSteps(Pages pages) {
    super(pages);
}........
Todd Zhang
la source
1

Je voudrais partager avec les codes ce que j'ai compris.

Le super mot-clé en java est une variable de référence qui est utilisée pour référencer des objets de classe parent. Il est principalement utilisé dans les contextes suivants: -

1. Utilisation de super avec variables:

class Vehicle 
{ 
    int maxSpeed = 120; 
} 

/* sub class Car extending vehicle */
class Car extends Vehicle 
{ 
    int maxSpeed = 180; 

    void display() 
    { 
        /* print maxSpeed of base class (vehicle) */
        System.out.println("Maximum Speed: " + super.maxSpeed); 
    } 
} 

/* Driver program to test */
class Test 
{ 
    public static void main(String[] args) 
    { 
        Car small = new Car(); 
        small.display(); 
    } 
} 

Production:-

Maximum Speed: 120
  1. Utilisation de super avec des méthodes:
/* Base class Person */
class Person 
{ 
    void message() 
    { 
        System.out.println("This is person class"); 
    } 
} 

/* Subclass Student */
class Student extends Person 
{ 
    void message() 
    { 
        System.out.println("This is student class"); 
    } 

    // Note that display() is only in Student class 
    void display() 
    { 
        // will invoke or call current class message() method 
        message(); 

        // will invoke or call parent class message() method 
        super.message(); 
    } 
} 

/* Driver program to test */
class Test 
{ 
    public static void main(String args[]) 
    { 
        Student s = new Student(); 

        // calling display() of Student 
        s.display(); 
    } 
}

Production:-

This is student class
This is person class

3. Utilisation de super avec les constructeurs:

class Person 
{ 
    Person() 
    { 
        System.out.println("Person class Constructor"); 
    } 
} 

/* subclass Student extending the Person class */
class Student extends Person 
{ 
    Student() 
    { 
        // invoke or call parent class constructor 
        super(); 

        System.out.println("Student class Constructor"); 
    } 
} 

/* Driver program to test*/
class Test 
{ 
    public static void main(String[] args) 
    { 
        Student s = new Student(); 
    } 
} 

Production:-

Person class Constructor
Student class Constructor
Gulsan Borbhuiya
la source
0

Constructeurs
Dans un constructeur, vous pouvez l'utiliser sans point pour appeler un autre constructeur. superappelle un constructeur dans la superclasse; thisappelle un constructeur dans cette classe:

public MyClass(int a) {
  this(a, 5);  // Here, I call another one of this class's constructors.
}

public MyClass(int a, int b) {
  super(a, b);  // Then, I call one of the superclass's constructors.
}

superest utile si la superclasse doit s'initialiser. thisest utile pour vous permettre d'écrire tout le code d'initialisation matérielle une seule fois dans l'un des constructeurs et de l'appeler à partir de tous les autres constructeurs, beaucoup plus faciles à écrire.

Méthodes
Dans n'importe quelle méthode, vous pouvez l'utiliser avec un point pour appeler une autre méthode. super.method()appelle une méthode dans la superclasse; this.method()appelle une méthode de cette classe:

public String toString() {
  int    hp   = this.hitpoints();  // Calls the hitpoints method in this class
                                   //   for this object.
  String name = super.name();      // Calls the name method in the superclass
                                   //   for this object.

  return "[" + name + ": " + hp + " HP]";
}

superest utile dans un certain scénario: si votre classe a la même méthode que votre superclasse, Java supposera que vous voulez celle de votre classe; supervous permet de demander la méthode de la superclasse à la place. thisn'est utile que pour rendre votre code plus lisible.

Olathe
la source
0

Le mot clé super peut être utilisé pour appeler le constructeur de la superclasse et pour faire référence à un membre de la superclasse

Lorsque vous appelez super () avec les bons arguments, nous appelons en fait le constructeur Box , qui initialise les variables largeur , hauteur et profondeur , auquel il fait référence en utilisant les valeurs des paramètres correspondants. Il ne vous reste plus qu'à initialiser son poids à valeur ajoutée. Si nécessaire, vous pouvez désormais classer les variables Box comme privées . Placez-vous dans les champs du modificateur privé de la classe Box et assurez-vous que vous pouvez y accéder sans aucun problème.

La superclasse peut contenir plusieurs constructeurs de versions surchargées, vous pouvez donc appeler la méthode super () avec différents paramètres. Le programme exécutera le constructeur qui correspond aux arguments spécifiés.

public class Box {

    int width;
    int height;
    int depth;

    Box(int w, int h, int d) {
        width = w;
        height = h;
        depth = d;
    }

    public static void main(String[] args){
        HeavyBox heavy = new HeavyBox(12, 32, 23, 13);
    }

}

class HeavyBox extends Box {

    int weight;

    HeavyBox(int w, int h, int d, int m) {

        //call the superclass constructor
        super(w, h, d);
        weight = m;
    }

}
Luchnik
la source
0

super est un mot-clé. Il est utilisé dans une définition de méthode de sous-classe pour appeler une méthode définie dans la superclasse. Les méthodes privées de la superclasse ne peuvent pas être appelées. Seules les méthodes publiques et protégées peuvent être appelées par le super mot-clé. Il est également utilisé par les constructeurs de classe pour appeler les constructeurs de sa classe parente.

Vérifiez ici pour plus d'explications.

otoloye
la source
0

Comme indiqué, à l'intérieur du constructeur par défaut, il y a un super () implicite appelé sur la première ligne du constructeur.

Ce super () appelle automatiquement une chaîne de constructeurs commençant en haut de la hiérarchie des classes et descendant dans la hiérarchie.

S'il y avait plus de deux classes dans la hiérarchie des classes du programme, le constructeur par défaut de classe supérieure serait appelé en premier .

En voici un exemple:

class A {
    A() {
    System.out.println("Constructor A");
    }
}

class B extends A{

    public B() {
    System.out.println("Constructor B");
    }
}

class C extends B{ 

    public C() {
    System.out.println("Constructor C");
    }

    public static void main(String[] args) {
    C c1 = new C();
    }
} 

Ce qui précède produirait:

Constructor A
Constructor B
Constructor C
Mark Burleigh
la source