Java ordre de l'Initialisation et de l'Instanciation

Je suis en train d'essayer de reconstituer le processus d'Initialisation et d'Instanciation dans la JVM, mais le JLS est un peu obtus sur quelques détails, donc si quelqu'un aurait l'esprit de compensation de certains détails, il serait apprécié. C'est ce que j'ai pu découvrir jusqu'à présent.

Initialisation

De manière récursive Initialiser static final variables de la classe et des interfaces de compiler les constantes de temps.
Retour de la récurrence de traitement des blocs statiques et les champs statiques dans l'ordre textuel.

Instanciation

De manière récursive Initialiser final variables d'instance de la classe qui sont à la compilation des constantes de temps.
Retour de la récurrence de traitement des non-blocs statiques et les champs d'instance dans l'ordre textuel ajoutant à l'constructeurs de retour.

Bon, maintenant pour les questions.

interfaces sont traitées dans l'ordre de déclaration?
interfaces sont traitées dans une autre pile récursive?

a) si oui, avez-interfaces être traités avant ou après le super-classes?

b) si oui, suis-je correct en déduire que l'un ou l'autres (Interface ou de la super-classe) obtient sa non-constante à la compilation des champs initialisés avant les autres constantes de compilation.
Quel est le rôle d'appels de l'autre constructeur super() jouer dans ce processus?
Suis-je trompé dans mes conclusions?
Me manque tout les autres détails de la clé?

Les Interfaces n'ont rien à initialiser. Sauf si vous êtes en utilisant le mot dans un autre mode que je suis habitué.
Les Interfaces peuvent avoir public static final champs. Si ces champs sont des objets avec un initialiseur (par exemple public static final ArrayList<String> someStrings = new ArrayList<>();) alors que ce serait une partie de l'initialisation.

InformationsquelleAutor user3056052 | 2014-04-15

java

44

Il est important de faire la distinction entre l'initialisation d'une classe, et l'initialisation d'un objet.

Initialisation De Classe

Une classe ou une interface est initialisé lors de la premier accès, en attribuant le temps de compilation champs constants, puis, de manière récursive l'initialisation de la super-classe (si ce n'est déjà initialisé), puis le traitement de la initialiseurs statiques (qui incluent les initialiseurs pour les champs statiques qui ne sont pas de compiler des constantes de temps).

Comme vous l'avez remarqué, l'initialisation d'une classe ne comprend pas, par elle-même, déclencher l'initialisation des interfaces qu'il implémente. Interfaces sont donc initialisé quand ils sont tout d'abord accessibles, généralement par la lecture d'un champ qui n'est pas une compilation constante de temps. Cet accès peut se produire lors de l'évaluation d'un initialiseur, provoquant un appel récursif à l'initialisation.

Il est également intéressant de noter que l'initialisation n'est pas déclenchée par accéder à des champs que sont la compilation des constantes de temps, que celles-ci sont évaluées à moment de la compilation:

Une référence à un champ qui est une constante variable (§4.12.4) devra être réglé au moment de la compilation à la valeur V notée par la constante de l'initialiseur.

Si un tel champ est statique, pas de référence au champ doit être présent dans le code dans un fichier binaire, y compris la classe ou de l'interface, qui a déclaré le champ. Un tel champ doit toujours semblent avoir été initialisé (§12.4.2); la valeur par défaut la valeur initiale du champ (si différente de celle V) ne doit jamais être observé.

Si ce champ n'est pas statique, aucune référence à ce champ doit être présent dans le code dans un fichier binaire, sauf dans la classe contenant le champ. (Ce sera une classe plutôt qu'à une interface, depuis une interface a seulement champs statiques.) La classe devrait avoir le code pour définir la valeur du champ de V pendant la création de l'instance (§12.5).

L'Initialisation De L'Objet

Un objet est initialisé chaque fois qu'un nouvel objet est créé, généralement par l'évaluation de une création de l'instance de la classe expression. Ce produit comme suit:
1. Affecter les arguments pour le constructeur nouvellement créés variables de paramètre pour ce constructeur invocation.
2. Si ce constructeur commence par un constructeur explicite invocation (§8.8.7.1) d'un autre constructeur de la même classe (à l'aide de ce), puis d'évaluer les arguments et les processus que le constructeur invocation de manière récursive à l'aide de ces cinq étapes. Si ce constructeur invocation se termine brusquement, alors cette procédure se termine brusquement pour la même raison; sinon, passez à l'étape 5.
3. Ce constructeur ne commence pas par un constructeur explicite invocation d'un autre constructeur de la même classe (à l'aide de ce). Si ce constructeur est pour une autre classe de l'Objet, puis ce constructeur va commencer avec un explicite ou implicite de l'invocation du constructeur de la superclasse (à l'aide de super). Évaluer les arguments et les processus que le constructeur de la superclasse invocation de manière récursive à l'aide de ces cinq étapes. Si ce constructeur invocation se termine brusquement, alors cette procédure se termine brusquement pour la même raison. Sinon, passez à l'étape 4.
4. Exécuter l'instance initialiseurs et variable d'instance initialiseurs pour cette classe, en affectant les valeurs de la variable d'instance initialiseurs de l'instance correspondante de variables, dans le de gauche à droite dans l'ordre dans lequel ils apparaissent sous forme de texte dans le code source de la classe. Si l'exécution de l'une de ces initialiseurs d'obtenir une exception, aucune initialiseurs sont traitées et cette procédure se termine abruptement avec la même exception. Sinon, passez à l'étape 5.
5. Exécuter le reste du corps de ce constructeur. Si l'exécution se termine brusquement, alors cette procédure se termine brusquement pour la même raison. Sinon, cette procédure se termine normalement.
Comme nous pouvons le voir dans l'étape 3, la présence d'un appel explicite à la super constructeur modifie simplement super-constructeur de la classe est appelée.

InformationsquelleAutor meriton - on strike

Qui suit est un exemple d'impression de l'ordre de chaque étape lors de la création de l'objet.

InstanceCreateStepTest.java:

import javax.annotation.PostConstruct;
/**
* Test steps of instance creation.
* 
* @author eric
* @date Jan 7, 2018 3:31:12 AM
*/
public class InstanceCreateStepTest {
public static void main(String[] args) {
new Sub().hello();
System.out.printf("%s\n", "------------");
new Sub().hello();
}
}
class Base {
static {
System.out.printf("%s - %s - %s\n", "base", "static", "block");
}
{
System.out.printf("%s - %s - %s\n", "base", "instance", "block");
}
public Base() {
System.out.printf("%s - %s\n", "base", "constructor");
}
@PostConstruct
public void init() {
System.out.printf("%s - %s\n", "base", "PostConstruct");
}
public void hello() {
System.out.printf("%s - %s\n", "base", "method");
}
}
class Sub extends Base {
static {
System.out.printf("%s - %s - %s\n", "sub", "static", "block");
}
{
System.out.printf("%s - %s - %s\n", "sub", "instance", "block");
}
public Sub() {
System.out.printf("%s - %s\n", "sub", "constructor");
}
@PostConstruct
public void init() {
System.out.printf("%s - %s\n", "sub", "PostConstruct");
}
@Override
public void hello() {
//super.hello();
System.out.printf("%s - %s\n", "sub", "method");
}
}

Exécution:

Il suffit d'invoquer la méthode main, et de vérifier ensuite la sortie.

Conseils:

Les méthodes marquée par @PostConstruct de ne pas être invoquée, sauf si vous l'appelez à l'intérieur de certaines conteneur, comme Spring-boot, car il dépend de ces conteneurs pour mettre en œuvre l'annotation comme @PostConstruct.

InformationsquelleAutor Eric Wang

Vous devez vous connecter pour publier un commentaire.