Quand devrais-je utiliser «this» dans une classe?

Je sais que this fait référence à un object actuel. Mais je ne sais pas quand je dois vraiment l’utiliser. Par exemple, y aura-t-il une différence si j’utilise x au lieu de this.x dans certaines des méthodes? Peut-être que x fera référence à une variable qui est locale pour la méthode considérée? Je veux dire la variable qui se voit seulement dans cette méthode.

Qu’en est-il de cette this.method() ? Puis-je l’utiliser? Devrais-je l’utiliser? Si j’utilise juste method() , ne sera-t-il pas, par défaut, appliqué à l’object actuel?

    Le mot-clé this est principalement utilisé dans trois situations. Le premier et le plus commun est dans les méthodes de définition des parameters pour désambiguïser les références de variables. La seconde est lorsqu’il est nécessaire de passer l’instance de classe actuelle en tant qu’argument à une méthode d’un autre object. Le troisième est un moyen d’appeler des constructeurs alternatifs à partir d’un constructeur.

    Cas 1: Utiliser this pour désambiguïser les références de variables. Dans les méthodes de configuration Java, nous transmettons généralement un argument portant le même nom que la variable de membre privé que nous tentons de définir. Nous this.x 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 Ssortingng name; public void setName(Ssortingng name) { this.name = name; } } 

    Cas 2: Utiliser this comme argument transmis à un autre object.

     public class Foo { public Ssortingng useBarMethod() { Bar theBar = new Bar(); return theBar.barMethod(this); } public Ssortingng getName() { return "Foo"; } } public class Bar { public void barMethod(Foo obj) { obj.getName(); } } 

    Cas 3: Utiliser this pour appeler des constructeurs alternatifs. Dans les commentaires, sortingnithis a correctement signalé une autre utilisation commune de this . Lorsque vous avez plusieurs constructeurs pour une seule classe, vous pouvez l’utiliser this(arg0, arg1, ...) pour appeler un autre constructeur de votre choix, à condition que vous le fassiez dans la première ligne de votre constructeur.

     class Foo { public Foo() { this("Some default value for bar"); //optional other lines } public Foo(Ssortingng bar) { // Do something with bar } } 

    J’ai également vu que this mettait l’accent sur le fait qu’une variable d’instance est en train d’être référencée (sans avoir besoin de désambiguïser), mais c’est un cas rare à mon avis.

    La deuxième utilisation importante de this (en plus de cacher avec une variable locale, comme le disent déjà de nombreuses réponses), consiste à accéder à une instance externe à partir d’une classe non statique nestede:

     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; } } } 

    Il vous suffit de l’utiliser – et la plupart des gens l’utilisent uniquement – 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 de l’utiliser est que cela fait apparaître intellisense dans les IDE 🙂

    Le seul besoin d’utiliser le this. qualifier est lorsqu’une autre variable de l’étendue actuelle partage le même nom et que vous souhaitez vous référer au membre d’instance (comme décrit William). En dehors de cela, il n’y a pas de différence de comportement entre x et this.x

    “this” est également utile pour appeler un constructeur d’un autre:

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

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

     public class User { private Ssortingng firstName; private Ssortingng surname; public User(Builder builder){ firstName = builder.firstName; surname = builder.surname; } public Ssortingng getFirstName(){ return firstName; } public Ssortingng getSurname(){ return surname; } public static class Builder { private Ssortingng firstName; private Ssortingng surname; public Builder setFirstName(Ssortingng firstName) { this.firstName = firstName; return this; } public Builder setSurname(Ssortingng surname) { this.surname = surname; return this; } public User build(){ return new User(this); } } public static void main(Ssortingng[] args) { User.Builder builder = new User.Builder(); User user = builder.setFirstName("John").setSurname("Doe").build(); } } 

    À moins que vous ayez des noms de variables qui se chevauchent, c’est vraiment juste pour plus de clarté lorsque vous lisez le code.

    Google a mis au point une page sur le site de Sun qui aborde ce sujet un peu.

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

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

    Cependant, je déteste vraiment cette convention. Donner deux variables différentes à des noms identiques est une recette pour les bogues. Je préfère de loin quelque chose du genre:

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

    Mêmes résultats, mais sans risque de bug où vous vous référez accidentellement à x lorsque vous voulez vraiment parler de x place.

    Pour l’utiliser avec une méthode, vous avez raison sur les effets; vous obtiendrez les mêmes résultats avec ou sans elle. Pouvez-vous l’utiliser? Sûr. Devriez-vous l’utiliser? A vous de voir, mais étant donné que je pense personnellement que ce n’est pas de la verbosité inutile (à moins que le code ne soit rempli de déclarations d’importation statiques), je ne suis pas enclin à l’utiliser moi-même.

    @William Brendel répond de manière agréable à trois cas d’utilisation différents.

    Cas d’utilisation 1:

    La page de documentation officielle Java à 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’object en cours – l’object dont la méthode ou le constructeur est appelé. Vous pouvez faire référence à n’importe quel membre de l’object actuel depuis une méthode d’instance ou un constructeur en utilisant ceci.

    Il couvre deux exemples:

    Utiliser ceci avec un champ et l’ utiliser avec un constructeur

    Cas d’utilisation 2:

    Autre cas d’utilisation qui n’a pas été cité dans cet article: this peut être utilisé pour synchroniser l’object actuel dans une application multithread afin de protéger la section critique des données et des méthodes.

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

    Cas d’utilisation 3:

    L’implémentation du modèle Builder dépend de son utilisation pour renvoyer l’object modifié.

    Reportez-vous à cet article

    Garder le constructeur en classe séparée (interface fluide)

    Il y a beaucoup de bonnes réponses, mais il y a une autre raison très mineure de mettre this partout. Si vous avez essayé d’ouvrir vos codes sources à partir d’un éditeur de texte normal (par exemple, un bloc-notes, etc.), this facilitera grandement la lecture.

    Imagine ça:

     public class Hello { private Ssortingng foo; // Some 10k lines of codes private Ssortingng getSsortingngFromSomewhere() { // .... } // More codes public class World { private Ssortingng bar; // Another 10k lines of codes public void doSomething() { // More codes foo = "FOO"; // More codes Ssortingng s = getSsortingngFromSomewhere(); // More codes bar = s; } } } 

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

    Vous aurez du mal à trouver où réside foo , jusqu’à ce que vous utilisiez la fonction “find” de l’éditeur. Ensuite, vous allez crier sur getSsortingngFromSomewhere() pour la même raison. Enfin, après avoir oublié ce que c’est, cette bar = s va vous donner le coup de grâce.

    Comparez cela à ceci:

     public void doSomething() { // More codes Hello.this.foo = "FOO"; // More codes Ssortingng s = Hello.this.getSsortingngFromSomewhere(); // More codes this.bar = s; } 
    1. Vous savez que foo est une variable déclarée dans la classe externe Hello .
    2. Vous savez que getSsortingngFromSomewhere() est également une méthode déclarée dans la classe externe.
    3. Vous savez que la bar appartient à World classe World et que s est 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, lors de la conception de votre API ou de votre projet, si vos règles incluent “si quelqu’un ouvre tous ces codes sources avec un bloc-notes, il doit se tirer une balle dans la tête”.

    quand il y a deux variables une variable d’instance et une autre variable locale du même nom, nous l’utilisons. pour renvoyer l’object en cours d’exécution afin d’éviter le conflit entre les noms.

    this est une référence à l’object actuel. Il est utilisé dans le constructeur pour distinguer la variable de classe locale et la variable courante qui portent le même nom. par exemple:

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

    this peut également être utilisé pour appeler un constructeur d’un autre constructeur. par exemple:

     public class circle { int x; circle() { this(1); } circle(int x) { this.x = x; } } 

    Voici les moyens d’utiliser le mot-clé ‘this’ dans java:

    1. Utilisation de this mot this clé pour renvoyer les variables d’instance de classe en cours
    2. Utiliser this() pour invoquer le constructeur de la classe en cours
    3. Utilisation de this mot this clé pour renvoyer l’instance de classe en cours
    4. Utilisation de this mot clé comme paramètre de méthode

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

    Y aura-t-il une différence si j’utilise “x” au lieu de “this.x” dans certaines des méthodes?

    Généralement pas. 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’object actuel?

    Oui. Mais si nécessaire, this.method() précise que l’appel est effectué par cet object.

    this n’affecte pas le code résultant – il s’agit d’un opérateur de compilation et le code généré avec ou sans ce sera le même. Lorsque vous devez l’utiliser, dépend du contexte. Par exemple, vous devez l’utiliser, comme vous l’avez dit, lorsque vous avez une variable locale pour laquelle la variable de classe d’ombres et vous voulez vous référer à la variable de classe et non à la variable locale.

    edit: par “le code résultant sera le même” je veux dire bien sûr, quand une variable dans la scope locale ne cache pas celle appartenant à la classe. Ainsi

     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 de dbconfessions , en ce qui concerne 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 objects. Cependant, veuillez noter que cela est simplifié par souci de concision.

    Pour vous assurer que les membres de l’object en cours sont utilisés. Les cas où la sécurité des threads est un problème, certaines applications peuvent modifier les valeurs des membres des objects incorrects. Pour cette raison, cela doit être appliqué au membre afin que la valeur de membre d’object correcte soit utilisée.

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