Comment initialiser des classes et des objets en Java

Tout d’abord, jetons un œil au code ci-dessous. Il s’agit d’une méthode d’inspection très classique.

public class InitField {      public static void main(String[] args) {          SuperInitField p = new SuperInitField();          SuperInitField c = new SubInitField();      }  }   class SuperInitField {      public SuperInitField() {          System.out.println("parent");      }      static {          System.out.println("static parent");      }   }   class SubInitField extends SuperInitField {      public SubInitField() {          System.out.println("child");      }      static {          System.out.println("static child");      }  }

Que vous puissiez écrire la bonne réponse rapidement ou non, mettons d'abord ce programme de côté et comprenons le principe d'initialisation de la machine virtuelle Java.

La JVM installe, connecte et initialise un type Java afin que le type puisse être utilisé en exécutant des programmes Java. Le cycle de vie du type est illustré dans la figure ci-dessous :

Le chargement et la connexion doivent être terminés avant l'initialisation.

La phase d'initialisation de la classe consiste principalement à attribuer des valeurs initiales correctes aux variables de classe. La valeur initiale « correcte » fait ici référence à la valeur de départ que le programmeur souhaite que cette variable de classe ait. Une valeur initiale correcte est donnée via une instruction d'initialisation de variable de classe ou une instruction d'initialisation statique. L'initialisation d'une classe implique deux étapes :

1) Si la classe a une superclasse directe et que la superclasse directe n'a pas été initialisée, initialisez d'abord la superclasse directe.

2) Si la classe a une méthode d'initialisation de classe, exécutez cette méthode.

Alors, quand la classe sera-t-elle initialisée ? La spécification de la machine virtuelle Java définit strictement le timing d'initialisation d'une classe : initialisée lorsqu'elle est activement utilisée.

Alors quelles situations répondent aux critères d'utilisation active par *** ? La spécification de la machine virtuelle Java explique cela, ce sont :

1) Créer une nouvelle instance de la classe

2) Appeler la méthode statique de la classe

3) Manipuler les champs statiques de la classe ou de l'interface ; champs finaux) ;

4) Appeler la méthode de réflexion spécifique à Java ;

5) Initialiser une sous-classe d'une classe

6) Spécifier une classe comme classe d'initialisation au démarrage de la machine virtuelle Java ;

À l'exception des six situations ci-dessus, toutes les autres méthodes sont utilisées passivement et ne provoqueront pas l'initialisation de la classe.

Une fois qu'une classe est chargée, connectée et initialisée, elle est prête à être utilisée. Concentrons-nous maintenant sur l'instanciation des objets. L'instanciation et l'initialisation d'objets sont des activités au cours de la phase initiale de la vie de l'objet.

Le compilateur Java génère au moins une méthode d'initialisation d'instance pour chaque classe qu'il compile, à savoir la méthode (). Chaque constructeur de classe dans le code source possède une méthode () correspondante. Si la classe ne déclare explicitement aucun constructeur, le compilateur génère un constructeur sans argument par défaut pour la classe. Ce constructeur par défaut appelle uniquement le constructeur sans argument de la classe parent.

Une méthode () peut contenir trois types de contenu de code : appeler une autre méthode () ; initialiser les variables d'instance et construire le code du corps de la méthode.
Si le constructeur commence explicitement par appeler un autre constructeur dans la même classe, le contenu inclus dans son corps de méthode () correspondant est :

1. Un appel de méthode ( pour cette classe )

 ;

2. implémente le bytecode du corps de méthode correspondant à la méthode de construction.

Si le constructeur ne commence pas par appeler d'autres méthodes de constructeur de sa propre classe et que l'objet n'est pas un objet Object, alors le contenu inclus dans la méthode () est :

1. Un parent class< L'appel à la méthode init>() ;

2. Le bytecode de toute méthode d'initialisation de variable d'instance

3. implémente le bytecode du corps de la méthode correspondant à la méthode de construction.

L'explication ci-dessus vous aide-t-elle à comprendre l'initialisation des types Java ?

D'accord, analysons à nouveau le début du code :

SuperInitField p = new SuperInitField();  //SuperInitField的超类是Object  //创建SuperInitField对象，属于***主动使用，因此要先初始化Object类，然后再调用SuperInitField类变量初始化语句或者静态初始化语句，所以要输出static parent  //类被装载、连接和初始化之后，创建一个对象，因此需要首先调用了Object的默认构造方法，然后再调用自己的构造方法，所以要输出parent    SuperInitField c = new SubInitField();  //SubInitField继承自SuperInitField  //创建SubInitField对象，属于***主动使用，父类SuperInitField已被初始化，因此只要调用SubInitField类变量初始化语句或者静态初始化语句，所以要输出static child  //类被装载、连接和初始化之后，创建一个对象，因此需要首先调用了SuperInitField的构造方法，然后再调用自己的构造方法，所以要输出parent，然后再输出child

À présent, vous devriez avoir une compréhension générale des principes d'initialisation des classes Java, puis je vais m'en remettre aux exercices et écrire les résultats du code suivant .

public class Test {      public Test(){          System.out.println("parent");      }      static{          System.out.println("static parent");      }      public static void main(String[] args) {          System.out.println("main");      }  }

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!