Java- 对象构造与初始化

对象构造

构造方法的基本概念（constructor）

• 每个对象都有构造方法。抽象类虽然不能实例化对象，但也有构造方法。
• if not， 编译器加一个default构造方法。

调用本类或父类的构造方法

• 调用本类或父类的构造方法
  
  • this调用本类的其他构造方法
  • super调用直接父类的构造方法
  • this或super要放在第一条语句，且只能够有一条
• 如果没有this及super，则编译器自动加上super()，即调用直接父类不带参数的构造方法。任何子类必须先或显示或隐式地调用直接父类的构造方法。

class ConstructCallThisAndSuper 
{
    public static void main(String[] args){ 
        Person p = new Graduate();
    }
}

class Person
{
    String name; 
    int age;
    Person(){}
    Person( String name, int age ){
        this.name=name; this.age=age; 
        System.out.println("In Person(String,int)");
    }
}

class Student extends Person
{
    String school;
    Student(){
        this( null, 0, null );
        System.out.println("In Student()");
    }
    Student( String name, int age, String school ){
        super( name, age );
        this.school = school;
        System.out.println("In Student(String,int,String)");
    }
}

class Graduate extends Student
{
    String teacher="";
    Graduate(){
        //super(); compiler will load this default method  automatically if we don't.
        System.out.println("In Graduate()");
    }
}

-----------OUTPUT-----------  
In Person(String,int)
In Student(String,int,String)
In Student()
In Graduate()

- 必须所有父类的构造都必须得到调用，否则整个对象的构建就可能不正确。

Class A{
    A(int a){...};
}

Class B extends A{
    B(String a){} // 编译不通过，提示构造构造方法不存在
}

    - 编译出错是因为，在类B中的构造方法没有`this`及`super`，因此编译器会自动调用父类的构造方法，即`B(String a){ super(); }`，但是类A中由于已经显示地声明了一个构造方法`A(int)`，因此系统就不会在生产默认的构造方法`A()`，所以编译出错。解决方法：
        1. 在类B的构造方法中，加入`super(3)`
        2. 在A中加入一个不带参数的构造方法`A(){}`
        3. 去掉A中全部的构造方法，则Compiler会自动加入一个不带参数的构造方法。

对象的初始化

创建对象时的初始化

• p = new Person(){ {age=18; name="LiMing";} };
• 这种双括号的写法可以针对没有相应构造函数，但又要对对象的字段进行赋值的情形

实例初始化与静态初始化

• 实例初始化（Instance Initializers）
  
  • 在类中直接写{ ... }，实例初始化，先于构造方法{}中的语句执行（除了this，super）。
• 静态初始化(Static Initializers)
  
  • static { ... }
  • 静态初始化，在第一次使用这个类时执行，其他时候不执行
  • 但其执行的具体时机是不确定的，但可以肯定的是：总是先于实例的初始化执行。

class InitialTest
{
    public static void main(String[] args) 
    {
        new InitialTest2(6);
    }
    int n=10;  //step2
    {
        n++;
        System.out.println("InitialTest..."+n);
    }

    static int x;
    static 
    {
        x++;
        System.out.println("static..." +x);
    }

}

class InitialTest2 extends InitialTest{
    InitialTest2(int a){ 
        this.a=a; 
        System.out.println("this.a=" + a );
    }
    int a;
    {   // 实例初始化语句，总是先于构造函数体里的函数执行（除了this，super）
        System.out.println("InitialTest2..."+this.a);
    }
    static
    {   // 静态初始化语句，总是先于实例的初始化执行
        x++;
        System.out.println("static2..." +x);
    }
}

-----------OUTPUT-----------  
static...1
static2...2
InitialTest...11
InitialTest2...0
this.a=6
[Finished in 1.4s]