Java中初始化块和构造函数的执行顺序-yiteyi-C++库

先决条件： 静态块 , 初始化程序块 , 建造师在Java程序中，可以对方法、构造函数和初始化块执行操作。 实例初始化块 ：IIB用于初始化实例变量。IIB在构造函数之前执行。每次创建类的对象时，它们都会运行。 初始化程序块： 包含在创建实例时始终执行的代码。它用于声明/初始化类的各种构造函数的公共部分。 施工人员： 用于初始化对象的状态。与方法一样，构造函数也包含在对象创建时执行的语句（即指令）集合。

null

Java中初始化块和构造函数的执行顺序

每当类第一次在JVM中加载时，静态初始化块就会运行
初始化块按它们在程序中出现的顺序运行。
实例初始化块在初始化类时和调用构造函数之前执行。它们通常放置在支架中的构造函数上方。

                     // Java code to illustrate order of                   
                     // execution of constructors, static                   
                     // and initialization blocks                   
                     class                               GFG {                   
                             
                                         GFG(                               int                               x)                   
                                         {                   
                                         System.out.println(                               "ONE argument constructor"                               );                   
                                         }                   
                             
                                         GFG()                   
                                         {                   
                                         System.out.println(                               "No  argument constructor"                               );                   
                                         }                   
                             
                                         static                   
                                         {                   
                                         System.out.println(                               "1st static init"                               );                   
                                         }                   
                             
                                         {                   
                                         System.out.println(                               "1st instance init"                               );                   
                                         }                   
                             
                                         {                   
                                         System.out.println(                               "2nd instance init"                               );                   
                                         }                   
                             
                                         static                   
                                         {                   
                                         System.out.println(                               "2nd static init"                               );                   
                                         }                   
                             
                                         public                               static                               void                               main(String[] args)                   
                                         {                   
                                         new                               GFG();                   
                                         new                               GFG(                               8                               );                   
                                         }                   
                     }                   

输出

1st static init
2nd static init
1st instance init
2nd instance init
No  argument constructor
1st instance init
2nd instance init
ONE argument constructor

注：如果有两个或多个静态/初始值设定项块，则它们将按照它们在源代码中出现的顺序执行。

现在，预测以下程序的输出-

                     // A tricky Java code to predict the output                   
                     // based on order of                   
                     // execution of constructors, static                   
                     // and initialization blocks                   
                     class                               MyTest {                   
                                         static                   
                                         {                   
                                         initialize();                   
                                         }                   
                             
                                         private                               static                               int                               sum;                   
                             
                                         public                               static                               int                               getSum()                   
                                         {                   
                                         initialize();                   
                                         return                               sum;                   
                                         }                   
                             
                                         private                               static                               boolean                               initialized =                               false                               ;                   
                             
                                         private                               static                               void                               initialize()                   
                                         {                   
                                         if                               (!initialized) {                   
                                         for                               (                               int                               i =                               0                               ; i <                               100                               ; i++)                   
                                         sum += i;                   
                                         initialized =                               true                               ;                   
                                         }                   
                                         }                   
                     }                   
                             
                     public                               class                               GFG {                   
                                         public                               static                               void                               main(String[] args)                   
                                         {                   
                                         System.out.println(MyTest.getSum());                   
                                         }                   
                     }                   

输出：

说明：

初始化函数中的循环从0到99。考虑到这一点，您可能会认为该程序会打印0到99之间的数字之和。因此，总和为99×100/2，或4950。然而，该项目却持相反看法。它会打印 9900 ，完全是该值的两倍。
为了了解它的行为，让我们追踪它的执行情况。GFG。main方法调用MyTest。getSum。在执行getSum方法之前，VM必须初始化类MyTest。类初始化按静态初始值设定项在源代码中出现的顺序执行。
MyTest类有两个静态初始值设定项：类顶部的静态块和初始化的静态字段。块首先出现。它调用initialize方法，该方法测试初始化的字段。因为没有给这个字段赋值，所以它的默认布尔值为false。
类似地，sum的默认int值为0。因此，initialize方法实现了您期望的功能，将4950相加，并将initialized设置为true。执行静态块后，初始化字段的静态初始值设定项将其设置回false，从而完成MyTest的类初始化。不幸的是，sum现在包含4950，但initialized包含false。
然后，GFG类中的main方法调用MyTest。getSum，它反过来调用initialize方法。由于initializeIf标志为false，initializeIf方法进入其循环，在sum的值上再加上4950，将其值增加到9900。getSum方法返回该值，程序将其打印出来
本文由 Shubham Juneja .如果你喜欢GeekSforgek，并想贡献自己的力量，你也可以使用贡献极客。组织或者把你的文章寄到contribute@geeksforgeeks.org.看到你的文章出现在Geeksforgeks主页上，并帮助其他极客。

如果您发现任何不正确的地方，或者您想分享有关上述主题的更多信息，请写下评论。

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

THE END

Java