Chapitre d'amélioration Java (11) ----- Bloc de code

Au cours du processus de programmation, nous pouvons rencontrer des programmes de la forme suivante :

public class Test {
    {
        ////
    }
}

 Nous appelons cette forme de segment de programme un bloc de code. Le soi-disant bloc de code utilise des accolades ({}) pour encapsuler plusieurs lignes de code ensemble pour former un corps de données indépendant utilisé. pour mettre en œuvre un algorithme spécifique. De manière générale, un bloc de code ne peut pas être exécuté seul, il doit avoir un corps opérationnel. Il existe quatre principaux types de blocs de code en Java :

1. Les blocs de code ordinaires

Les blocs de code ordinaires sont Celui que nous utilisons le plus et qui est le plus courant est le segment de code entouré de {} après le nom de la méthode. Un bloc de code ordinaire ne peut pas exister seul, il doit suivre le nom de la méthode. Il doit également être appelé en utilisant le nom de la méthode.

public class Test {
    public void test(){
        System.out.println("普通代码块");
    }
}

2. Bloc de code statique

Quand on pense à statique, on pensera à statique. Un bloc de code statique est un segment de code entouré de {} modifié avec static Son objectif principal est d'initialiser des propriétés statiques.

public class Test {
    static{
        System.out.println("静态代码块");
    }
}

3. Bloc de code synchrone

Utilisez le mot-clé synchronisé pour modifier le fragment de code et utilisez "{}" pour le joindre. Cela signifie qu'un seul thread peut entrer dans le bloc de méthode en même temps, qui est un multi-thread. mécanisme de protection.

4. Construisez le bloc de code

Définissez directement le code sans aucun modificateur, préfixe et suffixe dans la classe Les blocs sont des blocs de code construit. Nous comprenons qu'une classe doit avoir au moins un constructeur, qui est appelé lors de la création d'un objet. Le bloc de code de construction, comme le constructeur, est également appelé lorsqu'un objet est généré. Alors, quand le code de construction est-il appelé ? Comment l'appeler ? Regardez le code suivant :

public class Test {
    /**
     * 构造代码
     */
    {
        System.out.println("执行构造代码块...");
    }
    
    /**
     * 无参构造函数
     */
    public Test(){
        System.out.println("执行无参构造函数...");
    }
    
    /**
     * 有参构造函数
     * @param id  id
     */
    public Test(String id){
        System.out.println("执行有参构造函数...");
    }
}

Ce qui précède définit une classe très simple. Cette classe contient un constructeur sans paramètre, un constructeur paramétré et un bloc de code de construction. En même temps, comme mentionné ci-dessus, le bloc de code n'a pas la capacité de s'exécuter indépendamment. peut le transporter, donc le compilateur Comment le bloc de code construit sera-t-il géré ? Le compilateur insérera les blocs de code dans leur ordre (s'il y a plusieurs blocs de code) devant tous les constructeurs, garantissant ainsi que quel que soit le constructeur appelé, tous les blocs de code construits seront exécutés. Le code ci-dessus est équivalent au formulaire suivant :

public class Test {
    /**
     * 无参构造函数
     */
    public Test(){
        System.out.println("执行构造代码块...");
        System.out.println("执行无参构造函数...");
    }
    
    /**
     * 有参构造函数
     * @param id  id
     */
    public Test(String id){
        System.out.println("执行构造代码块...");
        System.out.println("执行有参构造函数...");
    }

}

       运行结果

public static void main(String[] args) {
        new Test();
        System.out.println("----------------");
        new Test("1");
    }
------------
Output:
执行构造代码块...
执行无参构造函数...
----------------
执行构造代码块...
执行有参构造函数...

                                                    Il Les résultats d'exécution ci-dessus montrent que lors de la création d'un objet, le code de construction est toujours exécuté en premier, puis la fonction constructeur est exécutée. Cependant, une chose à noter est que le code de construction n'est pas exécuté avant le constructeur, il l'est. exécuté en fonction du constructeur. C'est précisément à cause de ces caractéristiques que le bloc de code construit possède ces caractéristiques, il est donc souvent utilisé dans les scénarios suivants : >

  S'il y a plusieurs constructeurs dans une classe , ces constructeurs doivent tous initialiser les variables d'instance. Si nous instancions directement dans le constructeur, il se passera certainement beaucoup de code répétitif, encombrant et peu lisible. Ici, nous pouvons utiliser pleinement les blocs de code construits pour y parvenir. Cela profite du fait que le compilateur ajoute un bloc de code de construction à chaque constructeur.  

2. Initialiser l'environnement de l'instance

       一个对象必须在适当的场景下才能存在，如果没有适当的场景，则就需要在创建对象时创建此场景。我们可以利用构造代码块来创建此场景，尤其是该场景的创建过程较为复杂。构造代码会在构造函数之前执行。

       上面两个常用场景都充分利用构造代码块的特性，能够很好的解决在实例化对象时构造函数比较难解决的问题，利用构造代码不仅可以减少代码量，同时也是程序的可读性增强了。特别是当一个对象的创建过程比较复杂，需要实现一些复杂逻辑，这个时候如果在构造函数中实现逻辑，这是不推荐的，因为我们提倡构造函数要尽可能的简单易懂，所以我们可以使用构造代码封装这些逻辑实现部分。

       五、 静态代码块、构造代码块、构造函数执行顺序

       从词面上我们就可以看出他们的区别。静态代码块，静态，其作用级别为类，构造代码块、构造函数，构造，其作用级别为对象。

       1、 静态代码块，它是随着类的加载而被执行，只要类被加载了就会执行，而且只会加载一次，主要用于给类进行初始化。

       2、 构造代码块，每创建一个对象时就会执行一次，且优先于构造函数，主要用于初始化不同对象共性的初始化内容和初始化实例环境。

       3、 构造函数，每创建一个对象时就会执行一次。同时构造函数是给特定对象进行初始化，而构造代码是给所有对象进行初始化，作用区域不同。

       通过上面的分析，他们三者的执行顺序应该为：静态代码块 > 构造代码块 > 构造函数。

public class Test {
    /**
     * 静态代码块
     */
    static{
        System.out.println("执行静态代码块...");
    }
    
    /**
     * 构造代码块
     */
    {
        System.out.println("执行构造代码块...");
    }
    
    /**
     * 无参构造函数
     */
    public Test(){
        System.out.println("执行无参构造函数...");
    }
    
    /**
     * 有参构造函数
     * @param id
     */
    public Test(String id){
        System.out.println("执行有参构造函数...");
    }
    
    public static void main(String[] args) {
        System.out.println("----------------------");
        new Test();
        System.out.println("----------------------");
        new Test("1");
    }
}
-----------
Output:
执行静态代码块...
----------------------
执行构造代码块...
执行无参构造函数...
----------------------
执行构造代码块...
执行有参构造函数...

以上就是java提高篇（十一）-----代码块的内容，更多相关内容请关注PHP中文网（www.php.cn）！