super () en Java

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

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

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.

Article d'origine: Java: Calling super ()

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

Illustration:

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.

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

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() {
    }
}

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

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.

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.

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.
   }

}

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);
}........

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

2. 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

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.

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;
    }

}

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.

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