Instance Control Flow in Java - GeeksforGeeks

17 Dec, 2021
This article will explain how Instance Control Flow takes place whenever objects are created.
Whenever we are executing a java .class file, 1st Static Control Flow will be executed. In the Static Control Flow, if we are creating an object the following sequence of steps will be executed as part of Instance Control Flow:
Identification of instance member from top to bottom.Execution of instance variable assignments and instance blocks from top to bottom.Execution of constructor.
Identification of instance member from top to bottom.
Execution of instance variable assignments and instance blocks from top to bottom.
Execution of constructor.
Example:
Java
// InstanceControlFlow classclass 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
Explanation:
When the above program will be executed, firstly Static Control Flow mechanism will occur in which class object is created which causes the Instance Control Flow mechanism in working as the following sequence.
Firstly, it will identify the instance member from top to bottom. After identifying instance members in the first step, both the instance blocks are executed from top to bottom. At first, inside the first instance block, we call methodOne() method, and inside that method, we print the value of variable ‘j’. JVM print value of variable ‘j’ as 0 because it is just initialized and yet not assigned with actual value, then the second instance block is executed.
Then, at last, the execution of the constructor will take place.
Note: Static Control Flow is a one-time activity and it will be executed at the time of class loading, but Instance Control Flow is not a one-time activity for every object creation it will be executed.
Whenever we are creating a child class object the following sequence of events will be executed automatically:
Identification of instance members from Parent to Child.Execution of instance variable assignments and instance blocks only in Parent class.Execution of Parent class constructor.Execution of instance variable assignments and instance blocks in Child class.Execution of Child class constructor.
Identification of instance members from Parent to Child.
Execution of instance variable assignments and instance blocks only in Parent class.
Execution of Parent class constructor.
Execution of instance variable assignments and instance blocks in Child class.
Execution of Child class constructor.
Example:
Java
// Parent classclass 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 classclass 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
Explanation:
When the above program will be executed, firstly Static Control Flow mechanism will occur in which a child class object is created which causes the Instance Control Flow mechanism in working as the following sequence.
Firstly, it will identify the instance member from Parent to Child. After identifying instance members in the first step, the instance blocks are executed in the Parent class from top to bottom. At first, inside the first instance block of Parent class, we call methodOne() method, and inside that method, we print the value of variable ‘y’. JVM print value of variable ‘y’ as 0 because it is just initialized and yet not assigned with actual value, then Parent class constructor is executed.
Secondly, the instance blocks are executed in the Child class from top to bottom. Inside the first instance block of the Child class, we call methodTwo() method, and inside that method, we print the value of variable ‘j’. JVM prints the value of variable j as 0 because it is just initialized and yet not assigned with the actual value.
Then At last Child class constructor is executed.
Note: Object creation is the most costly operation in java and hence if there is no specific requirement never recommended to create objects.
Direct and Indirect Reference
Inside instance block, if we are trying to read a variable that read operation is called Direct Read. Inside instance block, If we are calling a method and within that method, if we trying to read a variable that read operation is called Indirect Read.
Example:
Java
// DirectIndirectRead classclass 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. RIWO (Read Indirectly Write Only) State
If a variable is just identified by the JVM and the original value, not assigned then the variable is said to be in RIWO[Read Indirectly Write Only] state. If a variable is in RIWO[Read Indirectly Write Only] state then we can’t perform Direct Read but we can perform Indirect Read. If we are trying to read directly then we will get a compile-time error saying:  
Example 1
Java
// RIWODemo1 classclass 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;}
 Output
prog.java:6: error: illegal forward reference
        System.out.println(i); // -> Direct Read
                           ^
1 error
Example 2
Java
// RIWODemo2 classclass 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. R & W (Read & Write) State
In R & W(read and write) state the JVM assigned their respective original values to the variables as mentioned in code.
Example:
Java
// RW classclass 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
nishkarshgandhi
Java-Object Oriented
Technical Scripter 2020
Java
Technical Scripter
Java
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Stream In Java
Constructors in Java
Different ways of Reading a text file in Java
Exceptions in Java
Functional Interfaces in Java
Generics in Java
Comparator Interface in Java with Examples
Introduction to Java
HashMap get() Method in Java
Strings in Java