Un constructeur est une méthode spéciale destinée à définir initialement les valeurs des champs d'un objet. À première vue, les constructeurs d’objets ne diffèrent pas beaucoup des méthodes objets ordinaires. Et en effet, à l'intérieur du constructeur, nous pouvons faire tout ce que nous pouvons faire dans les méthodes objet classiques : afficher du texte sur la console, accéder à tous les champs et méthodes du nouvel objet, lever des exceptions, etc. Tout comme les méthodes classiques, les constructeurs peuvent avoir des arguments. Tout comme les méthodes surchargées, il peut y avoir plusieurs constructeurs avec des signatures différentes. Tout comme les méthodes génériques, les constructeurs peuvent être paramétrés par des variables de type. Même si nous examinons le bytecode généré par le compilateur, à l'endroit où il devrait y avoir un appel au constructeur, nous trouverons un appel à une méthode avec le nom dont l'appel n'est pas différent de l'appel à d'autres méthodes <init>de L'object. Et après avoir trouvé le bytecode de cette méthode, nous constaterons qu'il contient le résultat de la compilation de notre constructeur. Il semble qu'il n'y ait pas beaucoup de différences par rapport aux méthodes conventionnelles, mais elles existent, et elles sont assez significatives. Tout d'abord, voyons pourquoi avons-nous réellement besoin de constructeurs ? Pour stocker et traiter des données, qu'il s'agisse de types primitifs, de tableaux ou d'objets, nous avons besoin d'une certaine quantité de mémoire. Il peut s'agir de registres de processeur, d'espace de pile ou d'un espace alloué dans la section de données de processus, ou dans une partie de mémoire allouée dynamiquement (tas). Dans de nombreux langages de programmation, à des fins d'accélération, lorsqu'un programme demande un nouvel espace de mémoire, la mémoire n'est pas attribuée au programme et peut contenir des données arbitraires qui ont été stockées précédemment dans cette cellule mémoire. Préparer et écrire les valeurs nécessaires dans un tel morceau de mémoire afin qu'à la fin il y ait une structure de données significative, tombait entièrement sur les épaules du programmeur. Tout naturellement, les programmeurs ont voulu se faciliter la vie et ont écrit des routines pour initialiser (c'est-à-dire définir des valeurs initiales) pour les structures de données fréquemment utilisées. De telles routines étaient utilisées presque constamment, c'est pourquoi les créateurs du langage Java ont décidé de rendre obligatoire l'appel de ces routines d'initialisation lors de la création d'objets et les ont appelés constructeurs . Lorsqu'un nouvel objet est créé en Java, les événements suivants se produisent : Tout d'abord, le gestionnaire de mémoire Java alloue la quantité de mémoire nécessaire pour accueillir l'objet. Dans ce cas, non seulement les champs déclarés directement dans la classe de l'objet créé sont pris en compte, mais également les champs déclarés dans tous les ancêtres de cette classe. De plus, ce volume comprend un espace pour placer les structures utilisées par la machine Java pour ses besoins internes. Tous les champs d'un tel « vide » sont automatiquement définis sur les valeurs par défaut - nullpour les types de référence, 0pour les nombres et falsepourboolean. Après cela, le constructeur de classe est automatiquement appelé, dont la tâche est de définir les valeurs initiales des champs de l'objet. Alors que dans une méthode normale, la première instruction peut être n'importe quoi, le constructeur a beaucoup moins de liberté. La première instruction d'un constructeur doit être soit un appel explicite à un autre constructeur de la même classe, soit un appel explicite ou implicite à un constructeur d'une classe parent. Les appels explicites aux constructeurs de la même classe sont effectués à l'aide d'un mot-clé thissuivi d'un ensemble d'arguments entre parenthèses. L'appel explicite du constructeur d'une classe parent se fait exactement de la même manière, mais le mot-clé est utilisé super. Dans les arguments d'un appel explicite au constructeur de la même classe ou de la classe parent, vous ne pouvez pas accéder aux champs et méthodes de l'objet, ni utiliser les mots-clés et , puisqu'un appel explicite au constructeur introduit un contexte thisstatique super. Pour appeler implicitement le constructeur d'une classe parent, vous n'avez rien besoin d'écrire, mais le constructeur par défaut est implicitement appelé, qui doit exister et être visible par la classe actuelle. Dans le même temps, il convient de garder à l'esprit que si la chaîne des constructeurs parents appelants est interrompue avant que le constructeur de classe Objectsitué en haut de la chaîne ne termine avec succès son travail, alors l'objet ne sera pas finalisable, c'est-à-dire la méthode finalize()d'un tel objet ne sera jamais appelé. Une fois le constructeur de la classe parent terminé, le contrôle est implicitement transféré aux blocs d'initialisation d'instance et aux initialiseurs de champ d'instance de la classe actuelle. Les initialiseurs sont exécutés dans l'ordre dans lequel ils apparaissent dans le texte du programme. Ce n'est qu'une fois que les initialiseurs ont terminé leur travail que le contrôle est transféré au reste du constructeur. Les fonctionnalités restantes des constructeurs concernent le modèle de mémoire Java. Si une classe, ou l'un de ses ancêtres, remplace la méthode finalize(), alors l'achèvement du constructeur aura lieu avant ( arrive avant ) l'exécution de la méthode finalize(). Si un thread a vu une référence à un objet après l'achèvement du constructeur, il est alors garanti que ce thread verra les champs correctement initialisés finalde l'objet, dont l'initialisation a eu lieu avant l'achèvement du constructeur.
GO TO FULL VERSION