En quoi un initialiseur d'instance est-il différent d'un constructeur?
En d'autres termes, pourquoi auriez-vous besoin d'un initialiseur d'instance? Quelle différence ou avantage avez-vous à écrire un initialiseur d'instance par rapport à un constructeur?
Cela semble bien l'expliquer:
Les initialiseurs d'instance sont une alternative utile aux initialiseurs de variable d'instance chaque fois que:
le code d'initialisation doit intercepter les exceptions, ou
effectuer des calculs fantaisistes qui ne peuvent pas être exprimés avec un initialiseur de variable d'instance. Vous pouvez bien sûr toujours écrire un tel code dans les constructeurs.
Mais dans une classe qui avait plusieurs constructeurs, vous devrez répéter le code dans chaque constructeur. Avec un initialiseur d'instance, vous pouvez simplement écrire le code une fois, et il sera exécuté quel que soit le constructeur utilisé pour créer l'objet. Les initialiseurs d'instance sont également utiles dans les classes internes anonymes, qui ne peuvent pas déclarer de constructeur du tout.
De: JavaWorld initialisation d'objet en Java .
En termes de cycle de vie des objets, il n'y a pas de différence. Les deux sont invoqués au moment de la construction et, logiquement, le bloc d'initialisation peut être considéré comme faisant partie de la construction.
Sémantiquement, un initialiseur est un bel outil à avoir pour plusieurs raisons:
l'initialiseur peut améliorer la lisibilité du code en gardant la logique d'initialisation à côté de la variable en cours d'initialisation:
public class Universe {
public int theAnswer;
{
int SIX = 6;
int NINE = 7;
theAnswer = SIX * NINE;
}
// a bunch of other vars
}
contre
public class Universe {
public int theAnswer;
// a bunch of other vars
public Universe() {
int SIX = 6;
int NINE = 7;
theAnswer = SIX * NINE;
// other constructor logic
}
}
Les initialiseurs sont invoqués quel que soit le constructeur utilisé.
Les initialiseurs peuvent être utilisés dans des classes internes anonymes, où les constructeurs ne le peuvent pas.
Lorsque vous avez plusieurs constructeurs et que vous souhaitez exécuter du code commun pour chaque constructeur, vous pouvez utiliser l'initialiseur d'instance, comme il est appelé pour tous les constructeurs.
le véritable avantage des initialiseurs d'instance sur les constructeurs est visible lorsque nous utilisons une classe interne anonyme.
Les classes internes anonymes ne peuvent pas avoir de constructeur (car elles sont anonymes) ,donc elles sont assez naturelles pour initialiseurs d'instance.
J'éviterais l'idiome d'initialisation d'instance en général - le seul véritable avantage qu'il donne par rapport aux initialiseurs variables est la gestion des exceptions.
Et comme une méthode init (appelable depuis le constructeur) peut également gérer les exceptions et centraliser également le code de configuration du constructeur, mais a l'avantage de pouvoir fonctionner sur les valeurs des paramètres du constructeur, je dirais que l'initialiseur d'instance est redondant, et donc être évité.
L'initialiseur est un moyen de partager du code entre les constructeurs et rend le code plus lisible si l'initialiseur est utilisé avec une déclaration de variable.
Le compilateur Java copie les blocs d'initialisation dans chaque constructeur. Par conséquent, cette approche peut être utilisée pour partager un bloc de code entre plusieurs constructeurs. documentation Oracle