Explicación detallada de cuatro bloques de código en Java

En Java, los bloques de código se denominan bloques de código, y los bloques de código se pueden dividir en los siguientes cuatro tipos:

1. Introducción

1. Bloque de código normal:

Método Cuerpo de método en clase

2. Construya el bloque de código :

El constructor se llama cuando se crea el objeto, y se llama cada vez que se crea, teniendo prioridad sobre la ejecución del constructor de clase.

3. Bloque de código estático:

Un fragmento de código envuelto en Static {} solo se ejecutará una vez. Los bloques de código estático tienen prioridad sobre la ejecución del bloque de construcción.

4. Sincronice el bloque de código:

Uso de bloques de código SynChronized () {} envueltos en un entorno múltiple, las operaciones de lectura y escritura en datos compartidos deben ser mutuamente excluyentes, de lo contrario conducirá a la inconsistencia de los datos. Los bloques de código sincrónicos deben escribirse en el método.

2. Similidades y diferencias entre los bloques de código estático y los bloques de código construidos

Similitudes: todos los JVM cargan la clase y ejecutan antes de que se ejecute el constructor. Múltiples se pueden definir en la clase. En general, algunas variables estáticas se asignan en el bloque de código.

Diferencia: los bloques de código estático se ejecutan antes de los bloques de código no estatales. Los bloques de código estáticos se ejecutan solo una vez en el primer nuevo y no se ejecutan después. En su lugar, los bloques de código no estatales se ejecutan una vez cada nuevo.

Tres. Ejemplo

Bloque de código ordinario: {} que aparece en un método o declaración se denomina bloque de código normal. La orden de ejecución de los bloques de código ordinarios y las declaraciones generales está determinada por el orden en que aparecen en el código, aparece primero.

 prueba de clase pública {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); }}} / * * Ejecutar la variable de resultado x = 3 en el bloque de código ordinario * variable x = 1 en el método principal * variable y = 7 en el bloque de código ordinario * /

Bloque de código de construcción: un bloque de código que se define directamente en la clase y no tiene una palabra clave estática se llama bloque de código de construcción {}. El bloque de código del constructor se llama al crear un objeto, y cada vez que se crea el objeto, se llama, y el orden de ejecución del bloque de código del constructor tiene prioridad sobre el constructor de clase. Si hay múltiples bloques de código construidos, la orden de ejecución está determinada por el orden en que aparecen en el código, aparece primero la primera ejecución.

 public class test1 {{System.out.println ("primer bloque de construcción");} public test1 (int i) {System.out.println ("th" + i + "subcall" + "constructor");} {system.out.pintln ("segundo bloque de construcción"); Test1 (2);}}/** Resultado de la ejecución Primer bloque de construcción* Segundo bloque de construcción* 0º Constructor de llamadas* Primer bloque de construcción* Segundo bloque de construcción* Primer bloque de construcción* Primer bloque de construcción* Primer bloque de construcción* Segundo bloque de construcción* La segunda llamada al método de construcción*/

Bloque de código estático: un bloque de código declarado utilizando la palabra clave estática en Java. Los bloques estáticos se utilizan para inicializar las clases e inicializar los atributos de la clase. Cada bloque de código estático se ejecutará solo una vez. Dado que el JVM ejecuta bloques de código estático al cargar la clase, el código estático se ejecutan antes del método principal.

Si la clase contiene múltiples bloques de código estático, se ejecutará primero, entonces el código definido se ejecutará más adelante.

Aviso:

1. Los bloques de código estático no pueden existir en ningún cuerpo de método.

2. Los bloques de código estático no pueden acceder directamente a las variables de instancia y a los métodos de instancia, y deben acceder a través del objeto de instancia de la clase.

 public class test3 {public static String static_field = "atributo estático"; // static block static {system.out.println (static_field); system.out.println ("static code block 1");} public string fiel 2 ");} public initoderTest () {System.out.println (" no constructor de parámetros ");} public static void main (string [] args) {initoderTest test = new initoderTest ();} // no-shatic {system.out.println (campo); system.out.println (" no-static coyce 1 ");}// statats statats {System.out.println (static_field); System.out.println ("Bloque de código estático 2");}}/** Ejecute el atributo estático de resultado* Bloque de código estático 1* Atributo estático* Bloque de código estático 2* Atributo no estático* Bloque de código no estático 2* Atributo no estático* Bloque de código no estático 1* Constructor de construcción*/Constructor*//////Estatico Bloque de código Estático

El siguiente código demuestra la relación prioritaria entre los bloques de código individuales de crear un objeto y llamar a un método:

 ¡Persona de clase pública {static {System.out.println ("1. Soy un bloque estático, que tiene prioridad sobre la ejecución del bloque de construcción! ¡y solo se ejecuta una vez cuando se crea el primer objeto!");} {System.out.println ("2. Soy un constructor, que toma precedencia sobre la ejecución del método de construcción! function1 () {system.out.println ("Soy un bloque de código normal en un método no estático, que toma prioridad cuando el método se llama!");} public static void function2 () {system.out.println ("Soy un bloque de código normal en un método estático. El método se ejecuta más tarde que el bloque estatático!");}}}

Clase de prueba:

 public class Hellowrold {public static void main (string [] args) {new Person (). Function1 (); New Person().function1();System.out.println("================================================================================== ================================================================= ================================================================= ================================================================ ================================================================= ================================================================= =================================================================

Resultados de ejecución:

Podemos ver que los bloques estáticos siempre se ejecutan primero, y solo se ejecutarán una vez cuando se cree la primera instancia de la clase; El segundo es el bloque de constructor; y el tercero es el método del constructor.

Resumir

Lo anterior se trata de la explicación detallada de los cuatro bloques de código en Java, y espero que sea útil para todos. Los amigos interesados pueden continuar referiéndose a otros temas relacionados en este sitio. Si hay alguna deficiencia, deje un mensaje para señalarlo. ¡Gracias amigos por su apoyo para este sitio!