java 初始化器_Java中构造器的初始化

package object;

class Cup{

Cup(int marker){

System.out.println("Cup("+marker+")");

}

void f(int marker){

System.out.println("f("+marker+")");

}

}

class Cups {

static Cup cup1;

static Cup cup2;

static {

cup1 = new Cup(1);

cup2 = new Cup(2);

}

Cups(){

System.out.println("Cups()");

}

}

public class E08_StaticTest {

public static void main(String[] args) {

System.out.println("Inside main()");

//new Cups();

Cups.cup1.f(99);

}

static Cups cups1 = new Cups();

static Cups cups2 = new Cups();

} /* Output:

Cup(1)

Cup(2)

Cups()

Cups()

Inside main()

f(99)

*///:~

初始化的顺序为先静态对象，后非静态对象：在进入函数的入口地址(main)之前，首先初始化静态对象cups1和cups2两个静态对象，当初始化cups1时，进入Cups的构造器，里面又有两个静态对象cup1和cup2->Cup的构造器->输出Cup(1)、Cup(2)和Cups()；当初始化cups2时，进入Cups的构造器，静态对象cup1和cup2已经创建，所以只输出Cups()；然后进入main函数，顺序执行println函数和f()方法。

需要注意的是：此示例在main函数开始之前所有的类都被加载了，实际情况通常并非如此，此示例中所有的事物都通过static联系起来。

package object;

class Mug

{

Mug(int marker)

{

System.out.println("Mug(" + marker + ")");

}

void f(int marker)

{

System.out.println("f(" + marker + ")");

}

}

public class Test

{

Mug mug1;

Mug mug2;

{

mug1 = new Mug(1);

mug2 = new Mug(2);

System.out.println("mug1和mug2 初始化了");

}

Test()

{

System.out.println("Mugs()");

}

Test(int i)

{

System.out.println("Mugs(int)");

}

public static void main(String[] args)

{

System.out.println("Inside main()");

new Test();

System.out.println("new Mugs() completed");

new Test(1);

System.out.println("new Mugs(1) completed");

}

}/*Output

Inside main()

Mug(1)

Mug(2)

mug1和mug2 初始化了

Mugs()

new Mugs() completed

Mug(1)

Mug(2)

mug1和mug2 初始化了

Mugs(int)

new Mugs(1) completed

*///:~

这个例子中没有用到static关键字，则每次对匿名内部类进行初始化时相应的操作都会执行，而不是将带有static的对象只执行一次。

//: polymorphism/E15_PolyConstructors2.java

/****************** Exercise 15 *****************

* Add a RectangularGlyph to PolyConstructors.java

* and demonstrate the problem described in this

* section.

***********************************************/

package operators;

class Glyph{

void draw(){System.out.println("Glyph.draw()");}

Glyph(){

System.out.println("Glyph() before draw()");

draw();

System.out.println("Glyph() after draw()");

}

}

class RoundGlyph extends Glyph{

private int radius = 1;

RoundGlyph(int r){

radius = r;

System.out.println("RoundGlyph.RoundGlyph() , radius ="+radius);

}

void draw() {

System.out.println("RoundGlyph.draw() , radius ="+radius);

}

}

class RectangularGlyph extends Glyph {

private int width = 4;

private int height = 5;

RectangularGlyph(int width, int height) {

this.width = width;

this.height = height;

System.out.println("RectangularGlyph.RectangularGlyph(), width = " +

width + ", height = " + height);

}

void draw() {

System.out.println("RectangularGlyph.draw(), area = " + width *

height);

}

}

public class E03_Aliasing2 {

public static void main(String[] args) {

new RoundGlyph(5);

new RectangularGlyph(2,2);

}

} /* Output:

Glyph() before draw()

RoundGlyph.draw(), radius = 0

Glyph() after draw()

RoundGlyph.RoundGlyph(), radius = 5

Glyph() before draw()

RectangularGlyph.draw(), area = 0

Glyph() after draw()

RectangularGlyph.RectangularGlyph(), width = 2, height = 2

*///:~

上面这个例子在子代对象未完全构造之前调用了子代中的方法draw()；结果就出现了隐藏错误。new RoundGlyph(5)->调用RoundGlyph构造器，发现有父代->调用Glyph构造器，顺序执行构造器内的语句，输出Glyph() before draw()；执行到draw()时由于动态绑定执行RoundGlyph类中的draw()方法，输出RoundGlyph.draw(), radius = 0，此时radius并不等于默认的1(和想要的不一样)，原因是还没执行到RoundGlyph构造器部分；再执行System.out.println("Glyph() after draw()");输出Glyph() after draw()->调用RoundGlyph构造器，将5传递给radius，输出RoundGlyph.RoundGlyph(), radius = 5。

new RectangularGlyph(2,2)的执行过程与之相似。