Mot-clé this Java

Dans cet article, nous allons comprendre par des exemples la clé this en Java, comment et où elle est utilisée.

Clé this

La clé this est utilisée en Java pour renvoyer l'objet courant dans une méthode ou un constructeur. Par exemple,

class Main {
　　　　int instVar;
　　　　Main(int instVar){
　　　　　　　　this.instVar = instVar;
　　　　　　　　System.out.println("Référence this= ",　+　this);
　　　　}
　　　　public static void main(String[] args) {
　　　　　　　　Main obj = new Main(8);
　　　　　　　　System.out.println("Référence d'objet= ",　+　obj);
　　　　}
}

Output:

Référence this = com.ThisAndThat.MyClass@74a14482
Référence d'objet = com.ThisAndThat.MyClass@74a14482

Dans l'exemple précédent, nous avons créé un objet nommé obj de la classe Main. Ensuite, nous avons affiché les références de l'objet de la classe obj et de la clé this.

Ici, nous pouvons voir que les références obj et this sont identiques. Cela signifie que cela ne fait que renvoyer une référence à l'objet actuel.

Utilisation de la clé this

Dans divers cas, la clé this est généralement utilisée.

Utilisation de this pour résoudre les ambiguïtés des noms de variables

En Java, il n'est pas permis de déclarer deux ou plusieurs variables ayant le même nom à l'intérieur d'une portée (portée de classe ou de méthode). Cependant, les variables d'instance et les paramètres peuvent avoir le même nom. Par exemple,

class MyClass {
　　　　//　Variable d'instance
　　　　int age;
　　　　//　Paramètre
　　　　MyClass(int age){
　　　　　　　　age = age;
　　　　}
}

Dans le programme précédent, les variables d'instance et les paramètres ont le même nom : age. Ici, en raison de l'indétermination du nom, le compilateur Java est confus.

Dans ce cas, nous utilisons la clé this. Par exemple,

Tout d'abord, regardons un exemple sans utiliser la clé this :

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);
　　　　}
}

Output:

mc.age = 0

Dans l'exemple précédent, nous avons assigné une valeur8Il a été transmis au constructeur. Cependant, le 0 que nous obtenons est la sortie. Cela est dû au fait que le compilateur Java est confus en raison du nom inconnu des variables d'instance et des paramètres.

Maintenant, réécrivons le code ci-dessus en utilisant le mot-clé this.

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);
　　　　}
}

Output:

obj.age =　8

Maintenant, nous obtenons la sortie attendue. Cela est dû au fait que lorsque le constructeur est appelé, le contenu interne du constructeur est remplacé par l'objet appelant le constructeur, obj. Par conséquent, la variable age est affectée à8.

De plus, si le nom des paramètres et des variables d'instance diffère, le compilateur ajoute automatiquement le mot-clé this. Par exemple, le code suivant :

class Main {
　　　　int age;
　　　　Main(int i) {
　　　　　　　　age = i;
　　　　}
}

est équivalent à :

class Main {
　　　　int age;
　　　　Main(int i) {
　　　　　　　　this.age = i;
　　　　}
}

this et les getters et setters

Une autre utilisation courante du mot-clé this est dans les classesméthodes setter et getterpar exemple :

class Main {
　　　String name;
　　　//　méthode setter
　　　void setName(String name) {
　　　　　　　this.name = name;
　　　}
　　　//　méthode getter
　　　String getName(){
　　　　　　　return this.name;
　　　}
　　　public static void main(String[] args) {
　　　　　　　Main obj = new Main();
　　　　　　　//　appeler les méthodes setter et getter
　　　　　　　obj.setName("Seagull");
　　　　　　　System.out.println("obj.name: ",+obj.getName());
　　　}
}

Output:

obj.name: Seagull

Ici, nous avons utilisé le mot-clé this :

• lors de l'affectation des valeurs dans les méthodes setter

• lors de l'accès aux valeurs dans les méthodes getter

lors de l'utilisation de this dans la redéfinition des constructeurs

lors du traitementlors de la redéfinition des constructeursNous pourrions devoir appeler un autre constructeur à partir d'un autre constructeur. Dans ce cas, nous ne pouvons pas appeler explicitement le constructeur. Au lieu de cela, nous devons utiliser le mot-clé this.

Ici, nous utilisons une autre forme du mot-clé this. C'est-à-dire this(). Laissons nous prendre un exemple

class Complex {
　　　　private int a, b;
　　　　//constructeur avec deux paramètres
　　　　private Complex(int i, int j) {
　　　　　　　　this.a = i;
　　　　　　　　this.b = j;
　　　　}
　　　　//Constructeur avec un seul paramètre
　　　　private Complex(int i){
　　　　　　　　//Appel au constructeur avec deux paramètres
　　　　　　　　this(i, i);　
　　　　}
　　　　//Constructeur sans paramètres
　　　　private Complex(){
　　　　　　　　//constructeur sans paramètres
　　　　　　　　Appel au constructeur avec un seul paramètre
　　　　}
　　　　this(0);
　　　　@Override
　　　　　　　　public String toString(){　+　return this.a　+　return this.a　+　"　+　this.b
　　　　}
　　　　public static void main(String[] args) {
　　
　　　　　　　　　　　　　　　　//"i";
　　　　　　　　　　　　　　　　//Créer un objet de la classe Complex2Appel au constructeur avec　
　　　　　　　　Complex c1　= new Complex(2,　3);　
　　　　
　　　　　　　　//Appel au constructeur avec un seul paramètre
　　　　　　　　Complex c2　= new Complex(3);
　　　　　　　　//Appel au constructeur sans paramètres
　　　　　　　　Complex c3　= new Complex();
　　　　　　　　//Imprimer l'objet
　　　　　　　　System.out.println(c1);
　　　　　　　　System.out.println(c2);
　　　　　　　　System.out.println(c3);
　　　　}
}

Output:

2　+　3i
3　+　3i
0　+　0i

Dans l'exemple ci-dessus, nous avons utilisé le mot-clé this,

• Appel au constructeur Complex(int i) à partir du constructeur Complex(int i, int j)

• Appel au constructeur Complex() à partir du constructeur Complex(int i)

Attention à cette ligne,

System.out.println(c1);

Ici, lorsque nous imprimons l'objet c1Lorsque, l'objet est converti en chaîne de caractères. Dans ce processus, toString() est appelé. Comme nous avons redéfini la méthode toString() dans la classe, nous obtenons la sortie en fonction de cette méthode.

　L'un des plus grands avantages de this() est de réduire le nombre de code redondant. Mais, lors de l'utilisation de this(), nous devons être particulièrement prudents.

　C'est parce que l'appel d'un constructeur à partir d'un autre constructeur ajoute des coûts, et c'est un processus lent. Un autre grand avantage de l'utilisation de this() est de réduire le nombre de code redondant.

Attention：Appeler une autre constructeur à partir d'un autre constructeur s'appelle appel de constructeur explicite.

Passage de this en tant que paramètre

Nous pouvons utiliser le mot-clé this pour passer l'objet courant en tant que paramètre à une méthode. Par exemple,

class ThisExample {
　　　　//　Déclarer des variables
　　　　int x;
　　　　int y;
　　　　ThisExample(int x, int y) {
　　　　　　　　　　//Affectation des variables dans le constructeur
　　　　　　　　this.x = x;
　　　　　　　　this.y = y;
　　　　　　　　//Les valeurs de x et y avant l'appel à add()
　　　　　　　　System.out.println("Avant de passer this à la méthode addTwo() : ");
　　　　　　　　System.out.println("x = ")　+　this.x　+　", y = "　+　this.y);
　　　　　　　　//Appel à la méthode add() en passant this comme paramètre
　　　　　　　　add(this);
　　　　　　　　//Les valeurs de x et y après l'appel à add()
　　　　　　　　System.out.println("Après avoir passé this à la méthode addTwo() : ");
　　　　　　　　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);
　　　　}
}

Output:

Before passing this to the addTwo() method:
x =　1, y =　-2
After passing this to the addTwo() method:
x =　3, y = 0

In the above example, in the constructor ThisExample(), pay attention to the following line:

add(this);

Here, we call the add() method by passing this as a parameter. Because the this keyword contains a reference to the object obj of the class, we can change the values of x and y in the add() method.