Java analyse quel est l'ordre d'instanciation des classes du point de vue de la machine virtuelle

Ce que cet article vous apporte, c'est l'analyse par Java de l'ordre d'instanciation des classes du point de vue d'une machine virtuelle. Il a une certaine valeur de référence. Les amis dans le besoin peuvent s'y référer. J'espère qu'il vous sera utile.

1. Montrez d'abord l'exemple de code (Son.java & Father.java)

public class Father {    
    public static int a=10;//父类的静态变量    static{//父类的静态代码块
        a=20;
    }
    {//父类的构造代码块
        a=30;
    }    
    public Father() {//父类的构造方法
        a=40;
    }
}

public class Son extends Father{    
    public static int s=10;//子类的静态变量    public int k=20;//子类的实例变量    static{//子类的静态代码块
        s=20;
    }
    {//子类的构造代码块
        s=30;
    }    public Son() {//子类的构造函数
        s=40;
    }
    {//子类的构造代码块
        s=50;
    }
}

2 Compilez le fichier son.java dans un fichier son.class, et puis utilisez Decompile javap pour afficher les instructions de bytecode de Son afin d'analyser l'ordre de chargement de Son, qui est plus facile à comprendre (javap -v -c Son > p.txt).

3. Après avoir exécuté le code "new Son();", analysez l'ordre de chargement des classes.

Le static{}; ci-dessous est la fonction et son();

static {};
    descriptor: ()V
    flags: ACC_STATIC
    Code:
      stack=1, locals=0, args_size=0
         0: bipush        10
         2: putstatic     #11                 // Field s:I--------------------------顺序执行静态变量的赋值
         5: bipush        20
         7: putstatic     #11                 // Field s:I--------------------------顺序执行静态代码块
        10: return

  public packet1020.Son();
    descriptor: ()V
    flags: ACC_PUBLIC
    Code:
      stack=2, locals=1, args_size=1
         0: aload_0         
         1: invokespecial #16                 // Method packet1020/Father."<init>":()V--------------------执行父类的<init>函数（顺序不变，第一个）
         4: aload_0         
         5: bipush        20
         7: putfield      #18                 // Field k:I------------------------------------------------按顺序收集实例变量赋值
        10: bipush        30
        12: putstatic     #11                 // Field s:I------------------------------------------------按顺序收集构造代码块
        15: bipush        50
        17: putstatic     #11                 // Field s:I------------------------------------------------按顺序收集构造代码块
        20: bipush        40
        22: putstatic     #11                 // Field s:I------------------------------------------------最后执行自己的构造函数代码（顺序不变，最后一个）
        25: return

Démarrer l'analyse :

1. Déclenchez le chargement de la classe. Dans la phase d'initialisation, exécutez d'abord la fonction sous-classe Fonction, exécute l'affectation de variables statiques et le bloc de code statique en séquence.

2. Le constructeur est exécuté dans le code, donc la fonction

Conclusion :

1. Les affectations de variables statiques sont exécutées séquentiellement dans la classe parent, les blocs de code statiques

2. Les affectations de variables statiques sont exécutées séquentiellement dans la sous-classe, le code statique. blocs

3. Exécuter séquentiellement les affectations de variables d'instance dans la classe parent et construire des blocs de code

4. Constructeur de classe parent

5. dans la sous-classe

6. Constructeur de sous-classe

Explication du nom : extrait de "Compréhension approfondie de la machine virtuelle Java : fonctionnalités avancées et meilleures pratiques JVM" par M. Zhou Zhiming

1. Oui Et il n'y a que la troisième des 4 situations où la classe doit être initialisée (exécuter la fonction ) : lors de l'initialisation d'une classe, initialisez d'abord la classe parent. C'est pourquoi la fonction de la classe parent est exécutée avant la fonction

2. Fonction : Le compilateur collecte automatiquement les actions d'affectation de toutes les variables statiques de la classe et fusionne les instructions dans le bloc de code statique selon l'ordre dans le code source.

3. Fonction  : appelez d'abord la fonction de la classe parent, puis le compilateur collecte automatiquement les opérations d'affectation et les blocs de code de construction des variables d'instance dans l'ordre dans le code source. Les instructions dans sont combinées puis insérées avant la méthode constructeur, et enfin le code constructeur écrit par le programmeur lui-même.

Le bloc de code de construction est exécuté avant la fonction constructeur

<init>(){
　　1.调用父类<init>方法
　　2.顺序执行实例变量的赋值操作和构造代码块
　　3.程序员自己的构造函数方法代码
}

Résumé : ce qui précède est l'intégralité du contenu de cet article, j'espère qu'il sera utile à l'apprentissage de chacun. Pour plus de didacticiels connexes, veuillez visiter le Tutoriel vidéo Java, le Tutoriel graphique de développement Java, le Tutoriel vidéo bootstrap !

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!