java 对象构造_Java中对象构造

构造函数

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

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

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

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

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

顺序如下：

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

2、执行构造块中语句

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

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

下面是一个例子

public classMain

{public static voidmain(String[] args)

{

Base b= newBase();

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

baseVal=11

baseVal=12

Base中baseVal的最终值为:12

*/

}

}classBase

{public int baseVal = 10; //①

{//②构造块

baseVal = 11;

System.out.println("baseVal=" +baseVal);

}public Base() //③

{

baseVal= 12;

System.out.println("baseVal=" +baseVal);

}

}

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

例子验证

public classTest

{private int x = 100;private inty;private intz;

{y= 200;}publicTest()

{

z= 300;

}

}

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

Compiled from "Test.java"

public classTest {publicTest();

Code:0: aload_01: invokespecial #1 //Method java/lang/Object."":()V

4: aload_05: bipush 100

7: putfield #2 // Field x:I

10: aload_011: sipush 200

14: putfield #3 // Field y:I

17: aload_018: sipush 300

21: putfield #4 // Field z:I

24: return}

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

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

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

public classMain

{public static voidmain(String[] args)

{

SubClass sub= newSubClass();/** console:

* ①baseVal=11

②baseVal=12

③baseVal=12 sub Val=91

④baseVal=12 sub Val=92*/}

}classBase

{public int baseVal = 10;

{

baseVal = 11;

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

}public Base()

{

baseVal= 12;

System.out.println("②baseVal=" +baseVal);

}

}class SubClass extendsBase

{public int subVal = 90;

{

subVal= 91;

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

}publicSubClass()

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

subVal = 92;

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

}

}

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

classStudent

{public static voidmain(String[] args)

{

Student s= newStudent();

System.out.println(s);

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

public Student(String name,doublescore )

{//super() 第一句如果不是this(xx,xx)，则默认就是super();因为这里Student无显示的父类，所以super()就是调用Object的构造函数。

this.name =name;this.score =score;

}publicStudent()

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

}

@OverridepublicString toString()

{return String.format("name:%s , score:%.2f", name,score);

}

}

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

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

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

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

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

静态字段的构造

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

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

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

例子：

public classTest

{private static int x = 100;static { x = 200;}

}

字节代码：

Compiled from "Test.java"

public classTest {publicTest(); //

Code:0: aload_01: invokespecial #1 //Method java/lang/Object."":()V

4: return

static{}; //

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*/

privateSystem() {

}