super() en Java

Quelques faits:

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

OK, maintenant nous allons mettre en œuvre concrètement ces points de super().

Découvrez la différence entre le programme 1 et 2. Ici, le programme de 2 preuves de notre première déclaration de 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();
    }
}

De sortie:

200

200

Maintenant découvrez le programme 2 et essayer de comprendre la différence principale.

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

De sortie:

100

200

Dans le programme 1, le résultat a été que de la classe dérivée. Il ne pouvait pas imprimer la variable ni de la classe de base, ni la classe parent. Mais dans le programme 2, nous avons utilisé super() variable a lors de l'impression de sa sortie, et au lieu de l'impression de la valeur de la variable a de la classe dérivée, il a imprimé la valeur de la variable a de la classe de base. Donc, il s'avère que super() est utilisée pour appeler le parent immédiat.

OK, maintenant découvrez 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();
    }
}

De sortie:

200

Ici, la sortie est de 200. Quand nous avons appelé Show(), le Show() fonction de la classe dérivée a été appelé. Mais que devons-nous faire si nous voulons appeler la Show() fonction de la classe parent? Découvrez le programme 4 de 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();
    }
}

De sortie:

100

200

Nous avons ici deux sorties, 100 et 200. Lorsque le Show() fonction de la classe dérivée est appelée, elle appelle d'abord la Show() fonction de la classe parent, parce que à l'intérieur de la Show() fonction de la classe dérivée, nous avons appelé le Show() fonction de la classe parente en mettant le super mot-clé avant le nom de la fonction.

Est super() est utilisée pour appeler le constructeur parent?

Oui.

Pls expliquer à propos de Super().

super() est une utilisation particulière de la super mot-clé lorsque vous appelez un sans paramètre constructeur parent. En général, la super mot-clé peut être utilisé pour appeler des méthodes de remplacement, l'accès des champs cachés ou d'appeler un constructeur de la superclasse.

Voici la tutoriel officiel

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

Il y a aussi un super mot-clé, que vous pouvez utiliser dans les méthodes pour appeler une méthode de la super-classe

Un rapide google pour "Java super" résultats dans cette

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

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

Par exemple, en sélénium de l'automation, vous avez un PageObject qui peut utiliser l'un de ses parents constructeur comme suit:

public class DeveloperSteps extends ScenarioSteps {

public DeveloperSteps(Pages pages) {
    super(pages);
}........

La super mot-clé peut être utilisé pour appeler le constructeur de la superclasse et à se référer à un membre de la super-classe

Lorsque vous appelez super() avec les bons arguments, nous avons fait appel au constructeur Boîte de, qui initialise les variables largeur, hauteur et profondeur, qui lui est soumise en utilisant les valeurs des paramètres correspondants. Vous ne reste plus qu'à initialiser la valeur ajoutée de poids. Si nécessaire, vous pouvez le faire maintenant de variables de classe de la Zone comme privé. Mettre bas dans les champs de la classe Box privé modificateur et assurez-vous que vous pouvez y accéder sans aucun problème.

À la super-classe peut avoir plusieurs versions surchargées de constructeurs, de sorte que vous pouvez appeler la méthode super() avec des paramètres différents. Le programme va effectuer le constructeur qui correspond à l'argument spécifié.

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

}

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

Ce super() appelle automatiquement un de la chaîne de constructeurs à partir du haut de la hiérarchie de classe et se déplace vers le bas de la hiérarchie .

Si il y avait plus de deux classes dans la hiérarchie de classe du programme, la classe supérieure de constructeur par défaut serait d'obtenir appelé première.

Voici un exemple de ceci:

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

Ci-dessus serait de sortie:

Constructor A
Constructor B
Constructor C