Java中对象构造

构造函数

作用：在构造对象的同时初始化对象。java强制要求对象 诞生同时被初始化，保证数据安全。

调用过程和机制：①申请内存，②执行构造函数的函数体，③返回对象的引用。

特点：与类同名，无返回类型，可以重载。

每一个类都至少有1个构造函数，如果不显示定义构造函数，则javac会帮我们添加一个默认的无参数的构造函数。如果自己提供了构造函数，则javac不会再提供默认的无参构造函数。

一个类中，对象构造时的构造过程

顺序如下：

1、字段获取相应类型的默认值（基本类型是 0 ，引用类型是null），定义时给了初始值的则获得给定的值。

2、执行构造块中语句

3、执行构造函数中的主体语句

先来看一个类中，初始化时，各个构造方法的调用顺序

下面是一个例子

public class Main
{

    public static void main(String[] args)
    {

        Base b = new Base();

        System.out.println("Base中baseVal的最终值为:"+b.baseVal);    

         /*
          baseVal=11
          baseVal=12
          Base中baseVal的最终值为:12
　　     */

    }

}

class Base
{

    public int baseVal = 10;    // ①

    {                           // ②构造块
        baseVal = 11;
        System.out.println("baseVal=" + baseVal);
    }

    public Base()              // ③
    {
        baseVal = 12;
        System.out.println("baseVal=" + baseVal);
    }

}

实质上，为了初始化实例字段，javac会对每一个构造函数进行"修改"，原理如下图。所以，无论一个类中使用定义初始化，还是构造块，最终都是调用构造函数来起作用的。

例子验证

public class Test
{

    private int x = 100;
    private int y;
    private int z;

    {y= 200;}

    public Test()
    {
        z = 300;
    }

}

使用javap得到字节码的结果，可以很清楚的看到，字段的定义初始化，构造块初始化，其实都是语法特性，最终的内部实现都是依赖构造函数的执行。执行的顺序一目了然

Compiled from "Test.java"
public class Test {
  public Test();
    Code:
       0: aload_0
       1: invokespecial #1                  // Method java/lang/Object."<init>":()V
       4: aload_0
       5: bipush        100
       7: putfield      #2                  // Field x:I
      10: aload_0
      11: sipush        200
      14: putfield      #3                  // Field y:I
      17: aload_0
      18: sipush        300
      21: putfield      #4                  // Field z:I
      24: return
}

一个继承链中，对象构造时的过程

java中，子类的构造函数，如果不显式用super写出来的话，默认会在第一句调用父类的默认构造函数。可以通过super 显式指定调用父类的哪个构造函数。需要注意的是：这个super调用必须是子类构造函数的第一条语句。

可以发现：构造一个子类，会先去调用父类的整套构造机制（注意：我并没有这样说：构造一个子类，会先去构造一个父类，原因待会解释），父类又会调用父类的父类的构造机制，.......一直带到Object为止。那么，这就会引发一条调用链，过程有点类似递归，只有高层的函数调用完了，底层的函数才会执行完。

public class Main
{

    public static void main(String[] args)
    {

        SubClass sub = new SubClass();

        /*
         * console:
         *                  ①baseVal=11
                            ②baseVal=12
                            ③baseVal=12 sub Val=91
                            ④baseVal=12 sub Val=92
         */

    }

}

class Base
{

    public int baseVal = 10;    

    {
        baseVal = 11;
        System.out.println("①baseVal=" + baseVal);
    }

    public Base()
    {
        baseVal = 12;
        System.out.println("②baseVal=" + baseVal);
    }

}

class SubClass extends Base
{
     public int subVal = 90;

    {
        subVal = 91;
        System.out.println("③baseVal="+baseVal+" sub Val=" + subVal);

    }

    public SubClass()
    {
        // super() //子类构造函数默认隐式调用父类的默认构造函数 ，当然你也可以显示调用
        subVal = 92;

        System.out.println("④baseVal="+baseVal+" sub Val=" + subVal);
    }

}

当然，子类还可以使用this来调用自己的另一个版本的构造函数完成构造，这个可以叫做委托构造。

class Student
{

    public static void main(String[] args)
    {

        Student s = new Student();

        System.out.println(s);

    }

    private double score ;

    private String name;

    //构造函数的第一句不是super(xx,xx...)就是this(xx,xx...)。super用来借用父类的构造函数来构造自己，这是java强制要求的，其它语言也多是这样。
    //this(xx,xx...)则是程序员自己复用本类构造函数代码的手段。
    //如果不显示的写super(xx,xx...)，则编译javac会插入super()来调用父类默认的构造函数，如果父类没有默认的构造函数，则编译出错。
    //而this(xx,xx...)必须是程序员自己指定的，编译器不会插入。
    public Student(String name,double score )
    {
        //super()        第一句如果不是this(xx,xx)，则默认就是super();因为这里Student无显示的父类，所以super()就是调用Object的构造函数。
        this.name = name;
        this.score = score;
    }

    public Student()
    {
        this("no name",0.0);   //无参数的构造函数委托有2个参数的构造函数完成。
    }

    @Override
    public String toString()
    {
        return String.format("name:%s , score:%.2f", name,score);
    }

}

子类的构造，会生成一个父类对象吗？

这个问题的关键在于：是生成的一个内嵌的父类，还是生成一个独立的父类。

显然，我认为是生成的是内嵌的父类，即子类包含父类的数据，父类并不是独立存在的。

试想一下：如果new一个子类对象，会生成一个独立的父类，那么，对于深层次的继承链。比如10层，new一个最高层子类，岂不是会在内存生成 10个对象，显然是不可以的，不高效的。

那么子类对象在构造时，为什么要调用父类地方构造 函数呢？那是因为，子类要借用父类的构造函数类构造自己。因为子类包含父类的数据。

静态字段的构造

javac在编译时，会自动每一个类提供一个"静态构造函数"，将 静态字段的定义初始化 和 static初始化块 插入到这个"静态构造函数" 中去，先插入 静态字段的定义初始化，后插入 static初始化块。意味着  静态字段的定义初始化先于  static初始化块执行。

当类第一次使用的时候（被JVM加载的时候），执行这个"静态构造函数"，让static字段得到初始化。

静态字段，无论是否使用了static初始化块，都是在类第一次被加载时，完成的初始化。

例子：

public class Test
{

    private static  int x = 100;

    static { x = 200;}

}

字节代码：

Compiled from "Test.java"
public class Test {
  public Test();                       //<-----------javac提供的默认无参构造函数
    Code:
       0: aload_0
       1: invokespecial #1                  // Method java/lang/Object."<init>":()V
       4: return

  static {};                           //<------------javac自动合成的 “静态构造函数”
    Code:
       0: bipush        100
       2: putstatic     #2                  // Field x:I
       5: sipush        200
       8: putstatic     #2                  // Field x:I
      11: return
}

细节总结

1、每一个类至少有一个构造函数。如果不手动编写构造函数，javac会为这个类提供一个默认的，无参数的构造函数。如果手动编写了构造函数，则javac就不会提供默认的构造函数。

2、如果想让一个类不能实例化对象，则让他仅有的默认构造函数私有(private)，见Math类。

3、java 中的对象都在堆中生成，而引用他们的引用变量则视情况而定。比如一个类对象中有一个String成员，变量名为name，那么name也在堆中。C++中，如果使用new，则对象生成在堆中，如果不用new，一般在栈中。

4、类的成员变量如果不显式初始化，则赋值为默认值。但最好明确地个一个初始值。

5、final成员变量必须在new对象时被初始化，包括定义final变量时给初始值，或者在初始化块中，或者在构造函数中。

6、静态字段也会有默认值，也可以静态构造块中初始化。JVM第一次加载类时，这个过程就完成了。

7、通过this来调用本类其他的构造函数，这个this也必须是构造函数中的第一句，所以，不能同时使用this个super调用构造函数。

8、如果一个类不准在类外是例外对象，则应该定义仅有的1个默认私有无参构造函数：如 java.lang.System类。

 /** Don't let anyone instantiate this class */
    private System() {
    }