web-dev-qa-db-fra.com

Différence entre les mots-clés "this" et "super" dans Java

Quelle est la différence entre les mots-clés this et super?

Les deux sont utilisés pour accéder aux constructeurs de classe non? Est-ce que l'un de vous peut expliquer?

javakeyword
49
Sumithra

Permet de considérer cette situation

class Animal {
  void eat() {
    System.out.println("animal : eat");
  }
}

class Dog extends Animal {
  void eat() {
    System.out.println("dog : eat");
  }
  void anotherEat() {
    super.eat();
  }
}

public class Test {
  public static void main(String[] args) {
    Animal a = new Animal();
    a.eat();
    Dog d = new Dog();
    d.eat();
    d.anotherEat();
  }
}

La sortie va être

animal : eat
dog : eat
animal : eat

La troisième ligne affiche "animal: manger" parce que nous appelons super.eat(). Si nous appelions this.eat(), cela aurait été imprimé comme "dog: eat".

71
Nithesh Chandra

super est utilisé pour accéder aux méthodes de la classe de base tandis que this est utilisé pour accéder aux méthodes de la classe actuelle.

En étendant la notion, si vous écrivez super(), il fait référence au constructeur de la classe de base, et si vous écrivez this(), il fait référence au constructeur de la classe même dans laquelle vous écrivez cette code.

52
Jaywalker

this est une référence à l'objet saisi en tant que classe actuelle et super est une référence à l'objet défini en tant que classe parent.

Dans le constructeur, this() appelle un constructeur défini dans la classe en cours. super() appelle un constructeur défini dans la classe parente. Le constructeur peut être défini dans n'importe quelle classe parente, mais il fera référence à celle substituée la plus proche de la classe en cours. Les appels à d'autres constructeurs de cette manière ne peuvent être effectués que comme première ligne d'un constructeur.

Les méthodes d'appel fonctionnent de la même manière. L'appel de this.method() appelle une méthode définie dans la classe actuelle, où super.method() appellera la même méthode que celle définie dans la classe parente.

19
Erick Robertson

D'après votre question, je suppose que vous vous interrogez vraiment sur l'utilisation de this et super dans le chaînage de constructeurs; par exemple.

public class A extends B {
    public A(...) {
        this(...);
        ...
    }
}

versus

public class A extends B {
    public A(...) {
        super(...);
        ...
    }
}

La différence est simple:

  • La forme this forme des chaînes vers un constructeur de la classe actuelle; c'est-à-dire dans la classe A.

  • La forme super forme des chaînes vers un constructeur dans la superclasse immédiate; c'est-à-dire dans la classe B.

10
Stephen C

this fait référence à une référence de la classe actuelle.
super fait référence au parent de la classe actuelle (appelé le mot-clé super).

En faisant this, il vous permet d’accéder aux méthodes/attributs de la classe actuelle (y compris ses propres méthodes/attributs privés).

super vous permet d'accéder aux méthodes/attributs public/protected de la classe parent (de base). Vous ne pouvez pas voir la méthode privée/attributs du parent.

8
Buhake Sindi

super () et ceci ()

  • super () - pour appeler le constructeur de la classe parent.
  • this () - pour appeler le même constructeur de classe.

NOTE:

  • Nous pouvons utiliser super () et this () uniquement dans le constructeur et nulle part ailleurs, toute tentative dans ce sens entraînera une erreur lors de la compilation.

  • Nous devons garder soit super () ou this () comme première ligne du constructeur, mais PAS les deux simultanément.

super & ce mot clé

  • super - pour appeler les membres de la classe parent (variables et méthodes).
  • this - pour appeler les mêmes membres de la classe (variables et méthodes).

NOTE: Nous pouvons les utiliser n'importe où dans une classe, sauf les zones statiques (bloc statique ou méthode), toute tentative de cela entraînerait une erreur lors de la compilation.

5
Varun Vashista

this est utilisé pour accéder aux méthodes et aux champs de l'objet actuel. Pour cette raison, cela n'a pas de sens dans les méthodes statiques, par exemple.

super permet d'accéder aux méthodes et aux champs non privés de la super-classe, et d'accéder aux constructeurs à partir des constructeurs de la classe uniquement.

3
David Rabinowitz

Lorsque vous écrivez du code, vous ne voulez généralement pas vous répéter. Si vous avez une classe qui peut être construite avec différents nombres de paramètres, une solution courante pour éviter de vous répéter est d'appeler simplement un autre constructeur avec des valeurs par défaut dans les arguments manquants. Il n’ya qu’une restriction gênante: il s’agit de la première ligne du constructeur déclaré. Exemple:

MyClass()
{
   this(default1, default2);
}

MyClass(arg1, arg2)
{
   validate arguments, etc...
   note that your validation logic is only written once now
}

En ce qui concerne le constructeur super(), contrairement à super.method() access, ce doit être la première ligne de votre constructeur. Après cela, cela ressemble beaucoup aux constructeurs this(), DRY (ne vous répétez pas)], si la classe que vous étendez a un constructeur qui fait ce que vous voulez puis utilisez-le et continuez ensuite avec la construction de votre objet, exemple:

YourClass extends MyClass
{
   YourClass(arg1, arg2, arg3)
   {
      super(arg1, arg2) // calls MyClass(arg1, arg2)
      validate and process arg3...
   }
}

Information additionnelle:

Même si vous ne le voyez pas, le constructeur par défaut sans argument appelle toujours super() en premier. Exemple:

MyClass()
{
}

est équivalent à

MyClass()
{
   super();
}

Je vois que beaucoup ont mentionné l'utilisation des mots-clés this et super sur les méthodes et les variables - tout bon. Rappelez-vous que les constructeurs ont des restrictions uniques sur leur utilisation. Le plus notable est qu’ils doivent être la toute première instruction du constructeur déclaré et que vous ne pouvez en utiliser qu’une.

3
BigMac66

this mot clé utilisé pour appeler le constructeur dans la même classe (autre constructeur surchargé)

syntaxe : this (liste d'arguments); // compatible avec liste d'arguments dans un autre constructeur de la même classe

super mot-clé utilisé pour appeler le constructeur de la super classe.

syntaxe: super (liste d'arguments); // compatible avec liste d'arguments dans le constructeur de la super classe.

Ex:

public class Rect {
int x1, y1, x2, y2;

public Rect(int x1, int y1, int x2, int y2) // 1st constructor 
{ ....//code to build a rectangle }
}

public Rect () {   // 2nd constructor
this (0,0,width,height) // call 1st constructor (because it has **4 int args**), this is another way to build a rectangle 
}


public class DrawableRect extends Rect {

public DrawableRect (int a1, int b1, int a2, int b2) {
super (a1,b1,a2,b2) // call super class constructor (Rect class) 
}
}
3
rocketmanu