构造方法以及对象初始化过程

一、构造方法

  构造方法特点如下：

　 1. 没有返回类型，方法名必须和类名一致    

    2.构造方法不能手动调用，它只用在创建对象的时候，只出现在new之后,只要构造方法被调用运行，就一定有对象产生

    3.在一个对象的生命周期里，构造方法只能被调用一次       

    4.类写好后一定有构造方法，如果程序没有显示的提供构造方法，系统会提供一个默认的构造方法，public classname(){} ,如果程序显示提供，系统不再提供默认的

    5.同一个类的多个构造方法一定是重载

    6.构造方法的代码块里可以写创建对象的同时需要运行的代码还可以给属性赋值       

    7.构造方法不能被继承，因此不能Override，但它可以Overloading

二、没有父类的对象初始化过程(父类为Object除外)

    1. 分配空间

    2. 构造方法第一行是否有this()

    3. 初始化实例变量

    4. 执行构造方法

      因为实例变量在创建对象的过程中被初始化，所以使用实例变量前必须创建对象，否则实例变量根本不存在在创建对象时，本类的构造方法永远最后执行

    没有this()测试代码如下：

]public class TestInitial1{
public static void main(String[] args){
Computer com = new Computer();
}
}
class Computer{
HardDisk  hd = new HardDisk();
public Computer(){
System.out.println("this is computer");
}
}
class HardDisk{
public HardDisk(){
System.out.println("this is harddisk");
}
}

代码运行如下：

    this is harddisk

    this is computer

有this()测试代码如下：

]public class TestInitial2{
public static void main(String[] args){
Breakfast bf = new Breakfast(3);
System.out.println(bf.egg.number);
}
}
class Breakfast{
Egg egg = new Egg();
Milk milk = new Milk();
public Breakfast(){
System.out.println("this is no param constructor");
}
public Breakfast(int num){
this();
System.out.println("this is have param constructor");
}
}
class Egg{
int number=5;
public Egg(){
System.out.println("Egg");
}
}
class Milk{
public Milk(){
System.out.println("Milk");
}
}

代码运行如下：

    Egg

    Milk

    this is no param constructor

    this is have param constructor

    5

 

三、有父类的对象初始化过程

    1. 分配总内存(包括所有属性的内存，本类属性，父类的共性)

    2. 看本类构造方法的第一句是否有this()或super()

    3. 创建父类对象

    4. 初始化本类的实例变量

    5. 执行本类的构造方法

测试代码如下：

]public class TestInitial3{
public static void main(String[] args){
ChineseBreakfast cbf = new ChineseBreakfast();
}
}
class Meal{
private Egg egg = new Egg();
public Meal(){
System.out.println("Meal");
}
}
class Breakfast extends Meal{
private Milk milk = new Milk();
public Breakfast(){
System.out.println("Breakfast");
}
}
class ChineseBreakfast extends Breakfast{
private Egg egg = new Egg();
private Milk milk = new Milk();
public ChineseBreakfast(){
this(3);
System.out.println("ChineseBreakfast no param");
}
public ChineseBreakfast(int num){
System.out.println("ChineseBreakfast have param");
}
}
class Egg{
public Egg(){
System.out.println("Egg");
}
}
class Milk{
public Milk(){
System.out.println("Milk");
}
}
class A{
public A(){
System.out.println("A()");
}
}
class B extends A{
public B(){
System.out.println("B()");
}
}

 

运行结果如下：

Egg

Meal

Milk

Breakfast

Egg

Milk

ChineseBreakfast have param

ChineseBreakfast no param

 

四、有静态变量、静态代码块的对象初始化过程

    1. 父类的静态变量(常量)/静态代码块

    2. 子类的

静态变量(常量)/静态代码块

    3. 父类的变量/代码块

    4. 父类的构造方法

    5. 子类的变量/代码块

    6. 子类的构造方法

       静态变量/静态代码块、变量/代码块的初始化顺序以其在代码中出现的先后顺序为准，先出现先初始化。

测试如下：

]publc class TestInitial4{
public static void main(String[] args) throws Exception{
new Sub();
}
}
class Super{
private static  final Egg egg = new Egg();
private Milk milk = new Milk();

static{
System.out.println("super's  static block");
}

{
System.out.println("super's  block");
}

public  Super(){
System.out.println("super's constructor");
}
}
class Sub extends Super{
static{
System.out.println("sub's  static block");
}

{
System.out.println("sub's  block");
}

private static  final Fish fish = new Fish();
private Meat meat = new Meat();

public  Sub(){
System.out.println("sub's constructor");
}
}
class Egg{
public Egg(){
System.out.println("Egg");
}
}
class Milk{
public Milk(){
System.out.println("Milk");
}
}
class Fish{
public Fish(){
System.out.println("Fish");
}
}
class Meat{
public Meat(){
System.out.println("Meat");
}
}

运行结果如下：

Egg

super's  static block

sub's  static block

Fish

Milk

super's  block

super's constructor

sub's  block

Meat

sub's constructor

 

注意，这也是一道常见的面试题。  关于this、super的介绍见“this和super
”一文。