Java中的实例初始化块（IIB）-yiteyi-C++库

在Java程序中，可以对方法、构造函数和初始化块执行操作。实例初始化块或IIB用于初始化实例变量。因此，首先调用构造函数，java编译器在第一条语句super（）之后复制构造函数中的实例初始值设定项块。每次创建类的对象时，它们都会运行。

null

初始化块在初始化类时和调用构造函数之前执行。
它们通常放置在支架中的构造函数上方。
在你的课堂上完全没有必要把它们包括在内。

JAVA

                         // Java program to illustrate                       
                         // Instance Initialization Block                       
                         class                                     GfG {                       
                                                 // Instance Initialization Block                       
                                                 {                       
                                                 System.out.println(                                     "IIB block"                                     );                       
                                                 }                       
           
                                                 // Constructor of GfG class                       
                                                 GfG() { System.out.println(                                     "Constructor Called"                                     ); }                       
                                                 public                                     static                                     void                                     main(String[] args)                       
                                                 {                       
                                                 GfG a =                                     new                                     GfG();                       
                                                 }                       
                         }                       

输出

IIB blockConstructor Called

程序中的多个实例初始化块

我们也可以在一个类中有多个IIB。如果编译器发现多个IIB，那么它们都是从上到下执行的，即首先执行在顶部写入的IIB。

JAVA

                         // Java program to illustrate                       
                         // execution of multiple                       
                         // Instance Initialization Blocks                       
                         // in one program                       
                         class                                     GfG {                       
                                                 // Instance Initialization Block - 1                       
                                                 {                       
                                                 System.out.println(                                     "IIB1 block"                                     );                       
                                                 }                       
           
                                                 // Instance Initialization Block - 2                       
                                                 {                       
                                                 System.out.println(                                     "IIB2 block"                                     );                       
                                                 }                       
           
                                                 // Constructor of class GfG                       
                                                 GfG() { System.out.println(                                     "Constructor Called"                                     ); }                       
           
                                                 // Instance Initialization Block - 3                       
                                                 {                       
                                                 System.out.println(                                     "IIB3 block"                                     );                       
                                                 }                       
           
                                                 // main function                       
                                                 public                                     static                                     void                                     main(String[] args)                       
                                                 {                       
                                                 GfG a =                                     new                                     GfG();                       
                                                 }                       
                         }                       

输出

IIB1 blockIIB2 blockIIB3 blockConstructor Called

带有父类的实例初始化块

你也可以在家长课上学习IIB。实例初始化块代码在构造函数中调用super（）后立即运行。编译器在执行当前类的IIB之前先执行父类的IIB。

看看下面的例子。

JAVA

                         // Java program to illustrate                       
                         // Instance Initialization Block                       
                         // with super()                       
           
                         // Parent Class                       
                         class                                     B {                       
                                                 B() { System.out.println(                                     "B-Constructor Called"                                     ); }                       
           
                                                 {                       
                                                 System.out.println(                                     "B-IIB block"                                     );                       
                                                 }                       
                         }                       
           
                         // Child class                       
                         class                                     A                                     extends                                     B {                       
                                                 A()                       
                                                 {                       
                                                 super                                     ();                       
                                                 System.out.println(                                     "A-Constructor Called"                                     );                       
                                                 }                       
                                                 {                       
                                                 System.out.println(                                     "A-IIB block"                                     );                       
                                                 }                       
           
                                                 // main function                       
                                                 public                                     static                                     void                                     main(String[] args)                       
                                                 {                       
                                                 A a =                                     new                                     A();                       
                                                 }                       
                         }                       

输出

B-IIB blockB-Constructor CalledA-IIB blockA-Constructor Called

在上面的例子中，当类A的对象被创建时，编译器试图执行类A的构造函数。但它找到super（）语句，并首先转到父类构造函数执行。在这种情况下，执行顺序如下：

超类的实例初始化块。
超类的构造函数。
类的实例初始化块。
类的构造函数。

要点：

每次创建新实例时，实例初始化块都会运行。
初始化块按它们在程序中出现的顺序运行
实例初始化块在父类构造函数被调用后被调用（即super（）构造函数调用后）

相关文章： Java中的初始值设定项块本文由 维沙尔·加格 .如果你喜欢GeekSforgek，并想贡献自己的力量，你也可以使用贡献极客。组织或者把你的文章寄到contribute@geeksforgeeks.org.看到你的文章出现在Geeksforgeks主页上，并帮助其他极客。如果您发现任何不正确的地方，或者您想分享有关上述主题的更多信息，请写下评论。

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

THE END

Java