1. 我们可以用构造器来进行初始化,保证对象内的变量在new 的之前已经被初始化完成了。这样我们new 玩之后就可以直接调用了。
    1. public Class Counter{
    2. int i;
    3. Counter(){
    4. i=7; }
    5. }

    初始化顺序:在类的内部,变量定义的顺序决定了初始化的顺序,他们会在任何方法(包括扩构造器)被调用之前得到初始化。

    1. class Window{
    2. Window(int marker){
    3. System.out.println("Window的无参构造方法"+marker);
    4. }
    5. }
    6. class House{
    7. Window window1=new Window(1);
    8. House(){
    9. window3 =new Window(33);
    10. System.out.println("House构造方法");
    11. }
    12. Window window2=new Window(2);
    13. Window window3=new Window(3);
    14. }
    15. public class Test03 {
    16. public static void main(String[] args) {
    17. House house = new House();
    18. }
    19. }
    20. Output
    21. Window的无参构造方法1
    22. Window的无参构造方法2
    23. Window的无参构造方法3
    24. Window的无参构造方法33
    25. House构造方法

    通过上述代码我们发现,我们把Window对象分散到代码各处,他们都会按定义的顺序去执行初始化,然后是构造器的初始化化。这也就验证了我们所说的变量的初始化会在任何方法(包括构造器)调用之前执行。注意,如果我们采用类的形式直接去调用静态方法,此时,普通的成员变量将不会被初始化,因为没有为对象在堆中开辟空间。
    静态数据的初始化:无论我们创建多少个对象,都会在这个类加载到jvm的时候先去初始化静态对象(静态变量和静态代码块),而且仅仅执行一次(静态方法可以在静态方法中调用)。

    1. class Bowl{
    2. Bowl(int marker){
    3. System.out.println(marker);
    4. }
    5. void f(int i){
    6. System.out.println("f()"+i);
    7. }
    8. }
    9. class Table{
    10. static Bowl b1=new Bowl(1);//静态变量
    11. Bowl b2=new Bowl(2);
    12. Table() {
    13. Bowl b3=new Bowl(3);
    14. System.out.println("table的无参构造方法");
    15. }
    16. static {//静态代码块
    17. init();//调用静态方法
    18. }
    19. void test(int i){
    20. System.out.println("test()"+i);
    21. }
    22. static void init(){//静态方法
    23. System.out.println("init()被静态代码块调用");
    24. }
    25. }
    26. public class StaticTest {
    27. public static void main(String[] args) throws ClassNotFoundException {
    28. Table table = new Table();
    29. }
    30. }
    31. Output
    32. 1
    33. init()被静态代码块调用
    34. 2
    35. 3
    36. table的无参构造方法
    1. 通过上述代码,我们可以看出,优先被初始化的是静态变量和静态代码块,而且无论是静态变量还是静态代码块,在初始化时并无优先级。其次是普通变量(基本变量和引用变量)和普通代码块,且无论普通代码块和普通变量在初始化时也无优先级。最后是构造器的初始化。<br /> 最后我们可以总结出一个类被加载的过程:
    1. 当我们首次创建类的时候,或者类的静态方法(构造方法也是静态方法)和静态域被首次访问时,定位类class文件
    2. 当载入类文件到jvm时,有关静态域和静态方法的所有初始化动作都会被执行。且只执行一次。
    3. 在堆上为对象分配足够的存储空间(通过new 来创建类的时候),同时自动的将对象中的基本数据类型和引用数据类设置默认类型(引用类型为null).
    4. 执行说的普通域(普通变量和普通代码块)的初始化化动作(普通变量包括基本变量和引用变量)。
    5. 执行对象中的构造器。