Différence entre “ce” et“super” mots-clés en Java

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

Les deux sont utilisés pour accéder à des constructeurs de la classe à droite? Pouvez-vous vous expliquer?

InformationsquelleAutor Sumithra | 2010-10-26

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 est en cours d'impression "animal:manger" parce que nous sommes d'appel super.eat(). Si nous avons appelé this.eat(), il aurait imprimé en tant que "chien:manger".

Je ne trouve pas cette réponse déroutant, mais vous pouvez faire la dernière ligne de la sortie en gras ou en ajouter un point d'observation à souligner que la classe de base a été utilisé.

InformationsquelleAutor Nithesh Chandra

52

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 en cours.

L'extension de 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 très classe où vous écrivez ce code.

InformationsquelleAutor Jaywalker
19

this est une référence à l'objet saisi au cours actuel, et super est une référence à l'objet typé en tant que parent de la classe.

Dans le constructeur, this() appelle un constructeur défini dans la classe en cours. super() appelle un constructeur défini dans la classe parent. Le constructeur peuvent être définies dans la classe parent, mais il va se réfèrent à un substituée la plus proche de la classe en cours. Les appels vers d'autres constructeurs peuvent être effectuées uniquement la première ligne dans un constructeur.

De l'appel de méthodes fonctionne de la même manière. L'appel de this.method() appelle une méthode de la classe actuelle où super.method() fera appel à la même méthode, telle que définie dans la classe parent.
- Belle explication! Clair et Concis!
InformationsquelleAutor Erick Robertson
10

De votre question, j'en déduis que vous êtes vraiment se demander à propos de l'utilisation de this et super dans le constructeur de chaînage; par exemple,
```
public class A extends B {
    public A(...) {
        this(...);
        ...
    }
}
```
contre
```
public class A extends B {
    public A(...) {
        super(...);
        ...
    }
}
```
La différence est simple:
- La this former des chaînes à un constructeur de la classe en cours; c'est à dire dans le A classe.
- La super former des chaînes à un constructeur dans l'immédiat super-classe; c'est à dire dans le B classe.
InformationsquelleAutor Stephen C
8

this se réfère à un état de référence de la actuel classe.

super se réfère à la parent de la classe actuelle (qui a appelé à la super mot-clé).

En faisant this, il permet l'accès aux méthodes et attributs de la classe actuelle (y compris de sa propre salle de méthodes et attributs).

super vous permet d'accéder public/protected méthode attributs/des parent(de base) de la classe. Vous ne pouvez pas voir le parent privé de la méthode/attributs.
- Cette réponse est juste si vous changer toutes les occurrences de "classe" en "objet". Il n'est par exemple pas possible d'appeler 'ce' partir d'une méthode statique dans une classe.
- vrai...en gros, je suis allé sur le fait que super les appels de la classe de base (puisque c'est une classe dérivée d'une classe de base). Devrais-je dire de l'objet de base? Si oui, quelle est la différence entre la classe/objet?
- Je sais que c'est un peu jongler avec les mots et beaucoup de gens l'utilisation de la classe et d'objet comme des synonymes. La classe est en fait la définition et peut avoir des méthodes statiques, des constantes et peut même ne pas avoir la possibilité d'être instancié (classes abstraites). Un objet ne peut exister au moment de l'exécution et doit être créé avec le mot-clé new.
- vrai, mais si vous regardez la littérature, vous verrez des mots tels que base et derived classes et pas based et derived objets. Peut-être que la nouvelle de la littérature distingue la différence.
- Je suis d'accord sur l'utilisation de "base" et "dérivés" classes dans le contexte d'un diagramme de classe (ou de l'analyse technique) plus informelles de nommage pour les super-classe et sous-classe respectivement.
- u peut me dire les schématiquement l'utilisation du mot-clé super , pour ce mot clé, je peux penser que c'est un pointeur. Encore une question, c'est que quand j'utilise ce mot clé à l'intérieur du Système.out.println(this) il imprimer des adresses sous forme cryptée, mais j'utilise le mot-clé super dans le Système.out.println(super) il affiche l'erreur pourquoi?
InformationsquelleAutor Buhake Sindi
5

super() & ce()
- super () pour appeler le parent le constructeur de la classe.
- ce() - pour appeler même le constructeur de la classe.
REMARQUE:
- Nous pouvons utiliser super() et ce() uniquement dans le constructeur pas n'importe où d'autre, tout
  tentative de le faire conduire à l'erreur de compilation.
- Nous devons garder soit super() ou ce (ou) de la première ligne de la
  constructeur mais PAS les deux simultanément.
super & ce mot-clé
- super pour appeler le parent membres de la classe(variables et méthodes).
- ce - pour appeler de même les membres de la classe(variables et méthodes).
REMARQUE: Nous pouvons utiliser n'importe où dans une classe à l'exception des zones statiques(static bloc ou de la méthode), tout
tentative de le faire conduire à l'erreur de compilation.

InformationsquelleAutor Varun Vashista
3

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

super permet l'accès à la non-privé, de méthodes et de champs dans la super-classe, et pour accéder à des constructeurs de l'intérieur de la classe des constructeurs seulement.

InformationsquelleAutor David Rabinowitz
3

Lors de l'écriture de code, en général, ne veulent pas se répéter. Si vous avez une classe qui peut être construit avec différents nombres de paramètres d'une solution commune pour éviter de vous répéter, est de simplement appeler un autre constructeur avec paramètres par défaut dans les arguments manquants. Il y a seulement un ennuyeux restriction à la présente, - elle doit être la première ligne de la déclaration de constructeur. Exemple:
```
MyClass()
{
   this(default1, default2);
}

MyClass(arg1, arg2)
{
   validate arguments, etc...
   note that your validation logic is only written once now
}
```
Comme pour le super() constructeur, contrairement à super.method() d'accès, il doit être la première ligne de votre constructeur. Après cela, il est très bien comme la this() constructeurs, DRY (Don't Repeat Yourself), si la classe que vous étendre a un constructeur qui fait partie de ce que vous voulez, puis l'utiliser et puis continuer 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...
   }
}
```
Informations supplémentaires:

Même si vous ne le voyez pas, la valeur par défaut sans argument du constructeur appelle toujours super() premier. Exemple:
```
MyClass()
{
}
```
est équivalent à
```
MyClass()
{
   super();
}
```
Je vois que beaucoup ont mentionné l'aide de la this et super mots-clés sur les méthodes et les variables - est du tout bon. Rappelez-vous juste que les constructeurs ont des restrictions sur leur utilisation, le plus notable est qu'ils doivent être la première instruction de la déclaration de constructeur et vous ne pouvez en utiliser qu'un.

InformationsquelleAutor BigMac66

ce mot-clé à utiliser pour appeler le constructeur de la même classe (les autres surchargé constructeur)

syntaxe: ce (args liste); //compatible avec args liste dans autre constructeur de la même classe

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

syntaxe: super (args liste); //compatible avec args liste 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) 
}
}

InformationsquelleAutor rocketmanu

Vous devez vous connecter pour publier un commentaire.

super() & ce()

super & ce mot-clé