super () en Java
Est-ce que super() est 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 argument1 (s'il existe).
En outre, il peut être utilisé pour appeler des méthodes à partir du parent. C'est à dire. super.aMethod()
Plus d'infos et tutoriel ici
Quelques faits:
super()est utilisé pour appeler le parent immédiat.super()peut être utilisé avec des membres d'instance, c'est-à-dire des variables d'instance et des méthodes d'instance.super()peut être utilisé dans un constructeur pour appeler le constructeur de la classe parente.
OK, mettons maintenant en pratique ces points de super().
Vérifiez la différence entre les programmes 1 et 2. Ici, le programme 2 vérifie 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();
}
}
Sortie:
200
200
Maintenant, consultez le programme 2 et essayez 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();
}
}
Sortie:
100
200
Dans le programme 1, la sortie n'était que de la classe dérivée. Il ne pouvait pas imprimer la variable ni de la classe de base ni de la classe parent. Mais dans le programme 2, nous avons utilisé super() avec la variable a lors de l’impression de sa sortie. Au lieu d’imprimer la valeur de la variable a de la classe dérivée, la valeur de la variable a de la classe de base a été imprimée. Cela prouve donc que super() est utilisé pour appeler le parent immédiat.
OK, vérifions 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();
}
}
Sortie:
200
Ici, la sortie est 200. Lorsque nous avons appelé Show(), la fonction Show() de la classe dérivée a été appelée. Mais que devons-nous faire si nous voulons appeler la fonction Show() 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();
}
}
Sortie:
100
200
Ici, nous obtenons deux sorties, 100 et 200. Lorsque la fonction Show() de la classe dérivée est appelée, elle appelle d’abord la fonction Show() de la classe parente, car à l’intérieur de la fonction Show() de la classe dérivée, nous avons appelé la fonction Show() de la classe parent en plaçant le mot clé super avant le nom de la fonction.
Oui. super(...) invoquera le constructeur de la super-classe.
Regardez cet exemple:
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();
}
}
Impressions:
Constructing an animal: From Dog constructor
Constructing a dog.
Est-ce que super () est utilisé pour appeler le constructeur parent?
Oui.
Pls expliquer sur Super ().
super() est une utilisation spéciale du mot clé super dans lequel vous appelez un constructeur parent sans paramètre. En général, le mot clé super peut être utilisé pour appeler des méthodes remplacées, accéder à des champs cachés ou appeler le constructeur d'une superclasse.
Voici le tutoriel officiel
Oui, super() (minuscule) appelle un constructeur de la classe parent. Vous pouvez inclure des arguments: super(foo, bar)
Il existe également un mot clé super, que vous pouvez utiliser dans les méthodes pour appeler une méthode de la superclasse.
Un rapide Google pour "super Java" a pour résultat this
L'appel du super constructeur sans arguments n'est qu'un gaspillage d'espace é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() {
}
}
C'est correct. Super est utilisé pour appeler le constructeur parent. Alors supposons que vous ayez un bloc de code comme
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;
}
}
Ensuite, vous pouvez affecter une valeur à la variable membre n.
Juste super (); seul appellera le constructeur par défaut, s'il existe dans la superclasse d'une classe. Mais vous devez explicitement écrire vous-même le constructeur par défaut. Si vous ne le faites pas, Java en générera un pour vous sans implémentation, enregistrez super (); , en faisant référence à l’objet universel Superclass, et vous ne pouvez 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 Selenium, 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);
}........
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.
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 super-classe ne peuvent pas être appelées. Seules les méthodes publiques et protégées peuvent être appelées par le mot clé super. 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 implicite super () appelé sur la première ligne du constructeur.
Ce super () appelle automatiquement une chaîne de constructeurs commençant au sommet de la hiérarchie de classes et descendant dans la hiérarchie.
S'il y avait plus de deux classes dans la hiérarchie de classes du programme, le constructeur par défaut de la classe supérieure obtiendrait appelépremier.
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();
}
}
Ce qui précède produirait:
Constructor A
Constructor B
Constructor C
Le mot clé super peut être utilisé pour appeler le constructeur de la superclasse et faire référence à un membre de la superclasse.
Lorsque vous appelez super () avec les bons arguments, nous appelons en fait le constructeurBox, qui initialise les variableswidth,heightetprofondeur, y sont référés 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 maintenant définir les variables de classe Box sous la forme private . Indiquez dans les champs du modificateur privé de la classe Box et assurez-vous que vous pouvez y accéder sans aucun problème.
Plusieurs constructeurs de versions surchargées peuvent se trouver dans la super-classe, vous pouvez donc appeler la méthode super () avec des paramètres différents. 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;
}
}
Constructeurs
Dans un constructeur, vous pouvez l’utiliser sans point pour appeler un autre constructeur. super appelle un constructeur de la superclasse; this appelle un constructeur de 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.
}
super est utile si la superclasse a besoin de s'initialiser. this est 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 depuis 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]";
}
super est 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; super vous permet de demander la méthode de la superclasse. this n'est utile que pour rendre votre code plus lisible.