深度理解JAVA本身的构造器及子父类构造方法的初始化顺序

我们说构造器是一种方法，就象讲澳大利亚的鸭嘴兽是一种哺育动物。（按：老外喜欢打比喻，我也就照着翻译）。要理解鸭嘴兽，那么先必须理解它和其他哺育动物的区别。同样地，要理解构造器，那么就要了解构造器和方法的区别。所有学习java的人，尤其是对那些要认证考试的，理解构造器是非常重要的。下面将简单介绍一下 ，最后用一个表作了些简单的总结。

功能和作用的不同
构造器是为了创建一个类的实例。这个过程也可以在创建一个对象的时候用到：Platypus p1 = new Platypus();

相反，方法的作用是为了执行java代码。

修饰符，返回值和命名的不同

构造器和方法在下面三个方便的区别：修饰符，返回值，命名。和方法一样，构造器可以有任何访问的修饰： public, protected, private或者没有修饰（通常被package 和 friendly调用）. 不同于方法的是，构造器不能有以下非访问性质的修饰： abstract, final, native, static, 或者 synchronized。

返回类型也是非常重要的。方法能返回任何类型的值或者无返回值（void），构造器没有返回值，也不需要void。

最后，谈谈两者的命名。构造器使用和类相同的名字，而方法则不同。按照习惯，方法通常用小写字母开始，而构造器通常用大写字母开始。构造器通常是一个名词，因为它和类名相同；而方法通常更接近动词，因为它说明一个操作。

"this"的用法

构造器和方法使用关键字this有很大的区别。方法引用this指向正在执行方法的类的实例。静态方法不能使用this关键字，因为静态方法不属于类的实例，所以this也就没有什么东西去指向。构造器的this指向同一个类中，不同参数列表的另外一个构造器，我们看看下面的代码：
public class Platypus { String name; Platypus(String input) { name = input; } Platypus() { this("John/Mary Doe"); } public static void main(String args[]) { Platypus p1 = new Platypus("digger"); Platypus p2 = new Platypus(); } }


在上面的代码中，有2个不同参数列表的构造器。第一个构造器，给类的成员name赋值，第二个构造器，调用第一个构造器，给成员变量name一个初始值 "John/Mary Doe".

在构造器中，如果要使用关键字this,那么，必须放在第一行，如果不这样，将导致一个编译错误。
"super"的用法

构造器和方法，都用关键字super指向超类，但是用的方法不一样。方法用这个关键字去执行被重载的超类中的方法。看下面的例子：
class Mammal { void getBirthInfo() { System.out.println("born alive."); } } class Platypus extends Mammal { void getBirthInfo() { System.out.println("hatch from eggs"); System.out.print("a mammal normally is "); super.getBirthInfo(); } }


在上面的例子中，使用super.getBirthInfo()去调用超类Mammal中被重载的方法。
构造器使用super去调用超类中的构造器。而且这行代码必须放在第一行，否则编译将出错。看下面的例子：
public class SuperClassDemo { SuperClassDemo() {} } class Child extends SuperClassDemo { Child() { super(); } }


在上面这个没有什么实际意义的例子中，构造器 Child()包含了 super,它的作用就是将超类中的构造器SuperClassDemo实例化，并加到 Child类中。

编译器自动加入代码

编译器自动加入代码到构造器，对于这个，java程序员新手可能比较混淆。当我们写一个没有构造器的类，编译的时候，编译器会自动加上一个不带参数的构造器，例如：public class Example {}

编译后将如下代码：
public class Example { Example() {} }


在构造器的第一行，没有使用super，那么编译器也会自动加上，例如：
public class TestConstructors { TestConstructors() {} }



编译器会加上代码，如下：
public class TestConstructors { TestConstructors() { super; } }


仔细想一下，就知道下面的代码
public class Example {}



经过会被编译器加代码形如：

public class Example { Example() { super; } }



继承

构造器是不能被继承的。子类可以继承超类的任何方法。看看下面的代码：
public class Example { public void sayHi { system.out.println("Hi"); } Example() {} } public class SubClass extends Example { }



类 SubClass 自动继承了父类中的sayHi方法，但是，父类中的构造器 Example()却不能被继承。


以下在构造器 里构造器自己是不对的public test() {
   s = new test();
}

异常:

xception in thread "main" java.lang.StackOverflowError
at father.test.<init>(test.java:15)
at father.test.<init>(test.java:15)
at father.test.<init>(test.java:15)
at father.test.<init>(test.java:15)
........

因为不断的构造自己了.死循环了.

还要学会修饰符的应用后,本类的范围.

构造方法的初始化顺序
想像一下你正在用java写程序，并且用下面的代码初始化类 A 和 B 的对象：

class A {

int a = f();

int f() {

return 1;

}

}

class B extends A {

int b = a;

int f() {

return 2;

}

}

public class CtorDemo1 {

public static void main(String args[]) {

B bobj = new B();

System.out.println(bobj.b);

}

}


现在，好像很明显的当初始化完成后，bobj.b的值将是1。毕竟，类B中的b 的值是用类A中的a的值初始化的，而a 是用f 的值初始化的，而它的值为1，对吗？

实际上， bobj.b 的值是2，要知道为什么需要知道对象初始化的问题。

当一个对象被创建时，初始化是以下面的顺序完成的：

1. 设置成员的值为缺省的初始值 (0, false, null)

2. 调用对象的构造方法 (但是还没有执行构造方法体)

3. 调用父类的构造方法

4. 使用初始化程序和初始块初始化成员

5. 执行构造方法体


看看在实际中是如何一步一步完成的，看看下面的例子：

class A {

A() {

System.out.println("A.A called");

}

}


class B extends A {

int i = f();

int j;


{

j = 37;

System.out.println("initialization block executed");

}


B() {

System.out.println("B.B called");

}


int f() {

System.out.println("B.f called");

return 47;

}

}

public class CtorDemo2 {

public static void main(String args[]) {

B bobj = new B();

}

}

程序的输出是：

A.A called

B.f called

initialization block executed

B.B called

B 的构造方法被调用，但是最先做的事情是隐含的调用父类的构造方法。父类必须自己负责初始化它自己的状态而不是让子类来做。

然后B对象的成员被初始化，这包含一个对B.f 的调用和包围在{}中的初始块的执行。最后B的构造方法体被执行。

你可能会问“什么是对父类的构造方法的隐含调用”。这意味着如果你的构造方法的第一行不是下面内容之一：

super();

super(args);

this();

this(args);

则有下面的调用：

super();

提供给构造方法的第一行。

如果类没有构造方法呢？在这种情况下，一个缺省的构造方法(也叫"无参构造方法")由java编译器自动生成。缺省构造方法只有在类没有任何其它的构造方法时才产生。

更深入的明白这个，假设在文件A.java中有这样的代码：


public class A {

public static void main(String args[]) {

A aref = new A();

}

}

如果你想编译然后列出A.class 中的字节码，输入下面的内容：

$ javac A.java

$ javap -c -classpath . A

输出：

Compiled from A.java

public class A extends java.lang.Object {

public A();

public static void main(java.lang.String[]);

}

Method A()

0 aload_0

1 invokespecial #1

4 return

Method void main(java.lang.String[])

0 new #2

3 dup

4 invokespecial #3

7 astore_1

8 return

在main 中，注意对 A 的构造方法的调用(就是invokespecial 行)，以及A的构造方法中产生的类似的对Object 构造方法的调用。

如果父类没有缺省构造方法，你必须明确使用"super(args)"调用父类的某个构造方法，例如，下面是一个错误的用法：

class A {

A(int i) {}

}

class B extends A {}

在上面的情况下， A 没有缺省的构造方法，但是B的构造方法必须调用A的某个构造方法。

让我们来看看初始化的另一个例子：

class A {

A() {

System.out.println("A.A called");

}

A(int i) {

this();

System.out.println("A.A(int) called");

}

}

class B extends A {

int i = f();

int j;

{

j = 37;

System.out.println("initialization block executed");

}

B() {

this(10);

System.out.println("B.B() called");

}

B(int i) {

super(i);

System.out.println("B.B(int) called");

}

int f() {

System.out.println("B.f called");

return 47;

}

}

public class CtorDemo3 {

public static void main(String args[]) {

B bobj = new B();

}

}

程序的输出是：

A.A called

A.A(int) called

B.f called

initialization block executed

B.B(int) called

B.B() called

这个例子明确使用super() 和 this() 调用。this()调用是调用同一个类中的另一个构造方法；这个方法被称为“显式构造方法调用”。当那样的构造方法被调用，它将执行通常的super() 过程以及后续的操作。这意味着A.A 的方法体在A.A(int)之前执行，而这两个都在B.B(int) 和B.B 前执行。

如果返回第一个例子，你就可以回答为什么打印的是2而不是1。B 没有构造方法，因此生成一个缺省构造方法，然后它调用super()，然后调用A 产生的缺省构造方法。

然后A中的成员被初始化，成员a 被设置为方法f()的值，但是因为B 对象正被初始化，f() 返回值2。换句话说，调用的是B中的f()方法。

A产生的构造方法体被执行，然后B的成员被初始化，而b 被赋予值a，也就是2。最后，B的构造方法被执行。

最后一个例子说明了第一个例子的一个小小的变异版本：

class A {

int a = f();

int f() {

return 1;

}

}

class B extends A {

int b = 37;

int f() {

return b;

}

}

public class CtorDemo4 {

public static void main(String args[]) {

B bobj = new B();

System.out.println(bobj.a);

System.out.println(bobj.f());

}

}

程序的输出是：

0

37

你可能会期望输出的两个值bobj.a 和bobj.f()是一样的，但是正如你看到的他们不一样。这是正确的，即使是在a是从B的f方法中初始化的并且打印的是a 和 B的 f 方法的值。

这儿的问题是当a通过对B的f方法调用而初始化，而该方法返回成员b的值，而该成员还没有被初始化。因为这个，b的值就是刚开始的初始值0。

这些例子解释了编程中重要的一点――在对象的构造阶段调用可重载的方法是不明智的。



父类的成员变量的初始化值--〉如果初始化成员变量时要调用父类的方法（如private int a=getData();），就会执行此父类的方法. 但是如果此方法被子类覆盖，那么这里是调用子类的方法（getData（））。-->执行父类的构造函数-->子类的成员变量的初始化值--〉执行子类的构造函数。 技巧：其实继承就是可以把子父类按规定的顺序组合起来。 先是父类的属性在前，在是子类的属性，再是父类的构造方法，再是子类的构造方法，再是父类与子类的方法，如果方法有覆盖的，用子类的。---注意顺序。 错错.........错了...

2008-01-23 修正:

初始化 顺序应该是.

父静态变量-->子静态变量-->父非静态变量-->父静态代码块-->父构造函数------>子非变量-->子静态代码块-->子构造函数