黑马程序员-java中构造函数、构造代码块、静态代码块及它们的初始化顺序

---------------------- ASP.Net+Unity开发、.Net培训、期待与您交流！ ----------------------

java中，构造函数、构造代码块、静态代码的使用比较简单，但不注意也容易出现问题。而一旦出现问题，则难以排查。现总结如下：

一、构造函数

格式：

[修饰符] 类名(参数列表)
{
	构造函数中的执行语句;
}

作用：给对象进行初始化。

1、构造函数的特点：

1）构造函数与类名相同；

2）构造函数不返回任何值，也没有返回类型；

3）每一个类有零个或多个构造函数；

4）构造函数在创建对象时自动执行，一般不用显式调用。

现在，就上述几个需要说明的特点进一步进行解释：

特点1：注意java语言区分大小写；

特点2：因此，构造函数前面不可添加任何返回值类型（包括void），也不可以写return语句；

特点3：用户未给类定义构造函数时，编译器会自动添加默认的无参构造函数；一旦用户定义了构造函数，则不会产生默认的构造函数；多个构造函数是以重载的形式存在；

特点4：构造函数也可以显式调用，通过this语句和后面介绍的super语句。

在此我们先介绍this语句：

例1：

class Test
{
    String s;
	Test()
	{
		this("bbb");//构造函数之间的调用
	}
    Test(String s)
    {
        this.s=s; //this.s代表Test类中的成员变量s；用于区分同名变量
    }
}
class TestDemo
{
    public static void main(String[] args)
    {
        Test t1=new Test("aaa");
        Test t2=new Test();
		System.out.println("t1.s="+t1.s+" ; t2.s="+t2.s);
    }
}

输出结果：

t1.s=aaa ; t2.s=bbb

this语句的两个功能：

功能一：

1)this代表它所在函数所属对象的引用；2）this语句的用于区分同名变量。

功能二：构造函数间的调用。

2、构造函数的继承问题

类的继承机制使得子类可以使用父类的功能（即代码）。下面考查在继承关系下子父类的构造函数。

例2：

class  SuperClass
{
	SuperClass()
	{
		System.out.println("SuperClass A");
	}
	SuperClass(String str)
	{
		System.out.println("SuperClass "+str);
	}
}
class SubClass extends SuperClass
{
	SubClass()
	{
		System.out.println("SubClass A");
	}
	SubClass(String str)
	{
		System.out.println("SubClass "+str);
	}
}
class TestDemo
{
	public static void main(String[] args)
	{
		SubClass sc1=new SubClass();
		SubClass sc2=new SubClass("B");
	}	
}

输出结果：

SuperClass A
SubClass A
SuperClass A
SubClass B

例3：

class  SuperClass
{
	SuperClass(String str)
	{
		System.out.println("SuperClass "+str);
	}
}
class SubClass extends SuperClass
{
	SubClass()
	{
		System.out.println("SubClass A");
	}
}
class TestDemo
{
	public static void main(String[] args)
	{
		SubClass sc1=new SubClass();
	}	
}

输出结果：

#error#
无法将类SupClass中的构造器SupClass应用到给定类型；

例2、3说明了子类实例化时会自动调用父类的默认无参构造函数（ 即子类构造函数第一行隐含了一条语句：super();）；如果父类中未提供无参构造函数，则编译器会报错。

例4的解决方法：

方法1：父类中增加一个默认的无参构造函数；

方法2：在子类的构造函数中，用户显式调用父类的有参构造函数（即在子类构造函数第一行增加一条语句：super(str);）。


二、构造代码块

格式：

{
	构造代码块中的执行语句；
}

作用：给对象进行初始化

特点：对象一建立就运行，而且优先于构造函数执行。

与构造函数的区别：

构造代码块是给所有对象进行统一的初始化，其定义的是不同对象共性的初始化内容；而构造函数是给对应的对象进行初始化。

三、静态代码块

格式：

static
{
	静态代码块中的执行语句；
}

作用：给类进行初始化。

特点：随着类的加载而执行，但只执行一次，且优先于主函数。

四、初始化顺序

1、我们先考查下成员变量的初始化。

例4：

class A
{
	A(int i)
	{
		System.out.println("A.A("+i+")");
	}
}
class B
{
	A a1=new A(1);
	A a2=new A(2);

	B(int i)
	{
		System.out.println("B.B("+i+")");
	}
}
class TestDemo
{
	public static void main(String[] args)
	{
		System.out.println("TestDemo.main()");
		B b1=new B(1);
	}
}

输出结果：

TestDemo.main()
A.A(1)
A.A(2)
B.B(1)

在main方法中实例化了一个B类对象。但在初始化B类对象时，并非先调用B类的构造函数，而是 先初始化B类的成员变量。这里B类包含了2个A类对象，故要先调用3次A类的相应的构造函数，最后调用B类构造函数来初始化B类对象。

例5：

class A
{
	A(int i)
	{
		System.out.println("A.A("+i+")");
	}
}
class B
{
	A a1=new A(1);

	static A a2=new A(2);

	B(int i)
	{
		System.out.println("B.B("+i+")");
	}
}
class TestDemo
{
	public static void main(String[] args)
	{
		System.out.println("TestDemo.main()");
		B b1=new B(1);
		B b2=new B(2);
	}
}

输出结果：

TestDemo.main()
A.A(2)
A.A(1)
B.B(1)
A.A(1)
B.B(2)

静态成员变量先于非静态成员变量初始化，且只初始化一次； 非静态成员变量每次调用时都要初始化。

例6：

class A
{
	A(int i)
	{
		System.out.println("A.A("+i+")");
	}
}
class B
{
	A a1=new A(1);

	static A a2=new A(2);

	B(int i)
	{
		System.out.println("B.B("+i+")");
	}
}
class TestDemo
{
	static	B b2=new B(2);
	public static void main(String[] args)
	{
		System.out.println("TestDemo.main()");
		B b1=new B(1);
	}
}

输出结果：

A.A(2)
A.A(1)
B.B(2)
TestDemo.main()
A.A(1)
B.B(1)

静态成员变量的初始化先于main()方法的执行。

例7：

class A
{
	A(int i)
	{
		System.out.println("A.A("+i+")");
	}
}
class B
{
	static int i=4;

	A a1=new A(1);

	static A a2=new A(2);

	B(int i)
	{
		System.out.println("B.B("+i+")");
	}
}
class TestDemo
{
	public static void main(String[] args)
	{
		System.out.println("TestDemo.main()");
		System.out.println("B.i="+B.i);
	}
}

输出结果：

TestDemo.main()
A.A(2)
B.i=4

第一次访问类中的静态变量时（未创建该类对象），该类中的静态成员变量仍按照其在类中的位置顺序初始化。

2、我们再考查下构造函数、构造代码块、静态代码块的初始化顺序：

例8：

class A
{
	{
		System.out.println("A.{}");
	}

	static
	{
		System.out.println("A.static{}");
	}

	A(int i)
	{
		System.out.println("A.A("+i+")");
	}
}
class TestDemo
{
	{
		System.out.println("TestDemo.{}");
	}

	static
	{
		System.out.println("TestDemo.static{}");
	}

	public static void main(String[] args)
	{
		System.out.println("TestDemo.main()");
		A a1=new A(1);
		A a2=new A(2);
	}
}

输出结果：

TestDemo.static{}
TestDemo.main()
A.static{}
A.{}
A.A(1)
A.{}
A.A(2)

静态代码块先于构造代码块，而构造代码块先于构造函数； 静态代码块先于main函数，且只初始化一次；而构造代码块随着每次调用构造函数而初始化，并先于构造函数。

例9：

class A
{
	{
		System.out.println("A.{}");
	}

	static
	{
		System.out.println("A.static{}");
	}
	A()
	{
		System.out.println("A.A()");
	}
	A(int i)
	{
		System.out.println("A.A("+i+")");
	}
}
class B extends A
{
	int i=f();

	A a1=new A(1);

	static A a3=new A(3);

	{
		System.out.println("B.{}");
	}

	static
	{
		System.out.println("B.static{}");
	}
	
	B()
	{
		System.out.println("B.B()");
	}
	B(int i)
	{
		super(i);
		System.out.println("B.B("+i+")");
	}

	int f()
	{
		System.out.println("B.f()");
		return 4;
	}

}
class TestDemo
{
	{
		System.out.println("TestDemo.{}");
	}

	static
	{
		System.out.println("TestDemo.static{}");
	}

	static B b1=new B(1);

	B b2=new B(2);

	public static void main(String[] args)
	{
		System.out.println("TestDemo.main()");
		B b3=new B(3);
	}
}

输出结果：

TestDemo.static{}
A.static{}
A.{}
A.A(3)
B.static{}
A.{}
A.A(1)
B.f()
A.{}
A.A(1)
B.{}
B.B(1)
TestDemo.main()
A.{}
A.A(3)
B.f()
A.{}
A.A(1)
B.{}
B.B(3)

初始化的顺序如下：

1）静态代码块或静态成员变量的初始化（根据它们在代码中的位置顺序决定）；

2）调用对象的构造函数（但还未执行构造方法体）

3）调用父类的构造方法；

3）非静态成员变量的初始化；

3）构造代码块的初始化；

4）构造函数的初始化；

---------------------- ASP.Net+Unity开发、.Net培训、期待与您交流！ ----------------------详细请查看：www.itheima.com