Utilisation du mot clé "this" en java
J'essaie de comprendre ce que fait réellement le mot clé Java this. J'ai lu la documentation de Sun, mais je ne comprends toujours pas ce que this fait réellement.
Le mot clé this est une référence à l'objet actuel.
class Foo
{
private int bar;
public Foo(int bar)
{
// the "this" keyword allows you to specify that
// you mean "this type" and reference the members
// of this type - in this instance it is allowing
// you to disambiguate between the private member
// "bar" and the parameter "bar" passed into the
// constructor
this.bar = bar;
}
}
Une autre façon de penser est que le mot clé this est comme un pronom personnel que vous utilisez pour vous référencer. D'autres langues ont des mots différents pour le même concept. VB utilise Me et la convention Python (Python n'utilisant pas de mot clé, mais simplement un paramètre implicite pour chaque méthode) consiste à utiliser self.
Si vous deviez référencer des objets qui vous appartiennent intrinsèquement, vous diriez quelque chose comme ceci:
Mon bras ou mon jambe
Pensez à this comme un moyen pour un type de dire "mon". Ainsi, une représentation psuedocode ressemblerait à ceci:
class Foo
{
private int bar;
public Foo(int bar)
{
my.bar = bar;
}
}
Le mot clé this peut signifier différentes choses dans différents contextes, c'est probablement la source de votre confusion.
Il peut être utilisé comme référence d'objet faisant référence à l'instance sur laquelle la méthode actuelle a été appelée: return this;
Il peut être utilisé comme référence d'objet faisant référence à l'instance créée par le constructeur actuel, par exemple. pour accéder aux champs cachés:
MyClass(String name)
{
this.name = name;
}
Il peut être utilisé pour invoquer un constructeur différent d'une classe à partir d'un constructeur:
MyClass()
{
this("default name");
}
Il peut être utilisé pour accéder à des instances englobantes à partir d'une classe imbriquée:
public class MyClass
{
String name;
public class MyClass
{
String name;
public String getOuterName()
{
return MyClass.this.name;
}
}
}
"this" est une référence à l'objet actuel.
Voir détails ici
Le mot clé this est une référence à l'objet actuel . Il est préférable de l'expliquer avec le code suivant:
public class MyClass {
public void testingThis()
{
// You can access the stuff below by
// using this (although this is not mandatory)
System.out.println(this.myInt);
System.out.println(this.myStringMethod());
// Will print out:
// 100
// Hello World
}
int myInt = 100;
string myStringMethod()
{
return "Hello World";
}
}
Il n’est pas très utilisé sauf si vous avez le code standard chez vous, vous invitant à utiliser le mot clé this. Son utilisation est courante, si vous suivez une convention de code dans laquelle vous avez des noms de paramètres identiques à ceux de vos attributs de classe:
public class ProperExample {
private int numberOfExamples;
public ProperExample(int numberOfExamples)
{
this.numberOfExamples = numberOfExamples;
}
}
Une utilisation correcte du mot-clé this est d’enchaîner les constructeurs (rendant l’objet de construction cohérent dans tous les constructeurs):
public class Square {
public Square()
{
this(0, 0);
}
public Square(int x_and_y)
{
this(x_and_y, x_and_y);
}
public Square(int x, int y)
{
// finally do something with x and y
}
}
Ce mot clé fonctionne de la même manière, par exemple. C #.
Une utilisation encore meilleure de cette
public class Blah implements Foo {
public Foo getFoo() {
return this;
}
}
Cela vous permet de spécifiquement "cet" objet dans le contexte actuel. Un autre exemple:
public class Blah {
public void process(Foo foo) {
foo.setBar(this);
}
}
Sinon, comment pourriez-vous faire ces opérations.
Le mot-clé "this" fait référence à l'objet actuel pour lequel la méthode est en cours d'exécution. Il est également utilisé pour éviter toute ambiguïté entre la variable locale transmise en tant qu'argument dans une méthode et une variable d'instance chaque fois que la variable d'instance et la variable locale ont le même nom.
Exemple ::
public class ThisDemo1
{
public static void main(String[] args)
{
A a1=new A(4,5);
}
}
class A
{
int num1;
int num2;
A(int num1)
{
this.num1=num1; //here "this" refers to instance variable num1.
//"this" avoids ambigutiy between local variable "num1" & instance variable "num1"
System.out.println("num1 :: "+(this.num1));
}
A(int num, int num2)
{
this(num); //here "this" calls 1 argument constructor within the same class.
this.num2=num2;
System.out.println("num2 :: "+(this.num2));
//Above line prints value of the instance variable num2.
}
}
Le mot clé ' this ' fait référence au contexte de l'objet en cours. Dans de nombreux cas (comme Andrew indique), vous utiliserez un this explicite pour indiquer que vous faites référence à l'objet actuel.
Aussi, à partir de ' this and super ':
* Il y a d'autres utilisations pour cela. Parfois, lorsque vous écrivez une méthode d'instance, vous devez transmettre l'objet qui contient la méthode à un sous-programme, en tant que paramètre réel. Dans ce cas, vous pouvez l'utiliser comme paramètre réel. Par exemple, si vous souhaitez imprimer une représentation sous forme de chaîne de l'objet, vous pouvez dire "System.out.println (this);". Ou vous pouvez affecter la valeur de ceci à une autre variable dans une instruction d'affectation.
En fait, vous pouvez utiliser n'importe quelle variable avec cette variable, à l'exception de la modification de sa valeur. *
Ce site fait également référence au concept connexe de ' super ', qui peut s’avérer utile pour comprendre comment ils fonctionnent avec l’héritage.
C'est une référence d'instance réelle d'une classe à l'intérieur d'une méthode de la même classe. Coding
public class A{
int attr=10;
public int calc(){
return this.getA()+10;
}
/**
*get and set
**/
}//end class A
Dans calc () body, le logiciel exécute une méthode à l'intérieur de l'objet actuellement alloué.
Comment est-il possible que le comportement de l'objet puisse se voir? Avec le this mot clé, exactement.
Vraiment, le mot-clé this ne nécessite pas d’utilisation obligatoire (comme super ) car la machine virtuelle Java sait où appeler une méthode dans la zone mémoire, mais à mon avis, cela rend la code plus lisible.
Ce peut être aussi un moyen d'accéder à des informations sur le contexte actuel. Par exemple:
public class OuterClass
{
public static void main(String[] args)
{
OuterClass oc = new OuterClass();
}
OuterClass()
{
InnerClass ic = new InnerClass(this);
}
class InnerClass
{
InnerClass(OuterClass oc)
{
System.out.println("Enclosing class: " + oc + " / " + oc.getClass());
System.out.println("This class: " + this + " / " + this.getClass());
System.out.println("Parent of this class: " + this.getClass().getEnclosingClass());
System.out.println("Other way to parent: " + OuterClass.this);
}
}
}
Ce que cela fait est très simplement. Il contient la référence de l'objet Actuel.
- Ce mot clé contient la référence d'instance de la classe en cours
- Ce mot clé ne peut pas être utilisé à l'intérieur d'une fonction statique ou de blocs statiques
- Ce mot-clé peut être utilisé pour accéder à une variable occulte d'instance.
- Ce mot clé peut être utilisé pour passer l'objet actuel en tant que paramètre dans les appels de fonction
- Ce mot clé peut être utilisé pour créer une chaîne de constructeur
Chaque objet peut accéder à une référence à lui-même avec le mot clé this (parfois appelé la référence this ).
D'abord jetons un coup d'oeil sur le code
public class Employee {
private int empId;
private String name;
public int getEmpId() {
return this.empId;
}
public String getName() {
return this.name;
}
public void setEmpId(int empId) {
this.empId = empId;
}
public void setName(String name) {
this.name = name;
}
}
Dans la méthode ci-dessus, getName () renvoie le nom de la variable d'instance. Regardons maintenant du code similaire.
public class Employee {
private int empId;
private String name;
public int getEmpId() {
return this.empId;
}
public String getName() {
String name="Yasir Shabbir";
return name;
}
public void setEmpId(int empId) {
this.empId = empId;
}
public void setName(String name) {
this.name = name;
}
public static void main(String []args){
Employee e=new Employee();
e.setName("Programmer of UOS");
System.out.println(e.getName());
}
}
Sortie Yasir Shabbir
- cet opérateur travaille toujours avec une variable d'instance (Belong to Object) et non une variable de classe (Belong to Class)
- cela fait toujours référence à l'attribut de classe non statique, pas à tout autre paramètre ou variable locale.
- cette toujours utiliser dans la méthode non statique
- cet opérateur ne peut pas travailler sur une variable statique (variable de classe)
** REMARQUE: ** C’est souvent une erreur de logique quand une méthode contient un paramètre ou une variable locale qui a le même nom que En tant que champ de la classe. Dans ce cas, utilisez reference this si vous souhaitez accéder au champ De la classe; sinon, le paramètre de méthode ou la variable locale sera référencé.
Pensez-y en anglais, "cet objet" est l'objet que vous avez actuellement.
WindowMaker foo = new WindowMaker(this);
Par exemple, vous êtes actuellement dans une classe qui s'étend depuis JFrame et vous souhaitez transmettre une référence à l'objet WindowMaker pour JFrame afin qu'il puisse interagir avec JFrame. Vous pouvez passer une référence au JFrame, en passant sa référence à l'objet appelé "this".