Quelle est la signification de «ceci» en Java?

Normalement, je n'utilise que thisdans les constructeurs.

Je comprends qu'il est utilisé pour identifier la variable de paramètre (en utilisant this.something), si elle a un même nom avec une variable globale.

Cependant, je ne sais pas quelle est la vraie signification de thisJava et ce qui se passera si j'utilise thissans dot ( .).

this fait référence à l'objet courant.

Chaque méthode non statique s'exécute dans le contexte d'un objet. Donc, si vous avez une classe comme celle-ci:

public class MyThisTest {
  private int a;

  public MyThisTest() {
    this(42); // calls the other constructor
  }

  public MyThisTest(int a) {
    this.a = a; // assigns the value of the parameter a to the field of the same name
  }

  public void frobnicate() {
    int a = 1;

    System.out.println(a); // refers to the local variable a
    System.out.println(this.a); // refers to the field a
    System.out.println(this); // refers to this entire object
  }

  public String toString() {
    return "MyThisTest a=" + a; // refers to the field a
  }
}

Puis appeler frobnicate()sur new MyThisTest()imprimera

1
42
MyThisTest a = 42

Si efficacement, vous l'utilisez pour plusieurs choses:

• clarifier que vous parlez d'un champ, quand il y a aussi quelque chose d'autre avec le même nom qu'un champ
• se référer à l'objet courant dans son ensemble
• invoquez d'autres constructeurs de la classe courante dans votre constructeur

Ce qui suit est un copier-coller à partir d' ici , mais explique très bien toutes les différentes utilisations du thismot - clé:

Définition: le thismot - clé Java est utilisé pour faire référence à l'instance actuelle de la méthode sur laquelle il est utilisé.

Voici les façons d'utiliser ceci:

1. Pour indiquer spécifiquement que la variable d'instance est utilisée à la place d'une variable statique ou locale. C'est,

   private String javaFAQ;
   void methodName(String javaFAQ) {
       this.javaFAQ = javaFAQ;
   }
   

   Ici, cela fait référence à la variable d'instance. Ici, la priorité est élevée pour la variable locale. Par conséquent, l'absence de thisdénote la variable locale. Si la variable locale qui est le nom du paramètre n'est pas la même que la variable d'instance, indépendamment de thisest utilisée ou non, elle désigne la variable d'instance.

2. This est utilisé pour référencer les constructeurs

    public JavaQuestions(String javapapers) {
        this(javapapers, true);
    }
   

   Cela appelle le constructeur de la même classe java qui a deux paramètres.

3. This est utilisé pour passer l'instance Java actuelle en paramètre

   obj.itIsMe(this);

4. Similaire à ce qui précède, cela peut également être utilisé pour renvoyer l'instance actuelle

   CurrentClassName startMethod() {
        return this;
   }
   

   Remarque: cela peut conduire à des résultats indésirables lors de l'utilisation dans les classes internes dans les deux points ci-dessus. Puisque cela fera référence à la classe interne et non à l'instance externe.

5. This peut être utilisé pour obtenir le handle de la classe courante

   Class className = this.getClass(); // this methodology is preferable in java

   Bien que cela puisse être fait par

   Class className = ABC.class; // here ABC refers to the class name and you need to know that!

Comme toujours, thisest associé à son instance et cela ne fonctionnera pas dans les méthodes statiques.

Pour être complet, thispeut également être utilisé pour faire référence à l'objet extérieur

class Outer {
    class Inner {
        void foo() {
            Outer o = Outer.this;
    }
  }
}

Il fait référence à l'instance actuelle d'un objet particulier, vous pouvez donc écrire quelque chose comme

public Object getMe() {
    return this;
}

Un cas d'utilisation courant de thisconsiste à empêcher les ombres. Prenons l'exemple suivant:

public class Person {
    private final String name;

    public Person(String name) {
        // how would we initialize the field using parameter?
        // we can't do: name = name;
    }
}

Dans l'exemple ci-dessus, nous voulons affecter le membre de champ à l'aide de la valeur du paramètre. Puisqu'ils partagent le même nom, nous avons besoin d'un moyen de faire la distinction entre le champ et le paramètre. thisnous permet d'accéder aux membres de cette instance, y compris le champ.

public class Person {
    private final String name;

    public Person(String name) {
        this.name = name;
    }
}

Dans Swing, il est assez courant d'écrire une classe qui implémente ActionListeneret ajoute l'instance actuelle (c'est-à-dire «this») en tant qu'ActionListener pour les composants.

public class MyDialog extends JDialog implements ActionListener
{
    public MyDialog()
    {
        JButton myButton = new JButton("Hello");
        myButton.addActionListener(this);
    }

    public void actionPerformed(ActionEvent evt)
    {
        System.out.println("Hurdy Gurdy!");
    }

}

C'est "une référence à l'objet dans le contexte actuel" en fait. Par exemple, pour imprimer "cet objet", vous pourriez écrire:

System.out.println(this);

Notez que votre utilisation de "variable globale" est quelque peu décalée ... si vous l'utilisez this.variableNamealors, par définition, ce n'est pas une variable globale - c'est une variable spécifique à cette instance particulière.

Citant un article sur programmation.guide:

thisa deux utilisations dans un programme Java.

1. En référence à l'objet courant

La syntaxe dans ce cas ressemble généralement à quelque chose comme

this.someVariable = someVariable;

Ce type d'utilisation est décrit ici: La référence 'this' (avec exemples)

2. Pour appeler un autre constructeur

La syntaxe dans ce cas ressemble généralement à quelque chose comme

MyClass() {
    this(DEFAULT_VALUE); // delegate to other constructor
}

MyClass(int value) {
    // ...
}

Ce type d'utilisation est décrit ici: cet appel de constructeur (…) (avec exemples)

Il fait référence à l'instance sur laquelle la méthode est appelée

class A {

  public boolean is(Object o) {
    return o == this;
  }

}

A someA = new A();
A anotherA = new A();
someA.is(someA); // returns true
someA.is(anotherA); // returns false

Le mot-clé this est utilisé pour faire référence à la variable actuelle d'un bloc, par exemple, considérez le code ci-dessous (juste un examen, alors ne vous attendez pas au code JAVA standard):

Public class test{

test(int a) {
this.a=a;
}

Void print(){
System.out.println(a);
}

   Public static void main(String args[]){
    test s=new test(2);
    s.print();
 }
}

C'est tout. la sortie sera "2". Si nous n'avons pas utilisé le mot - clé this , la sortie sera: 0

Les objets ont des méthodes et des attributs (variables) qui sont dérivés de classes, afin de spécifier quelles méthodes et variables appartiennent à un objet particulier le thismot réservé est utilisé. dans le cas des variables d'instance, il est important de comprendre la différence entre les paramètres implicites et explicites. Jetez un œil à l' fillTankappel de l' audiobjet.

Car audi= new Car();

audi.fillTank(5); // 5 is the explicit parameter and the car object is the implicit parameter 

La valeur entre parenthèses est le paramètre implicite et l'objet lui-même est le paramètre explicite, les méthodes qui n'ont pas de paramètres explicites, utilisent des paramètres implicites, la fillTankméthode a à la fois un paramètre explicite et un paramètre implicite.

Regardons de plus près la fillTankméthode dans la Carclasse

public class Car()
{
   private double tank;

   public Car()
   {
      tank = 0;
   }

   public void fillTank(double gallons)
   {
      tank = tank + gallons;
   }

}

Dans cette classe, nous avons une variable d'instance "tank". Il peut y avoir de nombreux objets qui utilisent la variable d'instance tank, afin de spécifier que la variable d'instance "tank" est utilisée pour un objet particulier, dans notre cas l'objet "audi" que nous avons construit précédemment, nous utilisons le thismot clé réservé. par exemple les variables l'utilisation de 'this' dans une méthode indique que la variable d'instance, dans notre cas "tank", est la variable d'instance du paramètre implicite.

Le compilateur java ajoute automatiquement le thismot réservé pour que vous n'ayez pas à l'ajouter, c'est une question de préférence. Vous ne pouvez pas utiliser thissans point (.) Car ce sont les règles de java (la syntaxe).

En résumé.

• Les objets sont définis par des classes et ont des méthodes et des variables
• L'utilisation de thissur une variable d'instance dans une méthode indique que la variable d'instance appartient au paramètre implicite ou qu'il s'agit d'une variable d'instance du paramètre implicite.
• Le paramètre implicite est l'objet à partir duquel la méthode est appelée dans ce cas "audi".
• Le compilateur java ajoute automatiquement ce mot réservé, l'ajoutant est une question de préférence
• this ne peut pas être utilisé sans un point (.) ceci est syntaxiquement invalide
• this peut également être utilisé pour faire la distinction entre les variables locales et les variables globales qui ont le même nom
• le thismot de réserve s'applique également aux méthodes, pour indiquer qu'une méthode appartient à un objet particulier.

Les variables d'instance sont communes à chaque objet que vous créez. disons, il y a deux variables d'instance

class ExpThisKeyWord{
int x;
int y;

public void setMyInstanceValues(int a, int b) {
    x= a;
    y=b;

    System.out.println("x is ="+x);
    System.out.println("y is ="+y);
}

}




class Demo{
public static void main(String[] args){

ExpThisKeyWord obj1 = new ExpThisKeyWord();
ExpThisKeyWord obj2 = new ExpThisKeyWord();
ExpThisKeyWord obj3 = new ExpThisKeyWord();

obj1.setMyInstanceValues(1, 2);
obj2.setMyInstanceValues(11, 22);
obj3.setMyInstanceValues(111, 222);



}
}

si vous avez remarqué le code ci-dessus, nous avons initié trois objets et trois objets appellent la méthode SetMyInstanceValues. Comment pensez-vous que JVM attribue correctement les valeurs de chaque objet? il y a l'astuce, JVM ne verra pas ce code comme il est montré ci-dessus. au lieu de cela, il verra comme ci-dessous le code;

public void setMyInstanceValues(int a, int b) {
    this.x= a; //Answer: this keyword denotes the current object that is handled by JVM.
    this.y=b;

    System.out.println("x is ="+x);
    System.out.println("y is ="+y);
}

(Je sais que je suis en retard mais chut je suis le sournois que tu ne m'as jamais vu)

Le mot - clé this dans la plupart des langages de programmation orientés objet, sinon tous, signifie qu'il s'agit d'une référence vers l'instance d'objet actuelle de cette classe. C'est essentiellement la même chose que d'appeler cet objet depuis l'extérieur de la méthode par son nom. Cela n'avait probablement aucun sens, alors je vais élaborer:

En dehors de la classe, pour appeler quelque chose dans cette instance de l'objet, par exemple, disons que vous avez un objet appelé objet et que vous souhaitez obtenir un champ que vous devez utiliser

object.field

Supposons par exemple que vous essayez d'accéder à object.field depuis l'intérieur de votre classe, par exemple votre constructeur, vous pouvez utiliser

this.field

Le mot clé this remplace essentiellement le mot clé de nom d'objet lorsqu'il est appelé à l'intérieur de la classe. Il n'y a généralement pas beaucoup de raison de le faire en dehors du fait que vous avez deux variables du même nom dont l'une étant un champ de la classe et l'autre étant simplement une variable à l'intérieur d'une méthode, cela aide à déchiffrer entre les deux . Par exemple, si vous avez ceci: (Hah, compris? Ceci ? Hehe .... juste moi? Ok: (je vais partir maintenant)

public String Name;
//Constructor for {object} class
public object(String Name){
    Name = Name;
}

Cela poserait des problèmes, le compilateur ne serait pas en mesure de connaître la différence entre la variable Name définie dans les paramètres du constructeur et la variable Name à l'intérieur des déclarations de champ de votre classe, donc il affecterait à la place le paramètre Name à .. .. la valeur du paramètre Name qui ne fait rien de bénéfique et n'a littéralement aucun but. C'est un problème courant que font la plupart des nouveaux programmes et dont j'ai également été victime. Quoi qu'il en soit, la bonne façon de définir ce paramètre serait d'utiliser:

public String Name;
//Constructor for {object} class
public object(String Name){
    this.Name = Name;
}

De cette façon, le compilateur sait que la variable Name que vous essayez d'attribuer fait partie de la classe et non de la méthode et l'affecte correctement, ce qui signifie qu'il affecte le champ Name à tout ce que vous mettez dans le constructeur.

Pour résumer, il fait essentiellement référence à un champ de l'instance d'objet de la classe sur laquelle vous travaillez, d'où le mot-clé "this", signifiant son cet objet, ou cette instance. C'est une bonne pratique de l'utiliser lors de l'appel d'un champ de votre classe plutôt que d'utiliser simplement le nom pour éviter d'éventuels bogues difficiles à trouver car le compilateur s'exécute juste dessus.

Une recherche rapide sur Google a donné ce résultat: http://xahlee.org/java-a-day/this.html

À peu près, le mot-clé "this" est une référence à l'objet courant (lui-même).

thisest une référence à l'objet actuel: http://download.oracle.com/javase/tutorial/java/javaOO/thiskey.html

cela peut être utilisé dans une méthode ou un constructeur.

Il renvoie la référence à l'objet courant.

Cela fait référence à l'objet dans lequel vous vous trouvez en ce moment. En d'autres termes, cela fait référence à l'objet récepteur. Vous l'utilisez pour clarifier à quelle variable vous faites référence. Page Java_whitepaper: 37

class Point extends Object
{
    public double x;
    public double y;

    Point()
    {
        x = 0.0;
        y = 0.0;
    }

    Point(double x, double y)
    {
        this.x = x;
        this.y = y;
    }
}

Dans l'exemple de code ci-dessus, this.x / this.y fait référence à la classe actuelle qui est des variables de classe Point x et y où (double x, double y) sont des valeurs doubles transmises par une classe différente pour affecter des valeurs à la classe actuelle.

J'étais également à la recherche de la même réponse et je ne pouvais pas comprendre clairement le concept. Mais finalement je l'ai compris à partir de ce lien

c'est un mot-clé en Java. Qui peut être utilisé dans une méthode ou un constructeur de classe. Cela fonctionne comme une référence à un objet courant dont la méthode ou le constructeur est appelé. ce mot clé peut être utilisé pour faire référence à n'importe quel membre de l'objet courant à partir d'une méthode d'instance ou d'un constructeur.

Consultez les exemples dans le lien pour une compréhension claire

Si les variables d'instance sont les mêmes que les variables déclarées dans le constructeur, nous utilisons "this" pour affecter des données.

class Example{
     int assign;// instance variable

     Example(int assign){ // variable inside constructor
          this.assign=assign;
     }
}

J'espère que cela t'aides.

En Java, "ceci" est une variable prédéfinie. Si nous utilisons "this" dans la méthode, cela signifie que nous obtenons la référence (adresse) de l'objet en cours d'exécution. À titre d'exemple.

this.age ---> âge de l'objet en cours d'exécution.

J'aimerais partager ce que j'ai compris de ce mot-clé. Ce mot-clé a 6 utilisations en java comme suit: -

1. Il peut être utilisé pour faire référence à la variable de classe actuelle. Comprenons avec un code. *

Comprenons le problème si nous n'utilisons pas ce mot-clé par l'exemple ci-dessous:

class Employee{  
int id_no;  
String name;  
float salary;  
Student(int id_no,String name,float salary){  
id_no = id_no;  
name=name;  
salary = salary;  
}  
void display(){System.out.println(id_no +" "+name+" "+ salary);}  
}  
class TestThis1{  
public static void main(String args[]){  
Employee s1=new Employee(111,"ankit",5000f);  
Employee s2=new Employee(112,"sumit",6000f);  
s1.display();  
s2.display();  
}}  

Production:-

0 null 0.0
0 null 0.0

Dans l'exemple ci-dessus, les paramètres (arguments formels) et les variables d'instance sont identiques. Nous utilisons donc ce mot-clé pour distinguer la variable locale et la variable d'instance.

class Employee{  
int id_no;  
String name;  
float salary;  
Student(int id_no,String name,float salary){  
this.id_no = id_no;  
this.name=name;  
this.salary = salary;  
}  
void display(){System.out.println(id_no +" "+name+" "+ salary);}  
}  
class TestThis1{  
public static void main(String args[]){  
Employee s1=new Employee(111,"ankit",5000f);  
Employee s2=new Employee(112,"sumit",6000f);  
s1.display();  
s2.display();  
}} 

production:

111 ankit 5000
112 sumit 6000

2. Pour appeler la méthode de classe actuelle.

class A{  
void m(){System.out.println("hello Mandy");}  
void n(){  
System.out.println("hello Natasha");  
//m();//same as this.m()  
this.m();  
}  
}  
class TestThis4{  
public static void main(String args[]){  
A a=new A();  
a.n();  
}}  

Production:

hello Natasha
hello Mandy

3. pour appeler le constructeur de classe actuel. Il est utilisé pour le chaînage des constructeurs.

class A{  
A(){System.out.println("hello ABCD");}  
A(int x){  
this();  
System.out.println(x);  
}  
}  
class TestThis5{  
public static void main(String args[]){  
A a=new A(10);  
}}

Production:

hello ABCD
10

4. à passer comme argument dans la méthode.

class S2{  
  void m(S2 obj){  
  System.out.println("The method is invoked");  
  }  
  void p(){  
  m(this);  
  }  
  public static void main(String args[]){  
  S2 s1 = new S2();  
  s1.p();  
  }  
}  

Production:

The method is invoked

5. passer en argument dans l'appel du constructeur

class B{  
  A4 obj;  
  B(A4 obj){  
    this.obj=obj;  
  }  
  void display(){  
    System.out.println(obj.data);//using data member of A4 class  
  }  
}  

class A4{  
  int data=10;  
  A4(){  
   B b=new B(this);  
   b.display();  
  }  
  public static void main(String args[]){  
   A4 a=new A4();  
  }  
} 

Production:-

10

6. pour renvoyer l'instance de classe actuelle

class A{  
A getA(){  
return this;  
}  
void msg(){System.out.println("Hello");}  
}  
class Test1{  
public static void main(String args[]){  
new A().getA().msg();  
}  
}  

Production:-

Hello

De plus, ce mot-clé ne peut pas être utilisé sans. (Point) car sa syntaxe n'est pas valide.