Flujo de control estático en Java

El flujo de control estático decide la secuencia de actividades/pasos que se ejecutarán en orden cuando ejecutamos una clase Java que contiene variables, métodos y bloques estáticos. Este artículo explicará cómo se produce el flujo de control estático cada vez que se ejecuta un programa Java.

Requisito previo: bloques estáticos

El mecanismo de flujo de control estático realiza los siguientes 3 pasos en el orden cronológico exacto: 

1. Identificación de miembros estáticos de arriba a abajo. Todas las variables estáticas, métodos y bloques se identifican durante este paso.
2. Ejecución de asignaciones de variables estáticas y bloques estáticos de arriba a abajo.
3. Finalmente, el método principal estático se ejecuta en el último paso del flujo de control estático.

Ejemplo:

// StaticControlFlow class (Main class)
 
class StaticControlFlow {
    // initializing static integer a=100
    static int a = 100;
 
    // static main method
    public static void main(String[] args)
    {
        // calling static method print()
        print();
        System.out.println(
            "Main method has finished its execution");
    }
 
    // first static block
    static
    {
        // displaying value of a
        System.out.println(a);
 
        // calling static method print()
        print();
        System.out.println("Inside First Static Block");
    }
 
    // static method print()
    public static void print()
    {
        // displaying value of b
        System.out.println(b);
    }
 
    // second static block
    static
    {
        System.out.println("Inside Second Static Block");
    }
 
    // initializing static integer b=200
    static int b = 200;
}

100
0
Inside First Static Block
Inside Second Static Block
200
Main method has finished its execution

Explicación: Cuando se ejecuta el programa anterior, el mecanismo de flujo de control estático ejecutará los 3 pasos en orden. Después de identificar los miembros estáticos en el primer paso, ambos bloques estáticos se ejecutan de arriba a abajo. Dentro del primer bloque estático , el valor de la variable ‘a’ es 100 ya que se ha inicializado antes de la ejecución del primer bloque estático.

Pero, dentro del segundo bloque estático , el valor de la variable ‘b’ aún no se inicializa según el flujo de control estático. Entonces, la JVM imprimirá 0 como el valor predeterminado de una variable estática no inicializada.

Luego, durante el tercer y último paso, se ejecuta el método principal estático. Dentro del método principal, se vuelve a llamar al método estático print(), y esta vez imprime b = 200 cuando la variable ‘b’ se inicializa durante el segundo paso.

Referencia directa e indirecta

Si tratamos de leer y mostrar el valor de una variable dentro del bloque estático, esa operación de lectura se llama lectura directa. Si llamamos a un método desde un bloque estático, y dentro de ese método, si estamos tratando de leer una variable, esa operación de lectura se llama lectura indirecta.

En el ejemplo anterior, al imprimir el valor de la variable ‘a’ dentro del primer bloque estático, se considera una operación de lectura directa. Sin embargo, se invoca un método estático print() dentro del mismo bloque estático y se imprime el valor de la variable ‘b’. Esto se considera una operación de lectura indirecta.

Supongamos que la JVM identifica una variable y aún no la ha inicializado con su valor original. En ese caso, se dice que la variable está en estado de solo lectura indirecta y escritura (RIWO). Después del primer paso del flujo de control estático, tanto las variables ‘a’ como ‘b’ están en el estado RIWO.

Estado RIWO

Cuando se ejecuta una clase Java, hay algunos pasos que JVM realiza algunos pasos secuencialmente.

• Identifique los miembros estáticos de arriba a abajo.
• Ejecuta asignaciones de variables estáticas y bloques estáticos de arriba a abajo.
• Ejecuta el método principal.

Durante estas fases, existe uno de esos estados llamado RIWO (Read Indirectly Write Only) para una variable estática.

Durante RIWO no se puede acceder directamente a una variable con su referencia. En cambio, necesitamos usar una forma indirecta de llamar a ciertas variables.

Por ejemplo:

class Riwo {
   static int i = 10;
   static {  
     System.out.println(i);  
   }
}

En el caso anterior, la salida es 10.

// Java program to demonstrate the
// working of RIWO state in Java
 
class Riwo {
    static int i = 10;
    static
    {
        m1();
        System.out.println("block1");
    }
 
    public static void main(String[] args)
    {
        m1();
        System.out.println("block main");
    }
 
    public static void m1()
    {
        System.out.println(j);
        System.out.println("block m1");
    }
 
    static int j = 20;
    static {
      System.out.println("end of code");
    }
}

0
block m1
block1
end of code
20
block m1
block main

// Java program to demonstrate the error
// while working of RIWO state in Java
 
class Riwo {
    static
    {
        System.out.println(i);
        System.out.println("block1");
    }
    static int i = 10;
    public static void main(String[] args)
    {
        System.out.println("main block");
    }
}

Salida: en el caso anterior, obtenemos el siguiente error en tiempo de compilación

prog.java:7: error: illegal forward reference
        System.out.println(i);
                           ^
1 error

Eso significa que no podemos leer una variable estática directamente cuando está en el estado RIWO. Deberíamos llamar a la variable indirectamente usando un método.