Java中创建对象时代码执行顺序

Java中创建对象的时候代码执行顺序

(2008-12-11 13:03:05)

转载▼

标签： it

分类：软件

在Java中,创建一个对象,到底代码执行顺序是什么样子的。通过编写一个类，测试一下就知道了。

1、首先测试一个直接从Object继承的类。

public class Parent {
    privatestatic int p1 = staticPrintInt("P....初始化父类静态属性", 100);
    private intp2 = instancePrintInt("P....初始化父类实例属性", 200);
   
   static{
    System.out.println("P....执行父类静态代码段");
    }

    {
    System.out.println("P....执行父类非静态代码段");
    }
   
    publicstatic int staticPrintInt(String str, int value){
    System.out.println(str);
    return value;
    }
   
    public intinstancePrintInt(String str, int value){
    System.out.println(str);
    return value;
    }
   
    public voidpublicPrintProperty(){
    System.out.println("P....Parent public方法");
    System.out.println("P....p1 =" + p1);
    System.out.println("P....p2 =" + p2);
    }

    privatevoid privatePrintProperty(){
    System.out.println("P....Parent private方法");
    System.out.println("P....p1 =" + p1);
    System.out.println("P....p2 =" + p2);
    }

    publicParent(){
    System.out.println("P....父类构造器");
    publicPrintProperty();
    privatePrintProperty();
    }
   
    publicstatic void main(String[] args){
    Parent p;
    System.out.println("========================");
    p = new Parent();
    }
}

执行该类之后，会得到以下输出

P....初始化父类静态属性
P....执行父类静态代码段
========================
P....初始化父类实例属性
P....执行父类非静态代码段
P....父类构造器
P....Parent public 方法
P....p1 =100
P....p2 =200
P....Parent private 方法
P....p1 =100
P....p2 =200

从上面的输出可以看出，使用直接父类为Object的类创建对象过程是：
a、加载类

1、为静态属性分配内存并赋值
2、执行静态代码段

b、创建对象

1、为实例属性分配内存并赋值
2、执行非静态代码段
3、执行构造器

1、再测试直接父类不是Object的类

package com.guandl.thinking;

public class Child extends Parent{
    privatestatic int c1 = staticPrintInt("C....初始化子类静态属性", 1000);
    private intc2 = instancePrintInt("C....初始化子类实例属性", 2000);
   
   static{
    System.out.println("C....执行子类静态代码段");
    }

    {
    System.out.println("C....执行子类非静态代码段");
    }
   
    public voidpublicPrintProperty(){
    System.out.println("C....Child public 方法");
    System.out.println("C....c1 =" + c1);
    System.out.println("C....c2 =" + c2);
    }

    privatevoid privatePrintProperty(){
    System.out.println("C....Child private方法");
    System.out.println("C....c1 =" + c1);
    System.out.println("C....c2 =" + c2);
    }
   
    publicChild(){
    System.out.println("C....子类构造器");
    publicPrintProperty();
    privatePrintProperty();
    }

    publicstatic void main(String[] args){
    Child c;
    System.out.println("========================");
    c = new Child();
    }
}

执行之后会输入以下结果

P....初始化父类静态属性
P....执行父类静态代码段
C....初始化子类静态属性
C....执行子类静态代码段
========================
P....初始化父类实例属性
P....执行父类非静态代码段
P....父类构造器
C....Child public 方法
C....c1 =1000
C....c2 =0
P....Parent private 方法
P....p1 =100
P....p2 =200
C....初始化子类实例属性
C....执行子类非静态代码段
C....子类构造器
C....Child public 方法
C....c1 =1000
C....c2 =2000
C....Child private 方法
C....c1 =1000
C....c2 =2000

从上面的输出可以看出，使用直接父类不是Object的类创建对象过程是：
a、加载类

1、为父类静态属性分配内存并赋值
2、执行父类静态代码段
3、为子类静态属性分配内存并赋值
4、执行子类静态代码段

b、创建对象
1、为父类实例属性分配内存并赋值
2、执行父类非静态代码段
3、执行父类构造器
5、为子类实例属性分配内存并赋值
6、执行子类非静态代码段
7、执行子类构造器

在这个过程里面，我们会注意到两段工作都是先处理父类，然后再处理子类的。也就是子类重复了一遍父类的工作。
这个过程里面可能会遇到一个特殊现象，那就是：
1、子类覆盖了父类中的某个方法。
2、父类构造器中调用到了该方法
3、在子类中，该方法访问到了只有子类才有的属性。

就像我们前面的代码中，
父类中的定义是：
    public voidpublicPrintProperty(){
    System.out.println("P....Parent public方法");
    System.out.println("P....p1 =" + p1);
    System.out.println("P....p2 =" + p2);
    }
子类中的定义是：
    public voidpublicPrintProperty(){
    System.out.println("C....Child public 方法");
    System.out.println("C....c1 =" + c1);
    System.out.println("C....c2 =" + c2);
    }
其中，C2是只有子类才具有的属性，但是在父类构造器中却调用到了该方法。
也就是说，按照Java对象创建过程，当该方法被执行的时候C2还没有被初始化。
在这种情况下，Java会根据属性的类型不同，采用不同的缺省值进行处理。
这也就是为什么父类构造器执行的时候
C2=0
子类构造器执行的时候
C2=2000的原因。

实际上，Java在处理创建子类对象的时候，在所有工作开始之前，先为继承层次中每个类的对象分配内存。然后在做其他工作。这样可以保证不管对象是否产生，起码属性已经先有了一个缺省值。

转载自  http://blog.sina.com.cn/s/blog_54ee3de50100bn3v.html