Java ce mot clé
Java ce mot-clé
Dans cet article, nous allons découvrir 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 = Main@23fc625e object reference = Main@23fc625e
Dans l'exemple ci-dessus, nous avons créé un objet nommé obj de la classe Main . On imprime ensuite la référence à l'objet obj et this mot clé de la classe.
Ici, nous pouvons voir que la référence des deux obj et this est le même. Cela signifie qu'il ne s'agit que de la référence à l'objet actuel.
Utilisation de ce mot clé
Il existe diverses situations où this mot-clé est couramment utilisé.
Utilisation de ceci pour les noms de variables ambigus
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 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 portent 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 this mot-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 :
obj.age = 0
Dans l'exemple ci-dessus, nous avons passé 8 comme valeur pour le constructeur. Cependant, nous obtenons 0 comme sortie. En effet, 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 this mot-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 la sortie attendue. 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. D'où l'âge la variable est affectée de 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;
}
} cela avec Getters et Setters
Une autre utilisation courante de this le mot 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é this mot-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 de constructeur
Lorsque vous travaillez avec la surcharge de constructeurs, nous devrons peut-être invoquer un constructeur à partir d'un autre constructeur. Dans un tel cas, nous ne pouvons pas appeler explicitement le constructeur. Au lieu de cela, nous devons utiliser this mot-clé.
Ici, nous utilisons une forme différente de ce mot-clé. C'est-à-dire 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é this mot-clé,
- pour appeler le constructeur
Complex(int i, int j)du constructeurComplex(int i) - pour appeler le constructeur
Complex(int i)du constructeurComplex()
Remarquez la ligne,
System.out.println(c1);
Ici, quand on imprime l'objet c1 , l'objet est converti en chaîne. Dans ce processus, le toString() est appelé. Puisque nous remplaçons le toString() méthode à l'intérieur de notre classe, nous obtenons la sortie selon cette méthode.
L'un des énormes avantages de this() est de réduire la quantité de code en double. Cependant, nous devons toujours être prudents lorsque nous utilisons this() .
En effet, l'appel d'un constructeur à partir d'un autre constructeur ajoute une surcharge et c'est un processus lent. Un autre énorme avantage d'utiliser this() est de réduire la quantité de code en double.
Remarque :L'invocation d'un constructeur à partir d'un autre constructeur est appelée invocation de constructeur explicite.
Passer ceci comme argument
Nous pouvons utiliser this mot-clé pour passer l'objet courant comme argument à une méthode. Par exemple,
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 :
Before passing this to addTwo() method: x = 1, y = -2 After passing this to addTwo() method: x = 3, y = 0
Dans l'exemple ci-dessus, à l'intérieur du constructeur ThisExample() , remarquez la ligne,
add(this);
Ici, nous appelons le add() méthode en passant ceci comme argument. Puisque ce mot clé contient la référence à l'objet obj de la classe, on peut changer la valeur de x et y à l'intérieur du add() méthode.
Java