Java的初始化顺序

[oueiang]

java中的初始化顺序究竟是怎样的，是先static，后一般变量，再后是构造函数吗？而且顺序应该是从根基类向下来的吧。但是这个又是怎么回事啊？在下实在迷惘，望个中高手指点一下！

[johnsoncr]

http://hi.baidu.com/johnsoncr/blog/item/567053134b45c1015aaf5390.html

[sharpyuce]

我以前写的一篇文章，介绍得很详细，你自己去看吧~
http://blog.csdn.net/sharpyuce/archive/2007/10/21/1835079.aspx

[wangqiyy]

用例子说明问题，然后用调试的方式看看就可以了

首先static变量，然后static的过程，然后类变量，最后构造函数


//SampleStatic.java
public class SampleStatic {

String other="other";
static String first="first";
static String second;
static{
second="second";
}

public Long2Float(){
this.other="last";
}

public String toString(){
StringBuffer sb=new StringBuffer();
sb.append("first=")
.append(first).append(" ")
.append("second=").append(second).append(" ")
.append("other=").append(this.other);
return sb.toString();
}

}

//OtherMain.java
public class OtherMain {

public static void main(String[] args){
SampleStatic lf=new SampleStatic ();
System.out.println(lf.toString());
}
}

[blue_winding]

类的初始化确实是一个不容易让人知道的过程,因为它的执行是有JVM控制的,程序员是看不到的.

我对类初始话的理解也不是很透彻,但在这里还是要罗嗦几句,如果不正确,还望高手们海涵,不要

吐我,呵呵.

首先,JVM在对类初始化时调用了JVM内部的方法<init>和<clint>.<clint>是对类的类成员和

和静态语句块进行初始化(static部分);而<init>是对实例变量和一般语句块进行初始化的.

所以,我认为java的初始化过程很麻烦,呵呵,但也请听我慢慢道来,类在初始化时会把类变量(有

static修饰的变量)静态语句块(static{ code })放在第一位,其次是一般语句块({ code }),然

后再是构造函数,构造函数会去初始化类的一般成员变量.如果有继承关系的话,当然是先父类先初始化,

详细过程如下:

a 父类静态成员和静态初始化块
b 子类静态成员和静态初始化块
c 父类实例成员和实例初始化块
d 父类构造方法
e 子类实例成员和实例初始化块
f 子类构造方法

[Norris_Zhang]

嗯，这个问题其实一般的JAVA基础书里都会写，不过初学的还真不容易看懂，如果有过一段时间的编程经验了呢，又发现其实这个问题也没什么好深究的（如果为了给别人讲，或者出书什么的，还是要搞明白），实际的应用中知道最后的结果是什么样的就够用了，如果真的到一定要了解这个问题的时候，其实再回去查一下权威的书，也很容易看懂，看懂了也没必要把它背下来。

呵呵，个人意见，当然有本人懒堕的思想在作怪，如果能很快把这个问题搞明白当然还是搞明白好，如果初学者搞了好久也没搞明白，建议放一放，先往后学，也没什么大碍

[lihaifeng0412]

说的都不错，我也没有什么说的。学习一下

[abelking]

new Xxx():

1 为新对象分配空间并将其成员初始化为0或者null
2 执行类体中的初始化（eg:在类中有一个成员声明为int a=100;则在第一步后a=0,执行到第二步后a=100）
3 执行构造函数
4 变量被分配为一个到内存堆中的新对象的引用

(static比non-static早初始化)

[l52100]

先静态 再构造 再实力

[mobin3000]

首先要明确的是:如果这个类没有被调用或创建实例的话,是不会初始化的!(如子类被调用才导致super类被调用)
然后的初始化顺序是:
1.static变量(其初始化不受声明的位置影响)
2.类中的域(或者说是属性,变量)
基本类型变量初始化为对应的初始值,不应该片面的说是0,如boolean初始值为false;
类中的对象名其实是一个引用,所以初始化为NULL;
3.构造函数.

[oueiang]

说的比较详细了，我个人觉得还是举例的那位比较高一筹，因为空谈总是不行，看来那位英语应该不错，学习的方法好。在此谢谢了各位……

[陈宝峰]

可以参考一下这个文章：http://blog.csdn.net/stevencn76/archive/2007/11/09/1875621.aspx

[lilifb]

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);//2
  Table() {//4
    System.out.println("Table()");
    b2.f(1);//5
  }
  void f2(int marker) {
    System.out.println("f2(" + marker + ")");
  }
  static Bowl b2 = new Bowl(2);//3
}

class Cupboard {
  Bowl b3 = new Bowl(3);//9  //14   //19
  static Bowl b4 = new Bowl(4);//7
  Cupboard() {//10  //15    //20
    System.out.println("Cupboard()");
    b4.f(2);//11  //16   //21
  }
  void f3(int marker) {
    System.out.println("f3(" + marker + ")");
  }
  static Bowl b5 = new Bowl(5);//8
}

public class StaticInitialization {
  public static void main(String[] args) {
    System.out.println(
      "Creating new Cupboard() in main");//12
    new Cupboard();//13
    System.out.println(
      "Creating new Cupboard() in main");//17
    new Cupboard();//18
    t2.f2(1);//22
    t3.f3(1);//23
  }
  static Table t2 = new Table();//  1
  static Cupboard t3 = new Cupboard();//6
}
/**
 *Bowl允许我们检查一个类的创建过程，而Table和Cupboard能创建散布于类定义中的Bowl的static成员。
 *注意在static定义之前，Cupboard先创建了一个非static的Bowl b3。它的输出结果如下：
//来源，JAVA编程思想第4章 初始化和清除

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)

 *
 *
 *
 *
 *
 *
 *
 *
 *
 */

[oueiang]

倘若再说我不明白众人定要说我是猪脑，可是我还真的是有点明白了，可是还有不明白……
我说说大家看对不对哦：
首先是将分配给对象的存储空间初始化为二进制0，然后加载含main的类，若是它是继承自别的类，则追根到源，从根到继承类的static成员开始初始化，然后是创建对象，先是根类中的普通变量被设为默认值，然后是根的构造函数，然后是根的变量按顺序被初始化，最后按照这样的顺序从下至下执行完。
就是一点我不明白，类中的成员方法什么时候执行啊？是在一个类构造函数执行完就执行类其余部分，还是等所有的都执行完才轮到它啊？

[andevele]

package c05.net;

class Bowl {
Bowl(int marker) {
System.out.println("Bowl(" + marker + ")");
}

void f1() {
System.out.println("Ok");
}
}

class Cupboard {
Bowl b1 = new Bowl(1);

static Bowl b2 = new Bowl(2);

Cupboard() {
System.out.println("Cupboard()");
}

static Bowl b3 = new Bowl(3);
}

class Table {
Table() {
System.out.println("Table()");
}
Table(String a,int i){
this();
System.out.println("Ok");
}
}

public class Order {
static Cupboard t1 = new Cupboard();

static Table t2;

Bowl t3 = new Bowl(10);

void print() {
t3.f1();
}

public static void main(String[] args) {
System.out.println("Creating new Cupboard() in main");
new Cupboard();
System.out.println("Creating new Cupboard() in main");
Order od = new Order();
od.t3.f1();
Table t4 = new Table("aa",1);
}
}

运行结果：

Bowl(2)
Bowl(3)
Bowl(1)
Cupboard()
Creating new Cupboard() in main
Bowl(1)
Cupboard()
Creating new Cupboard() in main
Bowl(10)
Ok
Table()
Ok


分析：首先程序从public类开始，装载Order,class，运行static Cupboard t1 = new Cupboard();

由于t1是一个对象引用变量，首先得到初始化，然后转到Cupboard类的实例中，这时候程序开始初始化

该实例中的变量，按照先static后非static变量初始化的顺序原则开始初始化各个变量，此时，

static Bowl b2 = new Bowl(2);

static Bowl b3 = new Bowl(3);


这两块先得到初始化

然后 Bowl b1 = new Bowl(1);得到初始化（注意，这是非stataic变量）

然后转到Cupboard() 构造函数。

此时Cupboard类已经初始化完毕，程序返回到public类中，又发现有 static Table t2;

开始初始化，由于t2只是个声明的变量，并没有创建一个Table对象让它指向，因此不要管这个t2变量。

在public类中，由于此时再没有static变量可以初始化，那么程序转到static方法main中进行，

（注意：Bowl t3 = new Bowl(10); 这一句为什么得不到初始化，是因为此时没有创建类Order的实例，所以程序目前还不会初始化该代码，至于以后会不会初始化，还要看在main方法中是否会创建Order类的实例，如创建了，则一定初始化，否则不会。）

在main方法中，

System.out.println("Creating new Cupboard() in main");//首先打印该行要输出的语句


new Cupboard(); //创建了Cupboard类的实例，程序转到Cupboard中进行变量初始化，此时要注意：

static变量的初始化，它只能初始化一次，也就是说，如果前面已经初始化过了，那么此时就不必要再初

始化了，这一点要牢记！！！




System.out.println("Creating new Order() in main");//程序转入此行打印要输出的语句


Order od = new Order();//创建Order对象实例，程序转入实例od中，此时Bowl t3 = new Bowl(10);

这一句的t3会得到初始化，程序转到Bowl类中进行有关的操作，操作完后返回到main方法中


od.t3.f1(); //调用实例t3中的方法f()


Table t4 = new Table("aa",1); //创建Table类的实例，让t4指向这个实例，t4得到初始化，调用Table含

有参数的构造方法，程序进行下去。



这样就完成了对这个程序的真个的流程的分析，如果有错误的地方，或者还要补充的地方，还希望大家

指点一下，谢谢！！！


最后再总结一下：

初始化顺序是：

（1） 先是父类的static变量和static初始化块

（2）然后是子类的static变量和static初始化块

（3）父类的实例变量、初始化快

（4）父类的构造方法

（5）子类的实例变量、初始化快

（6）子类构造方法

[ftgreat]

学习～
楼上很详细

[believefym]

http://blog.csdn.net/believefym/archive/2007/11/11/1879183.aspx

[jqiangtc]

学习,一个比一个详细..

[oueiang]

嘻嘻，看着大家热心帮我真开心

[oueiang]

我正在找工作，大家给点建议吧