web-dev-qa-db-fra.com

Pourquoi appeler super () dans un constructeur?

J'ai affaire à une classe qui étend JFrame.

Ce n'est pas mon code et il appelle super avant qu'il ne commence à construire l'interface graphique. Je me demande pourquoi cela est fait puisque j'ai toujours accédé aux méthodes de la superclasse sans avoir à appeler super();

javasuperclass
51
mark

Il existe un appel implicite à super() sans argument pour toutes les classes ayant un parent - qui correspond à toutes les classes définies par l'utilisateur dans Java - l'appel est donc explicitement non nécessaire). Cependant, vous pouvez utilisez l'appel à super() avec des arguments si le constructeur du parent accepte des paramètres et que vous souhaitez les spécifier. De plus, si le constructeur du parent accepte des paramètres, n'a pas de constructeur sans paramètre par défaut, vous besoin d'appeler super() avec un ou plusieurs arguments.

Un exemple, où l'appel explicite à super() vous donne un contrôle supplémentaire sur le titre du cadre:

class MyFrame extends JFrame
{
    public MyFrame() {
        super("My Window Title");
        ...
    }
}
89
AerandiR

Un appel au constructeur vide de votre classe parent super() est effectué automatiquement lorsque vous ne le faites pas vous-même. C'est la raison pour laquelle vous n'avez jamais eu à le faire dans votre code. C'était fait pour vous.

Lorsque votre super-classe n'a pas de constructeur no-arg, le compilateur vous demandera d'appeler super avec les arguments appropriés. Le compilateur s'assurera que vous instanciez correctement la classe. Donc, ce n’est pas une chose qui vous préoccupe trop.

Que vous appeliez super() dans votre constructeur ou non, cela n’affectera pas votre capacité à appeler les méthodes de votre classe parent.

En passant, certains disent qu'il est généralement préférable de passer cet appel manuellement pour des raisons de clarté.

19
Tim Pote

Nous pouvons accéder aux éléments de la super classe en utilisant la super méthode

Considérons que nous avons deux classes, la classe Parent et la classe Child, avec différentes implémentations de la méthode foo. Maintenant en classe enfant, si nous voulons appeler la méthode foo de la classe parente, nous pouvons le faire par super.foo (); nous pouvons également accéder aux éléments parents par la méthode super ().

    class parent {
    String str="I am parent";
    //method of parent Class
    public void foo() {
        System.out.println("Hello World " + str);
    }
}

class child extends parent {
    String str="I am child";
    // different foo implementation in child Class
    public void foo() {
        System.out.println("Hello World "+str);
    }

    // calling the foo method of parent class
    public void parentClassFoo(){
        super.foo();
    }

    // changing the value of str in parent class and calling the foo method of parent class
    public void parentClassFooStr(){
        super.str="parent string changed";
        super.foo();
    }
}


public class Main{
        public static void main(String args[]) {
            child obj = new child();
            obj.foo();
            obj.parentClassFoo();
            obj.parentClassFooStr();
        }
    }
2
Javapocalypse

Il appelle simplement le constructeur par défaut de la super-classe.

1
Community Driven Business

Nous pouvons accéder aux membres SuperClass en utilisant super ()

Si votre méthode substitue l'une des méthodes de sa superclasse, vous pouvez l'invoquer via le mot clé super. Vous pouvez également utiliser super pour faire référence à un champ masqué (bien que le fait de masquer des champs soit déconseillé). Considérez cette classe, Superclass:

public class Superclass {

    public void printMethod() {
        System.out.println("Printed in Superclass.");
    }
}

// Voici une sous-classe, appelée Subclass, qui remplace printMethod():

public class Subclass extends Superclass {

    // overrides printMethod in Superclass
    public void printMethod() {
        super.printMethod();
        System.out.println("Printed in Subclass");
    }
    public static void main(String[] args) {
        Subclass s = new Subclass();
        s.printMethod();    
    }
}

Dans la sous-classe, le nom simple printMethod() fait référence à celui déclaré dans la sous-classe, qui remplace celui de la super-classe. Donc, pour faire référence à printMethod() héritée de Superclass, Subclass doit utiliser un nom qualifié, en utilisant super comme indiqué. La compilation et l’exécution de la sous-classe imprime ce qui suit:

Printed in Superclass.
Printed in Subclass
0
Mdhar9e