构造器的初始化

案例一：

//构造器的初始化
public class OrderInitial {
public static void main(String[] args) {
//new对象时，先执行构造器，按顺序执行
House h = new House();
h.f();
}
}

class window{
window(int market){
System.out.println(“window”+market);
}
}

class House{
window w1=new window(1);
House(){
System.out.println(“house”);
w3=new window(4);//给w3重新赋值window4,之前的window3会被垃圾回收
}
window w2=new window(2);
void f(){
System.out.println(“f()”);
}
window w3=new window(3);
}

运行结果：
window1
window2
window3
house
window4
f()

解析：new一个house对象，先执行House类，依次执行window对象的创建，然后执行House的无参构造器，输出house、给w3重新赋值，然后house对象h调用f()方法。

案例二：
//构造器中存在静态成员时的初始化

public class StaticInitial {
public static void main(String[] args) {
System.out.println(“Creating new Cupboard”);//10
new Cupboard();
System.out.println(“Creating new Cupboard”);//14
new Cupboard();
table.f2(1); //18
cupboard.f3(1); //19
}
//先实例静态化对象
static Table table=new Table();
static Cupboard cupboard=new Cupboard();
}

class Bowl{
Bowl(int marker){
System.out.println(“bowl()”+marker);
}
void f1(int marker){
System.out.println(“f()”+marker);
}
}
class Table{
static Bowl b1=new Bowl(1);//1
Table(){
System.out.println(“Table()”);//3
b2.f1(1);//4
}
void f2(int marker){
System.out.println(“f2()”+marker);
}
static Bowl b2=new Bowl(2);//2
}
class Cupboard{
Bowl b3=new Bowl(3);//7 11 15
//静态成员只会执行一次，作用域是整个程序
static Bowl b4=new Bowl(4);//5
Cupboard(){
System.out.println(“Cupboard()”);//8 12 16
b4.f1(2);//9 13 17
}
void f3(int marker){
System.out.println(“f3()”+marker);
}
static Bowl b5=new Bowl(5);//6
}

输出结果：
bowl()1
bowl()2
Table()
f()1
bowl()4
bowl()5
bowl()3
Cupboard()
f()2
Creating new Cupboard
bowl()3
Cupboard()
f()2
Creating new Cupboard
bowl()3
Cupboard()
f()2
f2()1
f3()1
解析：首先执行静态成员，并且静态成员在整个运行过程中只执行一次，作用域为程序的整个运行过程。执行顺序在代码中已经标注。

案例三：

public class ExpStatic {
public static void main(String[] args) {
System.out.println(“Start”);
//访问静态成员会导致静态成员初始化
//静态成员被访问，执行静态成员初始化static块，然后调用f()方法
Cups.cup1.f(99);
}
}
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()”);
}
}

运行结果：
Start
Cup()1
Cup()2
f()99
解析：
静态成员被访问时，首先执行其中的静态代码块，静态代码块在程序的整个运行过程中，只能执行一次。初始化对象，然后调用执行其f()方法

案例四：

//非静态实例初始化
public class Mugs {
Mug mug1;
Mug mug2;
//实例代码块
{
mug1=new Mug(1); //2 7
mug2=new Mug(2); //3 8
System.out.println(“mug1 && mug2”); //4 9
}

 public Mugs(){
     System.out.println("Mugs()"); //5
 }
  public Mugs(int i){
      System.out.println("Mugs()"+i);  //10
  }

public static void main(String[] args) {
    System.out.println("start");  //1
     new Mugs();
    System.out.println("end"); //6
    new Mugs(1);
    System.out.println("endend"); //11
}

}
class Mug{
Mug(int marker){
System.out.println(“Mug()”+marker);
}
void f(int marker){
System.out.println(“f()”+marker);
}
}

运行结果：
start
Mug()1
Mug()2
mug1 && mug2
Mugs()
end
Mug()1
Mug()2
mug1 && mug2
Mugs()1
endend
解析：
非静态代码块在程序的运行过程中可以被多次执行，程序的执行过程已在代码中标注。