En Java, les blocs de code sont appelés blocs de code, et les blocs de code peuvent être divisés en quatre types suivants:
1. Introduction
1. Bloc de code normal:
Méthode Corps de méthode en classe
2. Construisez le bloc de code :
Le constructeur est appelé lorsque l'objet est créé, et il est appelé chaque fois qu'il est créé, en prenant la priorité sur l'exécution du constructeur de classe.
3. Bloc de code statique:
Un extrait de code enveloppé dans Static {} ne sera exécuté qu'une seule fois. Les blocs de code statique ont priorité sur l'exécution des blocs de construction.
4. Synchronisez le bloc de code:
En utilisant des blocs de code synchronisés () {} enveloppés, dans un environnement multithread, les opérations de lecture et d'écriture sur les données partagées doivent être mutuellement exclusives, sinon cela entraînera une incohérence des données. Les blocs de code synchrones doivent être écrits dans la méthode.
2. Similitudes et différences entre les blocs de code statique et les blocs de code construits
Similitudes: tous les JVM chargent la classe et s'exécutent avant que le constructeur ne soit exécuté. Plusieurs peuvent être définis dans la classe. Généralement, certaines variables statiques sont attribuées dans le bloc de code.
Différence: les blocs de code statiques sont exécutés avant les blocs de code non statiques. Les blocs de code statique ne sont exécutés qu'une seule fois sur le premier nouveau et ne sont pas exécutés par la suite. Au lieu de cela, les blocs de code non statiques sont exécutés une fois de nouveau.
Trois. Exemple
Bloc de code ordinaire: {} qui apparaît dans une méthode ou une instruction est appelé un bloc de code normal. L'ordre d'exécution des blocs de code ordinaire et des instructions générales est déterminé par l'ordre dans lequel ils apparaissent dans le code, apparaissent d'abord en premier.
classe publique test {public static void main (String [] args) {{int x = 3; System.out.println ("variable x =" + x); } int x = 1; System.out.println ("variable x =" + x); {int y = 7; System.out.println ("variable y =" + y); }}} / * * Exécuter la variable de résultat x = 3 dans le bloc de code ordinaire * variable x = 1 dans la méthode principale * variable y = 7 dans le bloc de code ordinaire * /Bloc de code de construction: un bloc de code qui est directement défini dans la classe et qui n'a pas de mot-clé statique est appelé un bloc de code de construction {}. Le bloc de code du constructeur est appelé lors de la création d'un objet, et chaque fois que l'objet est créé, il est appelé et l'ordre d'exécution du bloc de code du constructeur a priorité sur le constructeur de classe. S'il y a plusieurs blocs de code construits, l'ordre d'exécution est déterminé par l'ordre dans lequel ils apparaissent dans le code, apparaissent d'abord en première exécution.
Classe publique Test1 {{System.out.println ("First Building Block");} public test1 (int i) {System.out.println ("th" + i + "subsal" + "Constructeur");} {System.out.println ("Deuxième bloc de construction");} Public Static Void Main (String [] args) {nouveau test1 (0); Test1 (2);}} / * * Résultat de l'exécution Premier bloc de construction * Deuxième bloc de construction * 0th Call Constructeur * Premier bloc de construction * Deuxième bloc de construction * Premier bloc de construction * Premier bloc de construction * Premier bloc de construction * Deuxième bloc de construction * Le deuxième appel pour construire la méthode * /Bloc de code statique: un bloc de code déclaré en utilisant le mot-clé statique en Java. Les blocs statiques sont utilisés pour initialiser les classes et initialiser les attributs de la classe. Chaque bloc de code statique ne sera exécuté qu'une seule fois. Étant donné que le JVM exécute des blocs de code statique lors du chargement de la classe, les blocs de code statique s'exécutent avant la méthode principale.
Si la classe contient plusieurs blocs de code statique, il sera d'abord exécuté, le code défini sera exécuté ultérieurement.
Avis:
1. Les blocs de code statiques ne peuvent exister dans aucun corps de méthode.
2. Les blocs de code statique ne peuvent pas accéder directement aux variables d'instance et aux méthodes d'instance, et doivent être accessibles via l'objet d'instance de la classe.
classe publique test3 {public static String static_field = "Attribut static"; // Block statique statique {System.out.println (static_field); System.out.println ("Bloc de code statique 1");} public Field = "Attribut non statique"; // Block non statique {System.out.println (champ); System.out.out.Println ("Notor System Block 2 ");} public initoderTest () {System.out.println (" Aucun constructeur de paramètres ");} public static void main (String [] args) {initoderTest test = new InitoDerTest ();} // non statique Block {System.out.println (champ); System.out.println (" Block de code non statique 1 "); {System.out.println (static_field); System.out.println ("Bloc de code statique 2");}} / * * Exécuter l'attribut statique * Bloc de code statique 1 * Attribut statique * Bloc de code statique 2 * Attribut non statique * Constructeur non statique 2 * Attribut non statique * Block de code non statique 1 * Constructeur non argument * / /Le code suivant démontre la relation prioritaire entre les blocs de code individuels de la création d'un objet et d'appeler une méthode:
Personne de classe publique {static {System.out.println ("1. Je suis un bloc statique, qui prévoit l'exécution du bloc de construction! Et il ne s'exécute qu'une fois lorsque le premier objet est créé!");} {System.out.println ("" 2. Je suis un constructeur, qui prend la précèdence sur la méthode de construction Exécution! Exécuter une fois que chaque objet est créé! ");} Public Static Void function1 () {System.out.println ("Je suis un bloc de code normal dans une méthode non statique, qui prévient lorsque la méthode est appelée!");} public static void function2 () {System.out.println ("Je suis un bloc de code normal dans une méthode statique. La méthode est exécutée plus tard que le bloc statique!");}}Classe de test:
classe publique hellowrold {public static void main (String [] args) {new Person (). function1 (); new Person().function1();System.out.println("================================================================================== =======================================================================. =======================================================================. ======================================================================. =======================================================================. =======================================================================. =======================================================================.Résultats en cours:
Nous pouvons voir que les blocs statiques sont toujours exécutés en premier et ne seront exécutés qu'une seule fois que lorsque la première instance de la classe sera créée; Le second est le bloc constructeur; et le troisième est la méthode du constructeur.
Résumer
Ce qui précède concerne l'explication détaillée des quatre blocs de code en Java, et j'espère que cela sera utile à tout le monde. Les amis intéressés peuvent continuer à se référer à d'autres sujets connexes sur ce site. S'il y a des lacunes, veuillez laisser un message pour le signaler. Merci vos amis pour votre soutien pour ce site!