Java中的静态控制流-yiteyi-C++库

静态控制流决定了当我们运行一个包含静态变量、方法和块的java类时，将按顺序执行的活动/步骤的顺序。本文将解释每当执行Java程序时，静态控制流是如何发生的。

null

先决条件： 静态块

静态控制流机制按照精确的时间顺序执行以下3个步骤：

从上到下识别静态构件。在此步骤中，所有静态变量、方法和块都会被识别。
从上到下执行静态变量赋值和静态块。
最后，在静态控制流的最后一步执行static main方法。

例子：

JAVA

                         // 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                                     ;                       
                         }                       

输出

1000Inside First Static BlockInside Second Static Block200Main method has finished its execution

说明： 当执行上述程序时，静态控制流机制将按顺序执行3个步骤。在第一步中识别静态成员后，两个静态块都从上到下执行。里面 第一个静态块 ，变量的值 “a” 是100，因为它在第一个静态块执行之前已经初始化。

但是，在 第二个静态块 ，变量的值 “b” 尚未按照静态控制流初始化。因此，JVM将打印0作为未初始化静态变量的默认值。

然后，在第三个也是最后一个步骤中，执行static main方法。在main方法内部，再次调用静态方法print（），这一次它打印b=200，因为变量“b”在第二步初始化。

直接和间接引用

如果我们试图在静态块内读取并显示变量的值，则该读取操作称为直接读取。如果我们从静态块调用一个方法，并且在该方法中，如果我们试图读取一个变量，那么该读取操作称为间接读取。

在上面的示例中，当在第一个静态块内打印变量“a”的值时，它被视为直接读取操作。但是，在同一静态块中调用静态方法print（），并打印变量“b”的值。这被认为是一种间接读取操作。

假设一个变量由JVM标识，但尚未由其原始值初始化。在这种情况下，变量被称为处于只读间接写（RIWO）状态。在静态控制流的第一步之后，变量“a”和“b”都处于RIWO状态。

里沃州

在执行java类时，JVM会按顺序执行几个步骤。

从上到下识别静态成员。
从上到下执行静态变量分配和静态块。
执行main方法。

在这些阶段中，静态变量有一种称为RIWO（只读间接写）的状态。

在RIWO期间，变量不能通过其引用直接访问。相反，我们需要使用一种间接的方式来调用某些变量。

例如：

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

在上述情况下，输出为10。

JAVA

                         // 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"                                     );                       
                                                 }                       
                         }                       

输出

0block m1block1end of code20block m1block main

JAVA

                           // 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"                                        );                         
                                                     }                         
                           }                         

输出： 在上述情况下，我们得到以下编译时错误

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

这意味着当静态变量处于RIWO状态时，我们不能直接读取它。我们应该使用方法间接调用变量。

文章版权归作者所有，未经允许请勿转载。

THE END

Java