Explication détaillée du mot-clé Java this (disposition des nœuds de puissance)

Ceci en Java peut être vu partout et a de nombreuses utilisations. Dans des circonstances normales, il est très facile de comprendre ce mot-clé. Cependant, lorsque j'ai commencé à apprendre, j'avais une question que je ne pouvais pas comprendre clairement. Maintenant, je la comprends lentement, je vais l'enregistrer pour tout le monde à travers cet article pour référence. amis dans le besoin. Suivant

Lorsque nous utilisons habituellement le mot-clé this en Java, nous savons tous que cela représente l'instance actuelle de la méthode de cette classe qui est appelée. Dans des circonstances normales, il est facile de comprendre ce mot-clé, mais lorsque j'ai commencé à apprendre, j'avais une question que je ne comprenais pas clairement. Maintenant que je la comprends lentement, je veux l'écrire. Peut-être que quelqu'un a le même problème. comme moi. Des questions, peut-être que ça peut aider les autres. Examinons d’abord brièvement son rôle dans des circonstances normales. Par exemple, le code suivant :

public class Leaf {
 private int i = 0;
 Leaf increment() {
  i++;
  return this;
 }
 void print() {
  System.out.println("i = " + i);
 }
 public static void main(String[] args) {
  Leaf x = new Leaf();
  x.increment().increment().print();
 }
}

Dans la méthode principale de la classe Leaf, nous créons une nouvelle instance Leaf x, puis l'instance x appelle la méthode increment(). Si incrément() est une méthode normale ou une méthode vide, il n'y a rien qui mérite d'être étudié ici. Ce qui est spécial c'est que dans la méthode increment(), ce qu'on retourne c'est ceci, et ceci représente le x qu'on vient de créer. Parce que x appelle la méthode incrément(), la méthode increment() représente évidemment l'instance x de Leaf.

Il semble n'y avoir rien à discuter, cela représente l'instance x qui appelle cette méthode. Cependant, si nous modifions la fonction main() pour qu'elle ressemble à ce qui suit

public static void main(String[] args) {
 Leaf x = new Leaf();
 x.increment().increment().print();
  
 Leaf y = new Leaf();
 y.increment().increment().print();
}

Dans le code modifié ci-dessus, nous créons une nouvelle instance Leaf y, puis y est également appelé en continu. incrément() deux fois. Maintenant, la question est : si x et y appellent la méthode incrément() en même temps, alors qui cela peut-il représenter ? Vous pensez peut-être qu'il y a quelque chose qui ne va pas. Lorsque x appelle la méthode incrément(), cela représente x. Lorsque y appelle la méthode incrément(), cela représente y. Mais le problème est que lorsque nous parlons d'appeler des méthodes, au niveau jvm, nous trouvons l'adresse mémoire où se trouve la méthode increment() dans la classe Leaf, puis créons un cadre de pile dans la pile de la machine virtuelle Java
.

Exécutez ensuite le code à l'intérieur de la méthode dans le cadre de pile. Maintenant, vous voyez, c'est-à-dire qu'au niveau de la méthode d'exécution jvm, il n'y a pas ce qu'on appelle l'appel x, y est appelé, alors, comment cela dans la méthode détermine-t-il à quelle instance il pointe ?

Jetons un coup d'œil à la façon dont il est affiché dans le bytecode de la classe Leaf. Avons-nous manqué quelque chose si nous ne transmettons pas l'instance x ou l'instance y dans la méthode, alors exécutez la méthode dans le jvm, il est impossible de savoir à quel cas cela renvoie spécifiquement.

À ce stade, nous voyons que dans la méthode increment(), il n'y a aucun paramètre dans l'encodage, mais le nombre de paramètres dans le bytecode s'avère être 1. Si nous y réfléchissons Attention, le résultat est déjà évident. : Lorsque JVM effectue une compilation, dans la méthode d'instance, un paramètre sera passé masqué par défaut. Ce paramètre est l'instance actuellement appelée elle-même. Par exemple, si x est appelé, x sera transmis lorsqu'il est masqué, et si y est appelé, y sera transmis. Par conséquent, notre this peut déterminer vers qui il pointe au niveau de la méthode d’exécution jvm.

La conclusion ci-dessus est notre propre inférence. Existe-t-il un livre qui décrit cela en détail ? Dans "javaProgrammingPensées", cette section est décrite comme suit :

Supposons que nous soyons à l'intérieur d'une méthode et que nous souhaitons obtenir le handle de l' objet actuel. Puisque ce handle est passé "secrètement" par le compilateur, aucun identifiant n'est disponible. Il existe cependant un mot-clé dédié à cet effet : this.

Le handle passé secrètement par le compilateur qui y est mentionné est le paramètre caché que nous avons ici.

Jusqu'à présent, la description de cela doit être très claire, et nous la comprenons au niveau jvm. Alors, êtes-vous intéressé à jeter un œil à l’exemple ci-dessous et à réfléchir à ce que cela représente dans la classe de base B ?

public class B {
 public B() {
  System.out.println(this.getClass().getSimpleName()); 
  System.out.println(((A) this).a); 
 }
}
public class A extends B {
 public int a = 100;  
 public A() {
  a = 200;
 } 
 public static void main(String[] args) {
  new A();
 }
}

Cet exemple était initialement destiné à comprendre comment une classe est initialisée lorsque Java a une structure d'héritage, mais le constructeur en classe B ici assez particulier : la sortie SimpleName de this dans le constructeur de la classe B est A. Habituellement, lorsque nous rencontrons cette situation, la sortie SimpleName de this dans la classe B devrait être B, mais ici c'est A ? Pourquoi?

En parlant de cela ci-dessus, nous en avons déjà parlé. Lors de l'appel de la méthode Java pour créer un cadre de pile, le jvm transmettra secrètement une instance actuelle. Par conséquent, lorsque nous exécutons le constructeur de A, le constructeur de la classe parent B sera appelé par défaut. Lors de l'appel du constructeur de la classe parent B, l'instance actuelle transmise secrètement est l'instance de A - car c'est B qui est appelé. le constructeur de A, donc ceci représente ici A à la place.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!