Quelle est la signification de" ceci " en Java?

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 ceci:

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 {[4] } affichera

1
42
MyThisTest a=42

Si efficacement que vous l'utilisez pour plusieurs choses:

• préciser 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
• invoquer d'autres constructeurs du courant classe dans votre constructeur

Ce qui suit est un copier-coller de ici , mais explique très bien toutes les différentes utilisations du mot-clé this:

Définition: Le mot-clé this de 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 de la variable statique ou locale. C'est-à-dire,

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

   Ici, cela fait référence à l'instance variable. Ici, la priorité est élevée pour la variable locale. Par conséquent, l'absence de this dé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, alors indépendamment de this est utilisé ou non, il désigne la variable d'instance.

2. This est utilisé pour désigner 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 transmettre le instance java actuelle en tant que 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 lorsqu'il est utilisé 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 descripteur de la classe actuelle

   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, this est associé à son instance et cela ne fonctionnera pas dans les méthodes statiques.

Pour être complet, this peut également être utilisé pour faire référence à l'objet externe

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 this est d'empêcher l'observation. 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 en utilisant la valeur du paramètre. Comme ils partagent le même nom, nous avons besoin d'un moyen de faire la distinction entre le champ et le paramètre. this nous permet d'accéder aux membres de cette instance, y compris le terrain.

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 ActionListener et d'ajouter 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!");
    }

}

Si vous appelez myObject.method(), puis this renverra à myObject dans method.

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

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

System.out.println(this);

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

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 mot réservé this 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 oeil à l'appel fillTank pour l'objet audi.

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 méthode fillTank a à la fois un paramètre explicite et un paramètre implicite.

Examinons de plus près la méthode fillTank dans la classe Car

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 pourrait y avoir beaucoup d'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 plus tôt, nous utilisons le mot-clé this réservé. pour les variables d'instance l'utilisation de "ceci" dans un méthode indique que la variable d'instance, dans notre cas "réservoir", est variable d'instance du paramètre implicite.

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

En résumé.

• Les objets sont définis par classes et avoir des méthodes et des variables
• L'utilisation de this sur variable d'instance de dans a méthode indique que la variable d'instance appartient au paramètre implicite, ou que c'est 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és sans un point(.) ceci est syntaxiquement invalide
• this peut également être utilisé pour distinguer entre les variables locales et les variables globales qui ont le même nom
• le mot de réserve this s'applique également aux méthodes, pour indiquer qu'une méthode appartient à un objet particulier.

this est une référence à l'objet courant: 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.

Lece mot-clé est utilisé pour référencer la variable actuelle d'un bloc, par exemple considérons le code ci-dessous (juste un exampple, donc 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'utilisons pas le mot-clé this , alors la sortie sera: 0

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).

Je cherchais aussi la même réponse, et je ne pouvais pas comprendre le concept clairement. Mais finalement je l'ai compris à partir de ce lien

Ceci est un mot-clé en Java. Qui peut être utilisé à l'intérieur de la méthode ou du constructeur de la classe. Il (ceci) fonctionne comme une référence à un objet courant dont la méthode ou le constructeur est invoqué. ce mot-clé peut être utilisé pour désigner un membre de l'objet courant à l'intérieur d'une méthode d'instance ou un constructeur.

Vérifiez les exemples dans le lien pour une compréhension claire

Si les variables d'instance sont identiques aux variables déclarées dans le constructeur, nous utilisons "this" pour attribuer des données.

class Example{
     int assign;// instance variable

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

J'espère que cela aide.

En Java, "this" 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. Pour un exemple.

Ceci.age - - - > age de l'objet en cours d'exécution.

Les variables d'instance sont communes à tous les objets que vous créez. disons qu'il existe 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 lancé trois objets et trois objets appellent la méthode SetMyInstanceValues. Comment pensez-vous que JVM affecte correctement les valeurs pour chaque objet? il y a l'astuce, JVM ne verra pas ce code comment 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 boi sournois que vous ne m'avez jamais vu)

Le ce mot-clé dans la plupart des langages de programmation orientés objet, sinon tous, signifie que c'est 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 de l'extérieur de la méthode par son nom. Cela n'avait probablement aucun sens si mal élaboré:

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

object.field

Disons par exemple que vous essayez d'accéder à l'objet .champ de l'intérieur de votre classe dans disons, votre constructeur par exemple, vous pouvez utiliser

this.field

Le ce mot-clé remplace essentiellement le mot-clé object name 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 de si vous avez deux variables du même nom l'une de qui étant un champ de la classe et l'autre étant juste une variable à l'intérieur d'une méthode, il aide à déchiffrer entre les deux. Par exemple si vous avez ceci: (Ah, l'obtenir? ce? Hehe .... juste moi? ok: (Je pars maintenant)

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

Cela causerait 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, il assignerait donc à la place le Nom de paramètre.... 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 la plupart des nouveaux programmes font et 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'assigne correctement, ce qui signifie qu'il assigne 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 object de la classe sur laquelle vous travaillez, d'où le mot-clé "this", ce qui signifie son thisobject, ou this instance. C'est une bonne pratique d'utiliser cela 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 au-dessus d'eux.