Dans cet article, nous en apprendrons davantage sur ce mot-clé en Java, comment et où les utiliser à l'aide d'exemples.
ce mot-clé
En Java, ce mot-clé est utilisé pour faire référence à l'objet courant à l'intérieur d'une méthode ou d'un constructeur. Par exemple,
class Main ( int instVar; Main(int instVar)( this.instVar = instVar; System.out.println("this reference = " + this); ) public static void main(String() args) ( Main obj = new Main(8); System.out.println("object reference = " + obj); ) )
Sortie :
this reference = Référence d'objet Main @ 23fc625e = Main @ 23fc625e
Dans l'exemple ci-dessus, nous avons créé un objet nommé obj de la classe Main. Nous imprimons ensuite la référence à l'objet obj et au thismot - clé de la classe.
Ici, nous pouvons voir que la référence des deux obj et thisest la même. Cela signifie que ce n'est rien d'autre que la référence à l'objet actuel.
Utilisation de ce mot-clé
Il existe diverses situations où le thismot-clé est couramment utilisé.
Utilisation de ceci pour les noms de variables d'ambiguïté
En Java, il n'est pas permis de déclarer deux ou plusieurs variables ayant le même nom dans une portée (portée de classe ou portée de méthode). Cependant, les variables d'instance et les paramètres peuvent avoir le même nom. Par exemple,
class MyClass ( // instance variable int age; // parameter MyClass(int age)( age = age; ) )
Dans le programme ci-dessus, la variable d'instance et le paramètre ont le même nom: age. Ici, le compilateur Java est confus en raison de l'ambiguïté du nom.
Dans une telle situation, nous utilisons ce mot-clé. Par exemple,
Voyons d'abord un exemple sans utiliser de thismot clé:
class Main ( int age; Main(int age)( age = age; ) public static void main(String() args) ( Main obj = new Main(8); System.out.println("obj.age = " + obj.age); ) )
Sortie :
mc.age = 0
Dans l'exemple ci-dessus, nous avons passé 8une valeur au constructeur. Cependant, nous obtenons 0en sortie. Cela est dû au fait que le compilateur Java est confus en raison de l'ambiguïté des noms entre l'instance de la variable et le paramètre.
Maintenant, réécrivons le code ci-dessus en utilisant le thismot-clé.
class Main ( int age; Main(int age)( this.age = age; ) public static void main(String() args) ( Main obj = new Main(8); System.out.println("obj.age = " + obj.age); ) )
Sortie :
obj.age = 8
Maintenant, nous obtenons le résultat attendu. C'est parce que lorsque le constructeur est appelé, thisà l'intérieur du constructeur est remplacé par l'objet obj qui a appelé le constructeur. Par conséquent, la variable d'âge reçoit la valeur 8.
De plus, si le nom du paramètre et de la variable d'instance est différent, le compilateur ajoute automatiquement ce mot-clé. Par exemple, le code:
class Main ( int age; Main(int i) ( age = i; ) )
est équivalent à:
class Main ( int age; Main(int i) ( this.age = i; ) )
ceci avec Getters et Setters
Une autre utilisation courante du thismot-clé est dans les méthodes setters et getters d'une classe. Par exemple:
class Main ( String name; // setter method void setName( String name ) ( this.name = name; ) // getter method String getName()( return this.name; ) public static void main( String() args ) ( Main obj = new Main(); // calling the setter and the getter method obj.setName("Toshiba"); System.out.println("obj.name: "+obj.getName()); ) )
Sortie :
obj.name: Toshiba
Ici, nous avons utilisé le thismot-clé:
- pour attribuer une valeur à l'intérieur de la méthode setter
- pour accéder à la valeur dans la méthode getter
Utilisation de ceci dans la surcharge du constructeur
Tout en travaillant avec la surcharge de constructeur, nous pourrions avoir à appeler un constructeur d'un autre constructeur. Dans un tel cas, nous ne pouvons pas appeler le constructeur explicitement. Au lieu de cela, nous devons utiliser un thismot-clé.
Ici, nous utilisons une forme différente de ce mot-clé. C'est this(). Prenons un exemple,
class Complex ( private int a, b; // constructor with 2 parameters private Complex( int i, int j )( this.a = i; this.b = j; ) // constructor with single parameter private Complex(int i)( // invokes the constructor with 2 parameters this(i, i); ) // constructor with no parameter private Complex()( // invokes the constructor with single parameter this(0); ) @Override public String toString()( return this.a + " + " + this.b + "i"; ) public static void main( String() args ) ( // creating object of Complex class // calls the constructor with 2 parameters Complex c1 = new Complex(2, 3); // calls the constructor with a single parameter Complex c2 = new Complex(3); // calls the constructor with no parameters Complex c3 = new Complex(); // print objects System.out.println(c1); System.out.println(c2); System.out.println(c3); ) )
Sortie :
2 + 3i 3 + 3i 0 + 0i
Dans l'exemple ci-dessus, nous avons utilisé le thismot-clé,
- pour appeler le constructeur
Complex(int i, int j)depuis le constructeurComplex(int i) - pour appeler le constructeur
Complex(int i)depuis le constructeurComplex()
Remarquez la ligne,
System.out.println(c1);
Here, when we print the object c1, the object is converted into a string. In this process, the toString() is called. Since we override the toString() method inside our class, we get the output according to that method.
One of the huge advantages of this() is to reduce the amount of duplicate code. However, we should be always careful while using this().
This is because calling constructor from another constructor adds overhead and it is a slow process. Another huge advantage of using this() is to reduce the amount of duplicate code.
Note: Invoking one constructor from another constructor is called explicit constructor invocation.
Passing this as an Argument
We can use this keyword to pass the current object as an argument to a method. For example,
class ThisExample ( // declare variables int x; int y; ThisExample(int x, int y) ( // assign values of variables inside constructor this.x = x; this.y = y; // value of x and y before calling add() System.out.println("Before passing this to addTwo() method:"); System.out.println("x = " + this.x + ", y = " + this.y); // call the add() method passing this as argument add(this); // value of x and y after calling add() System.out.println("After passing this to addTwo() method:"); System.out.println("x = " + this.x + ", y = " + this.y); ) void add(ThisExample o)( o.x += 2; o.y += 2; ) ) class Main ( public static void main( String() args ) ( ThisExample obj = new ThisExample(1, -2); ) )
Sortie :
Avant de passer ceci à la méthode addTwo (): x = 1, y = -2 Après avoir passé ceci à la méthode addTwo (): x = 3, y = 0
Dans l'exemple ci-dessus, à l'intérieur du constructeur ThisExample(), notez la ligne,
add(this);
Ici, nous appelons la add()méthode en la passant comme argument. Puisque ce mot-clé contient la référence à l'objet obj de la classe, nous pouvons changer la valeur de x et y à l'intérieur de la add()méthode.
