En Java, quelle est la différence entre ce.méthode() et la méthode()?

Quelle est la différence entre un appel this.method() et method() (y compris différence de performances)?

InformationsquelleAutor nebkat | 2011-07-01

59

Moment crucial, c'est que si vous utilisez OuterClass.this.method() par exemple
```
class OuterClass {
    void method() { }

    class InnerClass {
        void method() {
            OuterClass.this.method(); //not the same as method().
        }
    }
 }
```
- cependant, c'est le même que OuterClass.méthode() dans le cas où la méthode est statique
- Strictement parlant, à mon humble avis on ne peut pas comparer OuterClass.c'.méthode() avec la méthode (), puisque nous sommes tout juste en comparant laisser ou mettre ce." in/out.
- Merci pour l'éducation de cette spéciale à titre d'exemple, Pierre.
- Pourquoi InnerClass est déclarée avec avec des parenthèses ()?
- Mon intégrée dans le compilateur a été brisé. 😉 Merci à vous.
InformationsquelleAutor Peter Lawrey
27

Il n'y a absolument aucune différence entre ces constructions et le bytecode généré sera exactement le même, par conséquent, aucun impact sur les performances. this est résolu lors de la compilation si pas explicitement défini.

La seule raison de l'utilisation explicite this est la lisibilité - certaines personnes trouvent plus facile à lire parce que this suggère que c'est une méthode d'instance de l'objet courant.

Veuillez également noter que si method() est statique, à l'aide de this est découragé et trompeuse.
```
private static void method() {
}

private void foo() {
    this.method();    //generates warning in my IDE for a reason
}
```
Et dans ce cas, il sera également sans effet sur les performances.
- Si la méthode est statique, il n'est pas correct. Mon compilateur me direz qu'il n'y a pas de pointeur "this" pour une méthode statique.
- J'ai précisé ce que je voulais dire à propos de static méthodes.
- Merci, Tomasz. Pas vers le bas de votes de moi; votre clarification est parfait.
- Il y a quelques raisons de lisibilité impliqués, oui, mais qui doit également être pris par la coloration syntaxique. Pour moi, c'est devenu un peu un (mauvais?) habitude de taper cette. est plus rapide / plus à l'aise que les touches ctrl+espace.
InformationsquelleAutor Tomasz Nurkiewicz

Qu'il n'y a pas de différence, peut être vu en appelant javap -c ClassName sur la ligne de commande.
Par exemple:

public class This {
    private void method() {
    }
    public void noThis() {
        method();
    }
    public void useThis() {
        this.method();
    }
}

Produit est le suivant démonté de sortie:

Compiled from "This.java"
public class This extends java.lang.Object{
public This();
  Code:
   0:   aload_0
   1:   invokespecial   #1; //Method java/lang/Object."<init>":()V
   4:   return

public void noThis();
  Code:
   0:   aload_0
   1:   invokespecial   #2; //Method method:()V
   4:   return

public void useThis();
  Code:
   0:   aload_0
   1:   invokespecial   #2; //Method method:()V
   4:   return

}

La seule différence est probablement ces quelques microsecondes au moment de la compilation quand il les chiffres de l'implicite this.

InformationsquelleAutor Atreys

Pour les méthodes il n'y a pas de différence, mais il peut faire une différence avec les champs. Considérer ce code:

private String someObject = "some value";

public String someMethod(String someObject) {
     //this.someObject refers to the field while
     //someObject refers to the parameter
}

InformationsquelleAutor Chris Knight

2

Il n'y a pas de différence réelle - Au moins il n'y a pas d'impact sur les performances. Je préfère ne pas écrire "ce" - L'IDE peut généralement de mettre en évidence les appels à cela de toute façon, et je pense que c'est moins lisible lors de chaque accès à des méthodes/champs/... commencer par "ce.". Mais c'est vraiment une question de préférence personnelle.

InformationsquelleAutor David Tanzer
2

Il n'y a pas de différence à tous les autres de la lisibilité. Il le rend plus claire pour le lecteur.
- La lisibilité est dans l'œil de celui qui regarde: je le trouve plus bruyant car les informations de this est redondant, car il est implicite. Il pourrait aider les débutants, c'est ennuyeux pour la plupart) plus de codeurs expérimentés.
InformationsquelleAutor javanerd
2

Utilisation this.method() et/ou this.myVar ou de ne pas les méthodes il n'y a pas de différence, sur vars il y a peut-être - mais être conformes à ce sujet. Je le vois disséminés un peu partout dans le code, il m'arrive de voir this.m_myClassVar.

Personnellement, je préfère le préfixe ma classe à vars avec un simple trait de soulignement et de mettre une fin trait de soulignement sur ma méthode args:
```
public MyClass
{
    private int _myInt;

    public void myMethod(final int myInt_, final int fooFactor_)
    {
        _myInt = myInt_ * fooFactor_;
    }
}
```
Bien que la plupart des IDEs permettra de savoir qui est qui, je trouve, ce qui tend à empêcher misassignment et rend les intentions du code plus clair et de l'OMI, plus facile à lire.

Je ne l'utilisation de _thisInstance.myMethod() (où _thisInstance est une référence à l'extérieur de la classe) ou _thisInstance._myVar, dans les classes internes/auditeurs/threads/etc. où j'ai besoin d'être clair sur ce que la méthode de la classe je suis d'appel et/ou lorsque j'ai besoin d'avoir une référence à une instance de classe.
- L'utilisation des caractères de soulignement dans les noms de variable va à l'encontre des conventions de nommage Java pour les non-variables constantes.
InformationsquelleAutor Developer Dude
1

L'utilisation de ce.méthode() indique clairement qu'une fonction associée à l'instance de la classe est appelée, par opposition à une fonction statique ou de l'un appartenant à un autre objet.

C'est dans l'esprit de ces développeurs en C++ qui aiment faire précéder de "m_" sur toutes les variables de membre dans une classe. Il rend la propriété sans ambiguïté. J'ai tendance à l'aimer, mais ce n'est pas aussi important lorsque vous utilisez un IDE qui clarifie les choses telles utilisant des couleurs et des polices.
- "l'un appartenant à un autre objet" eh Bien, il est nécessairement précédé par l'autre objet, non? "par opposition à une fonction statique" Est une distinction importante?
InformationsquelleAutor duffymo
-3

Avez-vous essayé de le faire.variable dans le constructeur?

En théorie, en C++, car l'objet n'a pas encore été créé il n'est pas de cela. Je ne suis pas sûr de le cas en Java.
- Fonctionne en Java, car this.foo = foo; est un schéma très commun à l'initialisation des champs (variables membres) à partir de paramètres de même nom.
InformationsquelleAutor Phil

Vous devez vous connecter pour publier un commentaire.