«This» peut-il jamais être nul en Java?

J'ai vu cette ligne dans une méthode de classe et ma première réaction a été de ridiculiser le développeur qui l'a écrite. Mais ensuite, j'ai pensé que je devais m'assurer que j'avais raison en premier.

public void dataViewActivated(DataViewEvent e) {
    if (this != null)
        // Do some work
}

Cette ligne sera-t-elle jamais évaluée comme fausse?

Non, ça ne peut pas. Si vous utilisez this, vous êtes dans l'instance et thisn'est donc pas nul.

Le JLS dit:

Lorsqu'il est utilisé comme expression principale, le mot-clé this désigne une valeur qui est une référence à l'objet pour lequel la méthode d'instance a été appelée (§15.12), ou à l'objet en cours de construction.

Si vous avez appelé une méthode à partir d'un objet, alors l'objet existe ou vous auriez un NullPointerExceptionavant (ou c'est une méthode statique mais alors, vous ne pouvez pas l'utiliser this).

Ressources :

• JLS - thismot - clé

C'est comme vous demander "Suis-je vivant?" thisne peut jamais être nul

Non jamais , le mot-clé 'this' lui-même représente l'instance (objet) active actuelle de cette classe dans la portée de cette classe, avec laquelle vous pouvez accéder à tous ses champs et membres (y compris les constructeurs) et à ceux visibles de sa classe parente.

Et, plus intéressant encore, essayez de le configurer:

this = null;

Pensez-y? Comment est-ce possible, n'est-ce pas comme couper la branche sur laquelle vous êtes assis? Puisque le mot-clé «ceci» est disponible dans la portée de la classe donc dès que vous dites this = null; n'importe où dans la classe, vous demandez en gros à JVM de libérer la mémoire affectée à cet objet au milieu d'une opération que JVM ne peut tout simplement pas permettre car elle doit revenir en toute sécurité après avoir terminé cette opération.

De plus, toute tentative this = null;entraînera une erreur du compilateur. La raison est assez simple, un mot-clé en Java (ou dans n'importe quel langage) ne peut jamais recevoir de valeur, c'est-à-dire qu'un mot-clé ne peut jamais être la valeur de gauche d'une opération d'affectation.

Autres exemples, vous ne pouvez pas dire:

true = new Boolean(true);
true = false;

Si vous compilez avec -target 1.3ou une version antérieure, un externe this peut être null. Ou du moins, c'était le cas ...

Non. Pour appeler une méthode d'une instance d'une classe, l'instance doit exister. L'instance est implicitement transmise en tant que paramètre à la méthode, référencée par this. Si thisc'était le cas , nullil n'y aurait pas eu d'instance pour appeler une méthode.

Il ne suffit pas que la langue l'applique. La VM doit l'appliquer. À moins que la machine virtuelle ne l'applique, vous pouvez écrire un compilateur qui n'applique pas la vérification de null avant d'appeler la méthode écrite en Java. Les opcodes pour un appel de méthode d'instance incluent le chargement de cette référence dans la pile, voir: http://java.sun.com/docs/books/jvms/second_edition/html/Compiling.doc.html#14787 . Substituer ceci à une référence nulle entraînerait en effet un test faux

Dans les méthodes de classe statique, thisn'est pas défini car thisest associé à des instances et non à des classes. Je crois que cela donnerait une erreur du compilateur pour essayer d'utiliser un thismot-clé dans un contexte statique.

Une normale thisne peut jamais être nulldans le vrai code Java ¹ , et votre exemple utilise une normale this. Voir les autres réponses pour plus de détails.

Un qualifié ne this devrait jamais l'être null, mais il est possible de briser cela. Considérer ce qui suit:

public class Outer {
   public Outer() {}

   public class Inner {
       public Inner() {}

       public String toString() {
           return "outer is " + Outer.this;  // Qualified this!!
       }
   }
}

Lorsque nous voulons créer une instance de Inner, nous devons le faire:

public static void main(String[] args) {
    Outer outer = new Outer();
    Inner inner = outer.new Inner();
    System.out.println(inner);

    outer = null;
    inner = outer.new Inner();  // FAIL ... throws an NPE
}

La sortie est:

outer is Outer@2a139a55
Exception in thread "main" java.lang.NullPointerException
        at Outer.main(Outer.java:19)

montrant que notre tentative de créer un Inneravec une nullréférence à son Outera échoué.

En fait, si vous vous en tenez à l'enveloppe "Pure Java", vous ne pouvez pas le casser.

Cependant, chaque Innerinstance a un finalchamp synthétique masqué (appelé "this$0") qui contient la référence au Outer. Si vous êtes vraiment délicat, il est possible d'utiliser des moyens "non purs" pour attribuer nullau champ.

• Vous pourriez utiliser Unsafepour le faire.
• Vous pouvez utiliser du code natif (par exemple JNI) pour le faire.
• Vous pouvez le faire en utilisant la réflexion.

Quoi qu'il en soit, le résultat final est que l' Outer.thisexpression sera évaluée à null² .

Bref, il est possible qu'un qualifié thissoit null. Mais c'est impossible si votre programme suit les règles "Pure Java".

^{1 - J'écarte des astuces telles que "écrire" les bytecodes à la main et les faire passer pour de vrais Java, peaufiner les bytecodes en utilisant BCEL ou similaire, ou sauter dans le code natif et faire des emplettes avec les registres sauvegardés. IMO, ce n'est PAS Java. Hypothétiquement, de telles choses peuvent également se produire à la suite d'un bogue JVM ... mais je ne me souviens pas de tous les rapports de bogues.}

^{2 - En fait, le JLS ne dit pas quel sera le comportement, et cela pourrait dépendre de l'implémentation ... entre autres.}

Lorsque vous appelez une méthode sur nullréférence, le NullPointerExceptionsera renvoyé à partir de Java VM. C'est par spécification, donc si votre machine virtuelle Java est strictement conforme à la spécification, thiscela ne le sera jamais null.

Si la méthode est statique, il n'y en a pas this. Si la méthode est virtuelle, elle thisne peut pas être nulle, car pour appeler la méthode, le moteur d'exécution devra référencer la vtable à l'aide du thispointeur. Si la méthode n'est pas virtuelle alors, oui, il est possible qu'elle thissoit nulle.

C # et C ++ autorisent les méthodes non virtuelles, mais en Java, toutes les méthodes non statiques sont virtuelles et thisne seront donc jamais nulles.

tl; dr, "this" ne peut être appelé qu'à partir d'une méthode non statique et nous savons tous qu'une méthode non statique est appelée à partir d'une sorte d'objet qui ne peut pas être null.