Quel est le style accepté pour utiliser le mot clé `this` en Java?

Je viens de langages comme Python ou Javascript (et d’autres moins orientés objet) et j’essaie d’améliorer ma connaissance pratique de Java, que je ne connais que de manière superficielle.

Est-il considéré comme une mauvaise pratique de toujours ajouter thisles attributs d'instance actuels? C'est plus naturel pour moi d'écrire

...
private String foo;

public void printFoo() {
    System.out.println(this.foo);
}
...

que

...
private String foo;

public void printFoo() {
    System.out.println(foo);
}
...

car cela m’aide à distinguer les attributs d’instance des variables locales.

Bien sûr, dans un langage comme Javascript, il est plus logique de toujours l'utiliser this, car on peut avoir plus d'imbrication de fonctions, d'où des variables locales provenant de domaines plus vastes. Pour autant que je sache, aucune imbrication de ce type n’est possible (à l’exception des classes internes), ce n’est donc probablement pas un gros problème.

En tout cas, je préférerais utiliser this. Vous sentiriez-vous bizarre et pas idiomatique?

Dans la plupart des IDE, vous pouvez simplement passer la souris sur la variable si vous voulez savoir. En outre, si vous utilisez une méthode d'instance, vous devez connaître toutes les variables impliquées. Si vous en avez trop, ou si leurs noms s’entrechoquent, vous devez alors refactoriser.

C'est vraiment assez redondant.

Je préfère utiliser this. Cela facilite la lecture du code dans différents éditeurs qui colorent les variables locales et les variables d'instance de la même manière. Cela facilite également la lecture du code sur une page imprimée pendant quelque chose comme une révision du code. C'est également un rappel assez fort de la portée de la variable pour les autres développeurs.

Cependant, il y a des arguments contre cela. Dans les IDE modernes, vous pouvez connaître la portée d'une variable en la survolant ou en la visualisant dans une structure arborescente. Vous pouvez également modifier la couleur et / ou la police des variables en fonction de leur portée (même de manière à ce que, une fois imprimé, la portée de la variable soit évidente).

Je crois que la dernière phrase de ChrisF est sans appel : soyez cohérent dans votre utilisation.

Un endroit où j'utilise systématiquement 'this' est les setters et / ou les constructeurs:

public void setFoo(String foo) {
    this.foo = foo;
}

À part cela, je ne pense pas qu'il soit nécessaire de l'ajouter. Lors de la lecture du corps d'une méthode, les paramètres et les paramètres locaux sont présents - et assez faciles à suivre (même sans l'aide de l'EDI). De plus, les sections locales et les champs ont tendance à être de nature différente (état d'objet, stockage transitoire ou paramètre).

S'il existe une confusion entre ce qui est une variable et ce qui est un champ, cela signifie probablement qu'une méthode a trop de variables / paramètres, est trop longue et trop complexe et doit être simplifiée.

Si vous choisissez d'utiliser 'ceci' pour baliser des champs, je vous conseillerais de vous assurer que la convention est toujours suivie à la lettre - il serait très facile de commencer en supposant que non 'cela' signifie qu'il s'agit d'un local et que les choses se cassent en se basant sur l'hypothèse.

edit: Je finis également par utiliser this dans equals, clone ou tout ce qui a un paramètre 'that' du même type d'objet:

public boolean isSame(MyClass that) {
    return this.uuid().equals(that.uuid());
}

C'est discutable.

En prenant C # comme une analogie car sa syntaxe et sa structure sont très similaires à celles de Java, nous constatons que C # StyleCop a une règle par défaut que vous souhaitez ajouter this, mais ReSharper a une règle par défaut qui dit que le thisest redondant (ce qui est) et peut être enlevé.

Donc, si vous utilisez un outil, vous les ajouterez mais si vous en utilisez un autre, vous les supprimerez. Si vous utilisez les deux outils, vous devrez choisir et désactiver l'une des règles.

Cependant, ce que les règles veulent dire, c'est que votre utilisation est cohérente - ce qui est probablement la chose la plus importante.

Est-il considéré comme une mauvaise pratique de toujours ajouter cela aux attributs d'instance actuels?

Oui - par certains, non - par d'autres.

J'aime et utilise des thismots-clés dans mes projets en Java et en C #. On peut affirmer que l'EDI mettra toujours en évidence les paramètres et les champs avec des couleurs différentes, mais que nous ne travaillons pas toujours dans l'EDI - nous devons faire beaucoup de fusions / différences / quelques modifications rapides dans un bloc-notes / vérifier des extraits de code dans un courrier électronique. . Il est beaucoup plus facile pour moi de repérer dès le premier coup d'œil où l'état de l'instance est modifié - par exemple, pour examiner certains problèmes de simultanéité possibles.

Je pense que si vous devez utiliser ceci, vous avez soit une méthode trop longue, soit une classe qui essaie de faire trop, ou les deux.

Les méthodes ne doivent jamais comporter plus de quelques lignes de code, utilisez une ou deux variables locales pour déterminer ce qui devient facile. même avec seulement le contexte de 3 lignes de la plupart des outils diff. Si vos méthodes sont trop longues et que vos classes ont trop de responsabilités (ce qui signifie souvent trop de champs), la solution consiste à les scinder.

Je pense que "ceci" encombre tout le code. Surtout avec les IDE modernes qui coloreront les paramètres locaux / variables locales / champs différemment.

Je pense que vous avez répondu à votre propre question avec ceci:

C'est plus naturel pour moi d'écrire

... ceci.foo ...

que

... foo ...

car cela m’aide à distinguer les attributs d’instance des variables locales.

Si vous êtes plus à l’aise pour utiliser this.tout en améliorant vos connaissances de l’utilisation de Java, utilisez-le bien ( je pense que c’est en quelque sorte le soi - même familier de Python auquel vous vous associez ).

Le fait est que, bien que les gens donnent des arguments solides / pertinents sur l’utilisation ou non this., cela ressemble toujours à un débat, exemple donné:

• cela clarifie le but des variables et vous devriez réécrire le code s'il n'est pas clair ce que chaque variable est;
• this.est redondant si vous passez toute la journée dans l'EDI, par opposition à une révision du code et des différences sur différentes versions à l'aide d'un comparateur sans mise en surbrillance de la syntaxe;
• le fait de ne pas taper this.me permet de gagner beaucoup de millisecondes de productivité par rapport au fait que je suis payé en appuyant sur la touche; l’ajout d’une touche this.revient à une augmentation de salaire: D;
• etc

Mais au bout du compte, en fin de compte, il reprend toujours ses préférences personnelles et son environnement de travail .

Normalement, ajouter ceci est inutile. Je ne pense pas que ce soit une mauvaise pratique en soi, mais une utilisation excessive de ce serait probablement considéré comme inhabituel dans la plupart des bases de code Java que je l' ai vu.

Cependant, je le trouve utile dans quelques situations spécifiques:

Remplacement de paramètres locaux - Il est parfois nécessaire d'indiquer que vous souhaitez utiliser une variable d'instance plutôt qu'un paramètre / une variable locale du même nom. C'est assez courant dans les constructeurs, où vous voulez que le nom du paramètre corresponde au nom interne de la variable d'instance qu'il est utilisé pour initialiser, par exemple

class MyObject {
  int value;

  public MyObject(int value) {
    this.value=value;
  }
}

Lorsque vous manipulez d'autres instances de la même classe , je pense que cela rend le code plus clair et plus compréhensible, car il est explicite de préciser à quelle instance de la classe vous vous référez, par exemple:

class MyObject {
  int value;
  ....

  public MyObject add(MyObject other) {
    return new MyObject( this.value + other.value )
  }
}