Pourquoi les champs statiques ne sont pas initialisées dans le temps?

Le code suivant imprime null une fois.

class MyClass {
   private static MyClass myClass = new MyClass();
   private static final Object obj = new Object();
   public MyClass() {
      System.out.println(obj);
   }
   public static void main(String[] args) {}
}

Pourquoi les objets statiques non initialisées avant l'exécution du constructeur?

Mise à jour

J'avais juste copié ce programme d'exemple et sans attention, je pensais que nous parlions de 2 champs d'Objet, maintenant que j'ai vu que le premier est un MyClass champ.. :/

InformationsquelleAutor Tom Brito | 2010-03-30

37

À cause de la statique sont initialisés dans l'ordre où ils sont donnés dans le code source.

Check this out:
```
class MyClass {
  private static MyClass myClass = new MyClass();
  private static MyClass myClass2 = new MyClass();
  public MyClass() {
    System.out.println(myClass);
    System.out.println(myClass2);
  }
}
```
À imprimer:
```
null
null
myClassObject
null
```
MODIFIER

Ok mettons à être un peu plus clair.
1. De la statique sont initialisés un par un dans l'ordre tel que déclaré dans le code source.
2. Depuis la première statique est initialisé avant le repos, lors de son initialisation, le reste de la statique des champs sont nuls ou les valeurs par défaut.
3. Lors de l'initiation de la deuxième statique de la première statique est correct mais le reste est toujours la valeur null ou par défaut.
Est-ce clair?

EDIT 2

Comme Varman a souligné la référence à elle-même sera nulle alors qu'elle est en cours d'initialisation. Qui a de sens que si vous pensez à ce sujet.
- ..et parce que myClass lui-même est statique.
- ok, statique est initilized dans l'ordre. Et les statistiques sont avant que le constructeur, alors pourquoi il n'est pas initialisé lors de l'exécution du constructeur? Ressemble vraiment un problème pour moi..
- non, vous vous êtes trompé. la statique ne sont pas avant des constructeurs. la statique sont init lorsque les constructeurs sont appelés respectivement. Dans mon exemple, lors de la première statique est init avec MyClass le constructeur est appelé. Lorsque le constructeur est en cours d'exécution myClass est init (parce que la course elle-même), mais myClass2 ne l'est pas. Lors de la deuxième MyClass est init il appelle le constructeur de nouveau et cette fois myClass était déjà init et myClass2 est en cours d'initialisation à l'époque
- si c'est comme statique sont initialisés dans un autre thread, alors que le constructeur s'exécute? Avez-vous un lien vers un même texte expliquant ce dans les détails?
- Mis à jour le post, j'espère que c'est plus explicatif
- Je suis aussi surpris de voir que vous êtes le premier à poser cette question si simple. C'est ceux de ces pièges
- Quand j'ai exécuté votre programme, j'ai obtenu des résultats différents. Imprimer null null myClassObjectref null
- Eh bien, je vais être damné. Presque 2 ans après que cette question a été répondu et vous êtes les premiers à fait d'exécuter ce code? Je vais corriger la réponse
InformationsquelleAutor Pyrolistical
24

Essayons une autre façon d'expliquer cela...

C'est la séquence de la JVM va de travers lors de la première référence de la classe MyClass.
1. Charger le byte-code dans la mémoire.
2. De mémoire pour le stockage statique est désactivée (zéro binaire).
3. Initialiser la classe:
  1. L'exécution de chacune d'initialiseur statique dans l'ordre dans lequel il apparaît, ce qui inclut les variables statiques et static { ... } blocs.
  2. JVM initialise ensuite votre myClass variable statique à une nouvelle instance de MyClass.
  3. Lorsque cela se produit, la JVM avis que MyClass est déjà chargé (byte-code) et dans le processus d'être initialisé, de sorte qu'il ignore l'initialisation.
  4. Allouer de la mémoire sur le tas pour l'objet.
  5. Exécuter constructeur.
  6. Imprimer la valeur de obj qui est encore null (puisqu'il ne fait pas partie de la tas et de constructeur initialisé les variables).
  7. Lorsque constructeur finitions, exécuter ensuite initialiseur statique qui définit obj à une nouvelle instance de Object.
4. Initialisation de classe fait. À partir de ce point, tous les constructeur appelle va se comporter comme vous prétendez/attendre - c'est-à obj ne serait pas null mais une référence à un Object instance.
Rappelez-vous que Java spécifie qu'un final variable est attribuée une valeur une fois. Il n'est pas qu'il est garanti pour être affecté d'une valeur lorsque les références de code, à moins que vous vous assurez que les références de code après il est affecté.

Ce n'est pas un bug. C'est la manière définie pour gérer l'utilisation de la classe au cours de sa propre initialisation. Si ce n'était pas le cas, la JVM irait dans une boucle infinie. Voir l'étape n ° 3.3 (si la JVM ne sautez pas de l'initialisation pour une classe qui est dans le processus de l'initialisation, il suffit de garder initialisation - boucle infinie).

Note que bien, tout cela se fait sur le même thread qui fait référence à la classe. Deuxièmement, la JVM garantit que l'initialisation complète avant toute autre thread n'est autorisé à utiliser cette classe.
- Belle réponse de Kevin, meilleur ici
- Tu veux dire que ça saute "statique" de l'initialisation, je suppose.
InformationsquelleAutor Kevin Brock
19

C'est parce que Java exécute la statique de la section afin qu'il ne soit déclaré. Dans votre cas, la séquence est
1. new MyClass
2. nouvel Objet
Lors de la #1 est exécutée, obj n'est pas encore initialisé, de sorte qu'il imprime la valeur null. Essayez ce qui suit et vous verrez la différence:
```
class MyClass {
  private static final Object obj = new Object();
  private static MyClass myClass = new MyClass();
  public MyClass() {
    System.out.println(obj); //will print null once
  }
}
```
De manière générale, il est préférable d'éviter une telle construire tous ensemble. Si vous essayez de créer un singleton, c'est comment ce fragment de code devrait ressembler à:
```
class MyClass {

  private static final MyClass myClass = new MyClass();

  private Object obj = new Object();

  private MyClass() {
    System.out.println(obj); //will print null once
  }
}
```
- +1 bonne réponse.
- Correct sur le <clinit> l'exécution de l'ordre. Le Singleton n'est pas vraiment un Singleton cependant, puisque le constructeur est public.
- Rob - merci de remarquer corrigée.
- ok, statique est initilized dans l'ordre. Et les statistiques sont déclaré et a demandé pour initialiser avant que le constructeur, alors pourquoi il n'est pas initialisé lors de l'exécution du constructeur? Ressemble vraiment un problème pour moi..
- vous avez à comprendre en appelant new MyClass() en statique et que vous appelez le constructeur
- pense que nous sommes d'avoir une panne de communication ici. Je sais que new MyClass() est un appel à un constructeur, cela n'explique pas pourquoi les champs statiques sont nuls lors de l'exécution du constructeur. Comme l'instance champs sont initialisés avant que le constructeur, les champs statiques devraient être.. mais pourquoi ils ne le font pas?
- Les membres statiques est construit avant l'instance constructeur s'exécute. C'est juste que dans votre code, votre initialiseur statique aussi appels de votre constructeur. C'est un dilemme de la poule et de l'oeuf problème.
InformationsquelleAutor Slava Imeshev
0

c'est parce que les champs statiques initialisée dans le même ordre défini.
- ce n'est pas la réponse pourquoi elle est nulle au moment du constructeur.
InformationsquelleAutor antony
0

@Pyrolistical

depuis l'initiale du premier champ statique myclass n'est pas entièrement construit ...le résultat que j'obtiens est

null
null
testInitialize.MyObject@70f9f9d8
null

InformationsquelleAutor iamx7777777

Vous devez vous connecter pour publier un commentaire.