Pourquoi appeler super () dans un constructeur?
j'ai affaire à une classe qui étend JFrame.
ce n'est pas mon code et il fait un appel à super avant de commencer à construire l'interface graphique. Je me demande pourquoi cela est fait puisque j'ai toujours juste accédé aux méthodes de la superclasse sans avoir à appeler super();
5 réponses
Il y a un appel implicite à super() sans argument pour toutes les classes qui ont un parent-qui est chaque classe définie par l'utilisateur en Java - donc l'appeler explicitement n'est généralement pas nécessaire. Cependant, vous utilisez l'appel pour super() avec les arguments si le constructeur du parent prend des paramètres, et que vous souhaitez les spécifier. De plus, si le constructeur du parent prend des paramètres, et qu'il n'a pas de constructeur par défaut sans paramètre, vous besoin appeler super() avec argument(s).
Un exemple, où l'appel explicite à super() vous donne un peu plus de contrôle sur le titre de l'image:
class MyFrame extends JFrame
{
public MyFrame() {
super("My Window Title");
...
}
}
appel à votre parent de la classe du constructeur vide super() se fait 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. Il a été fait pour vous.
quand votre superclass 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 quelque chose dont tu dois t'inquiéter aussi beaucoup.
Si vous appelez super() dans votre constructeur ou pas, cela n'affecte pas votre capacité à appeler les méthodes de votre classe parent.
Comme une note de côté, certains disent qu'il est généralement préférable de faire cet appel manuellement pour des raisons de clarté.
nous pouvons accéder aux éléments de super class en utilisant la méthode super
Considérons que nous avons deux classes, la classe Parent et de l'Enfant en classe, avec les différentes implémentations de la méthode foo. Maintenant en classe enfant si nous voulons appeler la méthode foo de classe parent, nous pouvons le faire par super.foo(); nous pouvons également accéder aux éléments parent 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();
}
}
il appelle simplement le constructeur par défaut de la superclasse.
nous pouvons accéder aux membres SuperClass en utilisant super ()
si votre méthode l'emporte sur une de ses méthodes superclass, vous pouvez invoquer la méthode overridden en utilisant le mot-clé super. Vous pouvez également utiliser super pour se référer à un champ caché (bien que se cacher des Champs est déconseillé). Considérez cette classe, super-classe:
public class Superclass {
public void printMethod() {
System.out.println("Printed in Superclass.");
}
}
> / Voici une sous-classe, appelée sous-classe, qui l'emporte sur 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 simple nom printMethod() se réfère à celui déclaré dans la sous-classe, qui l'emporte sur celui de la superclasse. Donc, reportez-vous à printMethod() hérité de superclasse, la sous-classe doit utiliser un nom qualifié, en utilisant super comme indiqué. Compiler et exécuter la sous-classe imprime ce qui suit:
Printed in Superclass.
Printed in Subclass