Quand dois-je utiliser «ceci» dans une classe?

Je sais que cela thisfait référence à un objet actuel. Mais je ne sais pas quand j'ai vraiment besoin de l'utiliser. Par exemple, y aura-t-il une différence si j'utilise à la xplace de this.xcertaines méthodes? Peut être xfera référence à une variable qui est locale pour la méthode considérée? Je veux dire variable qui n'est vue que dans cette méthode.

Et alors this.method()? Puis-je l'utiliser? Dois-je l'utiliser. Si je l'utilise method(), ne sera-t-il pas, par défaut, appliqué à l'objet courant?

Le thismot-clé est principalement utilisé dans trois situations. Le premier et le plus courant est dans les méthodes de définition pour lever l'ambiguïté des références de variables. La seconde est quand il est nécessaire de passer l'instance de classe actuelle comme argument à une méthode d'un autre objet. Le troisième est comme un moyen d'appeler des constructeurs alternatifs à partir d'un constructeur.

Cas 1: Utilisation thispour lever l'ambiguïté des références de variable. Dans les méthodes de définition de Java, nous transmettons généralement un argument avec le même nom que la variable de membre privé que nous tentons de définir. Nous attribuons ensuite l'argument xà this.x. Cela indique clairement que vous affectez la valeur du paramètre "nom" à la variable d'instance "nom".

public class Foo
{
    private String name;

    public void setName(String name) {
        this.name = name;
    }
}

Cas 2: utilisation thiscomme argument passé à un autre objet.

public class Foo
{
    public String useBarMethod() {
        Bar theBar = new Bar();
        return theBar.barMethod(this);
    }

    public String getName() {
        return "Foo";
    }
}

public class Bar
{
    public void barMethod(Foo obj) {
        obj.getName();
    }
}

Cas 3: Utilisation thispour appeler des constructeurs alternatifs. Dans les commentaires, trinithis a correctement signalé une autre utilisation courante de this. Lorsque vous avez plusieurs constructeurs pour une même classe, vous pouvez utiliser this(arg0, arg1, ...)pour appeler un autre constructeur de votre choix, à condition de le faire dans la première ligne de votre constructeur.

class Foo
{
    public Foo() {
        this("Some default value for bar");

        //optional other lines
    }

    public Foo(String bar) {
        // Do something with bar
    }
}

J'ai également vu thisutilisé pour souligner le fait qu'une variable d'instance est référencée (sans la nécessité de la désambiguïsation), mais c'est un cas rare à mon avis.

La deuxième utilisation importante de this(en plus de se cacher avec une variable locale comme de nombreuses réponses le disent déjà) est lors de l'accès à une instance externe à partir d'une classe non statique imbriquée:

public class Outer {
  protected int a;

  public class Inner {
    protected int a;

    public int foo(){
      return Outer.this.a;
    }

    public Outer getOuter(){
      return Outer.this;
    }
  }
}

Vous n'avez besoin d'utiliser this- et la plupart des gens ne l'utilisent - que lorsqu'il existe une variable locale qui se chevauche avec le même nom. (Méthodes Setter, par exemple.)

Bien sûr, une autre bonne raison d'utiliser thisest qu'elle fait apparaître intellisense dans les IDE :)

Le seul besoin d'utiliser le this.qualificatif est lorsqu'une autre variable dans la portée actuelle partage le même nom et que vous souhaitez faire référence au membre d'instance (comme William le décrit). En dehors de cela, il n'y a pas de différence de comportement entre xet this.x.

"this" est également utile lors de l'appel d'un constructeur à partir d'un autre:

public class MyClass {
    public MyClass(String foo) {
        this(foo, null);
    }
    public MyClass(String foo, String bar) {
        ...
    }
}

this est utile dans le modèle de générateur.

public class User {

    private String firstName;
    private String surname;

    public User(Builder builder){
        firstName = builder.firstName;
        surname = builder.surname;
    }

    public String getFirstName(){
        return firstName;
    }

    public String getSurname(){
        return surname;
    }

    public static class Builder {
        private String firstName;
        private String surname;

        public Builder setFirstName(String firstName) {
            this.firstName = firstName;
            return this;
        }

        public Builder setSurname(String surname) {
            this.surname = surname;
            return this;
        }

        public User build(){
            return new User(this);
        }

    }

    public static void main(String[] args) {
        User.Builder builder = new User.Builder();
        User user = builder.setFirstName("John").setSurname("Doe").build();
    }

}

Il y a beaucoup de bonnes réponses, mais il y a une autre raison très mineure à mettre thispartout. Si vous avez essayé d'ouvrir vos codes source à partir d'un éditeur de texte normal (par exemple le bloc-notes, etc.), l'utilisation thisle rendra beaucoup plus clair à lire.

Imagine ça:

public class Hello {
    private String foo;

    // Some 10k lines of codes

    private String getStringFromSomewhere() {
        // ....
    }

    // More codes

    public class World {
        private String bar;

        // Another 10k lines of codes

        public void doSomething() {
            // More codes
            foo = "FOO";
            // More codes
            String s = getStringFromSomewhere();
            // More codes
            bar = s;
        }
    }
}

C'est très clair à lire avec n'importe quel IDE moderne, mais ce sera un cauchemar total à lire avec un éditeur de texte normal.

Vous aurez du mal à savoir où fooréside, jusqu'à ce que vous utilisez la fonction "trouver" de l'éditeur. Ensuite, vous crierez getStringFromSomewhere()pour la même raison. Enfin, après avoir oublié ce qui sest, cela bar = sva vous donner le coup de grâce.

Comparez-le à ceci:

public void doSomething() {
    // More codes
    Hello.this.foo = "FOO";
    // More codes
    String s = Hello.this.getStringFromSomewhere();
    // More codes
    this.bar = s;
}

1. Vous savez, fooc'est une variable déclarée dans la classe externe Hello.
2. Vous savez, getStringFromSomewhere()c'est aussi une méthode déclarée dans la classe externe.
3. Vous savez que cela barappartient à la Worldclasse et qu'il ss'agit d'une variable locale déclarée dans cette méthode.

Bien sûr, chaque fois que vous concevez quelque chose, vous créez des règles. Ainsi , alors que la conception de votre API ou d'un projet, si vos règles sont « si quelqu'un ouvre tous ces codes sources avec un bloc - notes, il doit lui tirer dessus / elle - même dans la tête » , alors vous êtes tout à fait bien de ne pas faire cela .

Sauf si vous avez des noms de variables qui se chevauchent, c'est vraiment juste pour plus de clarté lorsque vous lisez le code.

La réponse de @William Brendel a fourni trois cas d'utilisation différents de manière agréable.

Cas d'utilisation 1:

La page de documentation Java officielle à ce sujet fournit les mêmes cas d'utilisation.

Dans une méthode d'instance ou un constructeur, il s'agit d'une référence à l'objet actuel - l'objet dont la méthode ou le constructeur est appelé. Vous pouvez faire référence à n'importe quel membre de l'objet actuel à partir d'une méthode d'instance ou d'un constructeur en utilisant ceci.

Il couvre deux exemples:

Utiliser ceci avec un champ et utiliser ceci avec un constructeur

Cas d'utilisation 2:

Autre cas d'utilisation qui n'a pas été cité dans cet article: thispeut être utilisé pour synchroniser l'objet actuel dans une application multithread pour protéger une section critique des données et méthodes.

synchronized(this){
    // Do some thing. 
}

Cas d'utilisation 3:

L'implémentation du modèle Builder dépend de l'utilisation de thispour renvoyer l'objet modifié.

Se référer à ce post

Garder le constructeur dans une classe distincte (interface fluide)

Google a publié une page sur le site Sun qui en parle un peu.

Vous avez raison sur la variable; thispeut en effet être utilisé pour différencier une variable de méthode d'un champ de classe.

    private int x;
    public void setX(int x) {
        this.x=x;
    }

Cependant, je déteste vraiment cette convention. Donner deux variables différentes des noms littéralement identiques est une recette pour les bugs. Je préfère de beaucoup quelque chose comme:

    private int x;
    public void setX(int newX) {
        x=newX;
    }

Mêmes résultats, mais sans risque de bogue xauquel vous faites référence accidentellement alors que vous vouliez vraiment faire référence à la xplace.

Quant à son utilisation avec une méthode, vous avez raison sur les effets; vous obtiendrez les mêmes résultats avec ou sans. Pouvez-vous l'utiliser? Sûr. Devriez-vous l'utiliser? À vous de voir, mais étant donné que je pense personnellement que c'est une verbosité inutile qui n'ajoute aucune clarté (à moins que le code ne soit rempli de déclarations d'importation statiques), je ne suis pas enclin à l'utiliser moi-même.

Voici les façons d'utiliser «ce» mot-clé en java:

1. En utilisant this mot clé pour référencer les variables d'instance de classe actuelles
2. Utilisation this()pour appeler le constructeur de classe actuel
3. Utilisation d'un thismot clé pour renvoyer l'instance de classe actuelle
4. Utilisation du thismot clé comme paramètre de méthode

https://docs.oracle.com/javase/tutorial/java/javaOO/thiskey.html

lorsqu'il y a deux variables, une variable d'instance et une autre variable locale du même nom, nous l'utilisons. pour référencer l'objet en cours d'exécution afin d'éviter le conflit entre les noms.

thisest une référence à l'objet courant. Il est utilisé dans le constructeur pour faire la distinction entre la variable de classe locale et la classe courante qui porte le même nom. par exemple:

public class circle {
    int x;
    circle(int x){
        this.x =x;
        //class variable =local variable 
    }
} 

thispeut également être utilisé pour appeler un constructeur à partir d'un autre constructeur. par exemple:

public class circle {
    int x;

    circle() { 
        this(1);
    }

    circle(int x) {
        this.x = x; 
    }
}

Y aura-t-il une différence si j'utilise "x" au lieu de "this.x" dans certaines méthodes?

Généralement non. Mais cela fait parfois une différence:

  class A {
     private int i;
     public A(int i) {
        this.i = i; // this.i can be used to disambiguate the i being referred to
     }
  }

Si j'utilise simplement "method ()", ne sera-t-il pas, par défaut, appliqué à l'objet courant?

Oui. Mais si nécessaire, this.method()clarifie que l'appel est fait par cet objet.

thisn'affecte pas le code résultant - c'est l'opérateur de temps de compilation et le code généré avec ou sans sera le même. Lorsque vous devez l'utiliser, cela dépend du contexte. Par exemple, vous devez l'utiliser, comme vous l'avez dit, lorsque vous avez une variable locale qui masque la variable de classe et que vous voulez faire référence à une variable de classe et non à une variable locale.

edit: par "le code résultant sera le même" je veux dire bien sûr, quand une variable de portée locale ne cache pas celle appartenant à la classe. Donc

class POJO {
   protected int i;

   public void modify() {
      i = 9;
   }

   public void thisModify() {
      this.i = 9;
   }
}

le code résultant des deux méthodes sera le même. La différence sera si une méthode déclare une variable locale avec le même nom

  public void m() {
      int i;
      i = 9;  // i refers to variable in method's scope
      this.i = 9; // i refers to class variable
  }

En ce qui concerne les messages de William Brendel et la question dbconfessions , concernant le cas 2 . Voici un exemple:

public class Window {

  private Window parent;

  public Window (Window parent) {
    this.parent = parent;
  }

  public void addSubWindow() {
    Window child = new Window(this);
    list.add(child);
  }

  public void printInfo() {
    if (parent == null) {
      System.out.println("root");
    } else {
      System.out.println("child");
    }
  }

}

J'ai vu cela utilisé lors de la construction de relations parent-enfant avec des objets. Cependant, veuillez noter qu'il est simplifié par souci de concision.

«Ce» mot-clé en java est utilisé pour référencer les objets de classe actuels.

Il y a 6 utilisations du mot-clé «this» en java

1. Accès à la variable de niveau classe : principalement utilisé si la variable de niveau local et de classe est la même
2. Accès aux méthodes de classe : c'est le comportement par défaut et peut être ignoré
3. Pour appeler un autre constructeur de la même classe
4. Utiliser le mot clé 'this' comme valeur de retour : pour renvoyer l'instance actuelle de la méthode
5. Passer le mot-clé 'this' comme argument à la méthode Passer: pour passer l'instance de classe actuelle comme argument
6. ce mot-clé comme argument au constructeur : pour passer l'instance de classe actuelle comme argument

réf: https://stacktraceguru.com/java/this-keyword-in-java

Pour vous assurer que les membres de l'objet actuel sont utilisés. Dans les cas où la sécurité des threads est un problème, certaines applications peuvent modifier les valeurs de membre d'objets incorrectes, c'est pourquoi cela doit être appliqué au membre afin que la valeur de membre d'objet correcte soit utilisée.

Si votre objet n'est pas concerné par la sécurité des threads, il n'y a aucune raison de spécifier quelle valeur de membre d'objet est utilisée.