Flujo de control de instancias en Java

Este artículo explicará cómo se lleva a cabo el flujo de control de instancia cada vez que se crean objetos.

Flujo de control de instancia en clase normal

Siempre que estemos ejecutando un archivo java .class, se ejecutará el primer flujo de control estático . En el flujo de control estático, si estamos creando un objeto, se ejecutará la siguiente secuencia de pasos como parte del flujo de control de instancia:

1. Identificación del miembro de la instancia de arriba a abajo.
2. Ejecución de asignaciones de variables de instancia y bloques de instancia de arriba a abajo.
3. Ejecución del constructor.

Ejemplo:

// InstanceControlFlow class
class InstanceControlFlow {
 
    // initializing instance integer i = 10
    int i = 10;
 
    // first instance block
    {
        // call instance method (methodeOne())
        methodOne();
        System.out.println("First Instance Block");
    }
 
    // constructor
    InstanceControlFlow()
    {
        System.out.println("Constructor");
    }
 
    // main method
    public static void main(String[] args)
    {
        // create InstanceControlFlow class object
        InstanceControlFlow f = new InstanceControlFlow();
        System.out.println("Main method");
    }
 
    // instance method (methodOne())
    public void methodOne() { System.out.println(j); }
 
    // second instance block
    {
        System.out.println("Second Instance Block");
    }
 
    // initializing instance integer j = 20
    int j = 20;
}

0
First Instance Block
Second Instance Block
Constructor
Main method

Explicación:

Cuando se ejecute el programa anterior, en primer lugar se producirá un mecanismo de flujo de control estático en el que se crea el objeto de clase, lo que hace que el mecanismo de flujo de control de instancia funcione en la siguiente secuencia.

En primer lugar, identificará el miembro de la instancia de arriba a abajo. Después de identificar los miembros de la instancia en el primer paso, ambos bloques de instancia se ejecutan de arriba a abajo. Al principio, dentro del bloque de primera instancia, llamamos al método methodOne() , y dentro de ese método, imprimimos el valor de la variable ‘j’. JVM imprime el valor de la variable ‘j’ como 0 porque solo se inicializó y aún no se le asignó el valor real, luego se ejecuta el bloque de segunda instancia.

Entonces, por fin, tendrá lugar la ejecución del constructor.

Nota: El flujo de control estático es una actividad única y se ejecutará en el momento de la carga de la clase, pero el flujo de control de instancia no es una actividad única para cada creación de objeto que se ejecutará.

Flujo de control de instancia en la relación padre a hijo

Siempre que estemos creando un objeto de clase hijo, la siguiente secuencia de eventos se ejecutará automáticamente:

1. Identificación de miembros de instancia de padre a hijo.
2. Ejecución de asignaciones de variables de instancia y bloques de instancia solo en la clase principal.
3. Ejecución del constructor de la clase Padre.
4. Ejecución de asignaciones de variables de instancia y bloques de instancia en clase Child.
5. Ejecución del constructor de la clase Child.

Ejemplo:

// Parent class
class Parent {
 
    // initializing instance integer x = 10
    int x = 10;
 
    // first instance block of Parent class
    {
        // call instance method (methodeOne())
        methodOne();
        System.out.println("Parent First Instance Block");
    }
 
    // constructor of Parent class
    Parent()
    {
        System.out.println("Parent Class Constructor");
    }
 
    // main method of Parent class
    public static void main(String[] args)
    {
        // create Parent class object
        Parent p = new Parent();
        System.out.println("Parent Class Main Method");
    }
 
    // instance method (methodOne())
    public void methodOne() { System.out.println(y); }
 
    // initializing instance integer y = 20
    int y = 20;
}
 
// Child class
class Child extends Parent {
 
    // initializing instance integer i = 100
    int i = 100;
 
    // first instance block of Child class
    {
        methodTwo();
        System.out.println("Child First Instance Block");
    }
 
    // constructor of Child class
    Child()
    {
        System.out.println("Child Class Constructor");
    }
 
    // main method of Child class
    public static void main(String[] args)
    {
        // create Child class object
        Child c = new Child();
        System.out.println("Child Class Main Method");
    }
 
    // instance method (methodTwo())
    public void methodTwo() { System.out.println(j); }
 
    // second instance block of Child class
    {
        System.out.println("Child Second Instance Block");
    }
 
    // initializing instance integer j = 200
    int j = 200;
}

0
Parent First Instance Block
Parent Class Constructor
0
Child First Instance Block
Child Second Instance Block
Child Class Constructor
Child Class Main Method

Explicación:

Cuando se ejecute el programa anterior, en primer lugar se producirá un mecanismo de flujo de control estático en el que se crea un objeto de clase secundario que hace que el mecanismo de flujo de control de instancia funcione en la siguiente secuencia.

En primer lugar, identificará el miembro de la instancia de padre a hijo. Después de identificar los miembros de la instancia en el primer paso, los bloques de la instancia se ejecutan en la clase principal de arriba a abajo. Al principio, dentro del bloque de primera instancia de la clase Padre, llamamos al método methodOne() , y dentro de ese método, imprimimos el valor de la variable ‘y’. JVM imprime el valor de la variable ‘y’ como 0 porque solo se inicializó y aún no se le asignó un valor real, luego se ejecuta el constructor de la clase principal.

En segundo lugar, los bloques de instancia se ejecutan en la clase Child de arriba a abajo. Dentro del bloque de primera instancia de la clase Child, llamamos al método methodTwo(), y dentro de ese método, imprimimos el valor de la variable ‘j’. JVM imprime el valor de la variable j como 0 porque se acaba de inicializar y aún no se le asigna el valor real.

Luego, se ejecuta el último constructor de la clase Child.

Nota: la creación de objetos es la operación más costosa en Java y, por lo tanto, si no hay un requisito específico, nunca se recomienda crear objetos.

Referencia directa e indirecta

Dentro del bloque de instancia, si estamos tratando de leer una variable, esa operación de lectura se llama Lectura directa . Dentro del bloque de instancia, si estamos llamando a un método y dentro de ese método, si estamos tratando de leer una variable, esa operación de lectura se llama lectura indirecta .

Ejemplo:

// DirectIndirectRead class
class DirectIndirectRead {
 
    // initializing instance integer i = 10
    int i = 10;
 
    // instance block
    {
        methodOne(); // -> Indirect Read
        System.out.println(i); // -> Direct Read
    }
 
    // instance method (methodOne())
    public void methodOne() { System.out.println(i); }
 
    // main method
    public static void main(String[] args)
    {
        // create DirectIndirectRead class object
        DirectIndirectRead d = new DirectIndirectRead();
    }
}

10
10

1. Estado RIWO (solo lectura indirecta y escritura)

Si la JVM solo identifica una variable y el valor original no se asigna, se dice que la variable está en estado RIWO [solo lectura indirecta y escritura]. Si una variable está en el estado RIWO [Solo lectura indirecta y escritura], entonces no podemos realizar la Lectura directa , pero podemos realizar la Lectura indirecta . Si estamos tratando de leer directamente, obtendremos un error de tiempo de compilación que dice:  

Ejemplo 1

// RIWODemo1 class
class RIWODemo1 {
 
    // instance block
    {
        System.out.println(i); // -> Direct Read
    }
 
    // main method
    public static void main(String[] args)
    {
        // create RIWODemo1 class object
        RIWODemo1 r = new RIWODemo1();
    }
 
    // initializing instance integer i = 10
    int i = 10;
}

 
Producción

prog.java:6: error: illegal forward reference
        System.out.println(i); // -> Direct Read
                           ^
1 error

Ejemplo 2

// RIWODemo2 class
class RIWODemo2 {
 
    // instance block
    {
        methodOne();
    }
 
    // instance method (methodOne())
    public void methodOne() { System.out.println(i); }
 
    // main method
    public static void main(String[] args)
    {
        // create RIWODemo2 class object
        RIWODemo2 r = new RIWODemo2();
    }
 
    // initializing instance integer i = 10
    int i = 10;
}

0

2. Estado R & W (lectura y escritura)

En el estado R & W (lectura y escritura), la JVM asignó sus respectivos valores originales a las variables como se menciona en el código .

Ejemplo:

// RW class
class RW {
 
    // initializing instance integer i = 10
    int i = 10;
 
    // instance block
    {
        System.out.println(i);
    }
 
    // main method
    public static void main(String[] args)
    {
        // create RW class object
        RW r = new RW();
    }
}

10