Le 'ce' et le ' super' les mots-clés sont des mots réservés utilisés dans un contexte différent. En plus de cela, Java fournit également ce() et super() constructeurs utilisés dans le contexte du constructeur. Dans cette section, nous aborderons les différences entre ce mot-clé et le super mot-clé et constructeur this() et super(), en Java.

super mot-clé et constructeur super()

super mot-clé

Un mot-clé réservé utilisé pour appeler la méthode ou la variable de la classe de base est appelé super mot-clé. Nous ne pouvons pas utiliser le super mot-clé en tant que identifiant . Le super mot-clé n'est pas seulement utilisé pour faire référence à l'instance de classe de base, mais également aux membres statiques.

entier en chaîne en Java

super() Constructeur

Le super() est principalement utilisé pour appeler des fonctions et des constructeurs membres de la classe de base.

Prenons un exemple des deux super mot-clé et super() pour comprendre comment ils fonctionnent.

SuperExemple1.java

 // import required classes and packages package javaTpoint.MicrosoftJava; // create Animal class which is base class of Animal class Animal{ // data member of Animal class String color = 'white'; } // create child class of Animal class Cat extends Animal{ //default constructor Cat() { // data members of the Cat class String color = 'Brown'; System.out.println('The cat is of color '+super.color); // calling parent class data member System.out.println('The cat is of color '+color); } } // create child class for Car class SuperExample1 extendsCat { // default constructor SuperExample1() { // calling base class constructor super(); System.out.println('The eyes of the cat is blue.'); } // main() method start publicstaticvoid main(String[] args) { // call default constructor of the SuperExample1 new SuperExample1(); System.out.println('Inside Main'); } } 

Sortir:

Dans la méthode main(), nous avons fait une déclaration nouveau SuperExemple1() . Il appelle le constructeur du SuperExemple1 classe.

À l'intérieur du constructeur, nous avons fait une déclaration super() qui appelle le constructeur de sa classe parent, c'est-à-dire Chat. Dans le constructeur, nous avons fait trois déclarations :

1. Initialiser la couleur avec la valeur 'Brun'.
2. Imprimer le membre de données de la classe parent.
3. Imprimer le membre de données de classe actuel.

Lorsque la deuxième instruction s'exécute, le flux du programme passe à la classe Animal pour accéder à la valeur de ses données membres. Après y avoir accédé, le flux revient vers le Chat constructeur de classe et l'imprime. Après cela, la dernière instruction exécute et imprime la valeur des variables de la classe actuelle.

Après exécution de la dernière déclaration du Chat classe, le flux revient au constructeur de classe SuperExemple1 et exécute les instructions restantes.

logique du premier ordre

Après avoir terminé l'exécution du SuperExemple1() , le flux revient à la méthode main() et exécute les instructions restantes.

Remarque : Pour utiliser super(), nous devons nous assurer qu'il s'agit de la première instruction du constructeur d'une classe. Nous pouvons l'utiliser pour faire référence uniquement au constructeur de la classe parent.

ce mot-clé et ce constructeur this()

ce mot clé

Il s'agit d'un mot-clé réservé en Java utilisé pour faire référence à l'objet de classe actuel. C'est une variable de référence à travers laquelle la méthode est appelée. Les autres utilisations de ce mot-clé sont :

• Nous pouvons l'utiliser pour faire référence à la variable d'instance de classe actuelle.
• Nous pouvons l'utiliser pour invoquer la méthode de classe actuelle (implicitement).
• Nous pouvons le passer en argument dans les appels de méthode et de constructeur.
• Nous pouvons également l'utiliser pour renvoyer l'instance de classe actuelle à partir de la méthode.

this() Constructeur

Le constructeur permet d'appeler un constructeur à partir d'un autre de la même classe. Prenons un exemple des deux ce mot-clé et ce() pour comprendre comment ils fonctionnent.

CetExemple1.java

 // import required classes and packages package javaTpoint.MicrosoftJava; // create ThisExample1 class to understand the working of this() and this class ThisExample1 { // initialize instance and static variable int x = 5; staticinty = 10; // default constructor of class ThisExample1 ThisExample1() { // invoking current class constructor this(5); System.out.println('We are insie of the default constructor.'); System.out.println('The value of x = '+x); } ThisExample1(int x) { this.x = x; // override value of the current class instance variable System.out.println('We are inside of the parameterized constructor.'); System.out.println('The value of y = '+y); } publicstaticvoid main(String[] args) { // invoking constructor of the current class new ThisExample1(); System.out.println('Inside Main'); } } 

Sortir:

Différence entre ceci et un super mot-clé

Le tableau suivant décrit la principale différence entre this et super :

Différence entre le constructeur this() et super()