java程序初始化 - 副本

2023-07-24 12:30:10

java程序初始化

初始化顺序

类的加载

对象的生成

1. 程序初始化的顺序

程序运行时的初始化顺序

不同属性和方法执行初始化的特点和注意事项

总结:
1、当程序执行时，需生成某个类的对象，Java解释器会先检查是否加载了相关的类，若未加载，则会先执行类的加载，再生成对象，若已经加载，则直接生成对象。
2、类的加载过程，当首次创建某个类的对象或未创建对象而是直接首次访问该类的static方法或static字段时，Java 解释器必须找到*.class（字节码文件），找到后，类的static成员变量会被初始化，此外若存在static代码块，则会执行static代码块，静态的成员变量和static代码块的执行顺序是按其在程序中定义的先后顺序来执行的。

注意：类是按需加载且只加载一次，因此静态代码块和静态成员变量也只初始化一次，也就是说，如果不创建对象且不引用static方法或static字段，则不会执行初始化。

3、创建对象的过程，类加载完成后，会进行对象的创建，对象的构建进程首先会在内存堆（Heap）里为一个该对象分配足够多的存储空间，然后先执行对象成员变量的初始化，再执行构造器，也就是说对象的成员变量会在构造器和其他方法被执行调用之前完成初始化，不论成员变量被定义在方法的前面或者后面。

2. 初始化例子

                //: StaticInitialization.java
                // Specifying initial values in a
                // class definition.
                class Bowl {
                     Bowl(int marker) {
                    	 System.out.println("Bowl(" + marker + ")");
                     }
                     void f(int marker) {
                    	 System.out.println("f(" + marker + ")");
                     }
                }
                
                class Table {
                     static Bowl b1 = new Bowl(1);
                     Table() {
                         System.out.println("Table()");
                         b2.f(1);
                     }
                     void f(int marker) {
                     	System.out.println("f2(" + marker + ")");
                     }
                     static Bowl b2 = new Bowl(2);
                }
                
                class Cupboard {
                     Bowl b3 = new Bowl(3);
                     static Bowl b4 = new Bowl(4);
                     Cupboard() {
                         System.out.println("Cupboard()");
                         b4.f(2);
                     }
                     void f3(int marker) {
                    	 System.out.println("f3(" + marker + ")");
                     }
                     static Bowl b5 = new Bowl(5);
                }
                
                public class StaticInitialization {
                     public static void main(String[] args) {
                         System.out.println（"Creating new Cupboard() in main");
                         new Cupboard();
                         System.out.println("Creating new Cupboard() in main");
                         new Cupboard();
                         t2.f2(1);
                         t3.f3(1);
                     }
                     static Table t2 = new Table();
                     static Cupboard t3 = new Cupboard();
                }
                
                
                输出结果：
                			   Bowl(1)
                                Bowl(2)
                                Table()
                                f(1)
                                Bowl(4)
                                Bowl(5)
                                Bowl(3)
                                Cupboard()
                                f(2)
                                Creating new Cupboard() in main
                                Bowl(3)
                                Cupboard()
                                f(2)
                                Creating new Cupboard() in main
                                Bowl(3)
                                Cupboard()
                                f(2)
                                f2(1)
                                f3(1)

1、运行程序，加载main方法所在的StaticInitialization类，首先依次执行StaticInitialization类中的静态变量t2和t3的初始化，即创建Table对象和Cupboard对象。

2、创建Table对象，先执行Table类的加载，并执行Table类中静态变量b1的初始化，即创建Bowl类的对象，调用Bowl类的构造器，打印输出 Bowl(1)；再执行静态变量b2的初始化，同b1，打印输出 Bowl(2)，最后调用Table类的构造器，打印输出 Table()，执行 b2.f(1)，调用b2的f()方法，打印 f(1)。

3、创建Cupboard对象，同Table对象，先执行Cupboard类的加载，并执行Cupboard类中静态变量b4和b5的初始化，依次打印输出 Bowl(4) 和 Bowl(5)，然后执行普通成员变量 b3的初始化，打印输出Bowl(3)，最后调用Cupboard类的构造器，打印输出 Cupboard()，执行 b4.f(2)，调用b2的f()方法，打印f(2) 。

4、从上向下依次执行main方法的语句，首先打印输出 Creating new Cupboard() in main，再执行创建Cupboard对象，注意，此时Cupboard对象并非首次创建，Cupboard类的加载以及类中的静态变量的初始化都已执行过一次，所以不再执行，但普通成员变量会再次执行初始化，打印输出 Bowl(3)，调用构造器，打印输出Cupboard()和 f(2) ,然后程序继续执行main方法剩余的语句，打印 Creating new Cupboard() in main，再次创建Cupboard对象，过程与上述完全相同，打印 Bowl(3)、Cupboard() 和 f(2)，最后执行两个方法调用，打印输出f2(1) 和 f3(1)，结束。

注意: 如果不创建对象且不引用static方法或static字段，相关类不会加载，也不会执行初始化。

补充：
程序创建对象实例的内存机制：
运行程序，类StaticInitialization的字节码文件加载到方法区，Java虚拟机自动调用main方法，main方法的操作指令压栈，进入栈内存，创建一个类的对象时，对象的构建进程首先会在内存堆（Heap）里为一个该对象分配足够多的存储空间，并产生内存空间的地址值，对对象的成员变量进行初始化，调用构造器，并将地址值赋给在栈内存中存储的我们已定义的该对象类型的变量，到此对对象的定义和创建。当程序执行中调用其他方法时，也会进行栈内存的压栈，当方法执行完毕后，会进行弹栈处理，将栈中的方法释放。

初学Java，日常总结，本文程序案例引用自《Java编程思想（第四版）》，文中总结部分中有部分参考自其它大神博文，如有侵权，请及时联系。

码农公寓