第四章初始化和清除 44.docx
- 文档编号:9893237
- 上传时间:2023-02-07
- 格式:DOCX
- 页数:14
- 大小:19.57KB
第四章初始化和清除 44.docx
《第四章初始化和清除 44.docx》由会员分享,可在线阅读,更多相关《第四章初始化和清除 44.docx(14页珍藏版)》请在冰豆网上搜索。
第四章初始化和清除44
4.4成员初始化
Java尽自己的全力保证所有变量都能在使用前得到正确的初始化。
若被定义成相对于一个方法的“局部”变量,这一保证就通过编译期的出错提示表现出来。
因此,如果使用下述代码:
voidf(){
inti;
i++;
}
就会收到一条出错提示消息,告诉你i可能尚未初始化。
当然,编译器也可为i赋予一个默认值,但它看起来更象一个程序员的失误,此时默认值反而会“帮倒忙”。
若强迫程序员提供一个初始值,就往往能够帮他/她纠出程序里的“臭虫”。
然而,若将基本类型(主类型)设为一个类的数据成员,情况就会变得稍微有些不同。
由于任何方法都可以初始化或使用那个数据,所以在正式使用数据前,若还是强迫程序员将其初始化成一个适当的值,就可能不是一种实际的做法。
然而,若为其赋予一个垃圾值,同样是非常不安全的。
因此,一个类的所有基本类型数据成员都会保证获得一个初始值。
可用下面这段小程序看到这些值:
//:
InitialValues.java
//Showsdefaultinitialvalues
classMeasurement{
booleant;
charc;
byteb;
shorts;
inti;
longl;
floatf;
doubled;
voidprint(){
System.out.println(
"DatatypeInitalvalue\n"+
"boolean"+t+"\n"+
"char"+c+"\n"+
"byte"+b+"\n"+
"short"+s+"\n"+
"int"+i+"\n"+
"long"+l+"\n"+
"float"+f+"\n"+
"double"+d);
}
}
publicclassInitialValues{
publicstaticvoidmain(String[]args){
Measurementd=newMeasurement();
d.print();
/*Inthiscaseyoucouldalsosay:
newMeasurement().print();
*/
}
}///:
~
输入结果如下:
DatatypeInitalvalue
booleanfalse
char
byte0
short0
int0
long0
float0.0
double0.0
其中,Char值为空(NULL),没有数据打印出来。
稍后大家就会看到:
在一个类的内部定义一个对象句柄时,如果不将其初始化成新对象,那个句柄就会获得一个空值。
4.4.1规定初始化
如果想自己为变量赋予一个初始值,又会发生什么情况呢?
为达到这个目的,一个最直接的做法是在类内部定义变量的同时也为其赋值(注意在C++里不能这样做,尽管C++的新手们总“想”这样做)。
在下面,Measurement类内部的字段定义已发生了变化,提供了初始值:
classMeasurement{
booleanb=true;
charc='x';
byteB=47;
shorts=0xff;
inti=999;
longl=1;
floatf=3.14f;
doubled=3.14159;
//...
亦可用相同的方法初始化非基本(主)类型的对象。
若Depth是一个类,那么可象下面这样插入一个变量并进行初始化:
classMeasurement{
Deptho=newDepth();
booleanb=true;
//...
若尚未为o指定一个初始值,同时不顾一切地提前试用它,就会得到一条运行期错误提示,告诉你产生了名为“违例”(Exception)的一个错误(在第9章详述)。
甚至可通过调用一个方法来提供初始值:
classCInit{
inti=f();
//...
}
当然,这个方法亦可使用自变量,但那些自变量不可是尚未初始化的其他类成员。
因此,下面这样做是合法的:
classCInit{
inti=f();
intj=g(i);
//...
}
但下面这样做是非法的:
classCInit{
intj=g(i);
inti=f();
//...
}
这正是编译器对“向前引用”感到不适应的一个地方,因为它与初始化的顺序有关,而不是与程序的编译方式有关。
这种初始化方法非常简单和直观。
它的一个限制是类型Measurement的每个对象都会获得相同的初始化值。
有时,这正是我们希望的结果,但有时却需要盼望更大的灵活性。
4.4.2构建器初始化
可考虑用构建器执行初始化进程。
这样便可在编程时获得更大的灵活程度,因为我们可以在运行期调用方法和采取行动,从而“现场”决定初始化值。
但要注意这样一件事情:
不可妨碍自动初始化的进行,它在构建器进入之前就会发生。
因此,假如使用下述代码:
classCounter{
inti;
Counter(){i=7;}
//...
那么i首先会初始化成零,然后变成7。
对于所有基本类型以及对象句柄,这种情况都是成立的,其中包括在定义时已进行了明确初始化的那些一些。
考虑到这个原因,编译器不会试着强迫我们在构建器任何特定的场所对元素进行初始化,或者在它们使用之前——初始化早已得到了保证(注释⑤)。
⑤:
相反,C++有自己的“构建器初始模块列表”,能在进入构建器主体之前进行初始化,而且它对于对象来说是强制进行的。
参见《ThinkinginC++》。
1.初始化顺序
在一个类里,初始化的顺序是由变量在类内的定义顺序决定的。
即使变量定义大量遍布于方法定义的中间,那些变量仍会在调用任何方法之前得到初始化——甚至在构建器调用之前。
例如:
//:
OrderOfInitialization.java
//Demonstratesinitializationorder.
//Whentheconstructoriscalled,tocreatea
//Tagobject,you'llseeamessage:
classTag{
Tag(intmarker){
System.out.println("Tag("+marker+")");
}
}
classCard{
Tagt1=newTag
(1);//Beforeconstructor
Card(){
//Indicatewe'reintheconstructor:
System.out.println("Card()");
t3=newTag(33);//Re-initializet3
}
Tagt2=newTag
(2);//Afterconstructor
voidf(){
System.out.println("f()");
}
Tagt3=newTag(3);//Atend
}
publicclassOrderOfInitialization{
publicstaticvoidmain(String[]args){
Cardt=newCard();
t.f();//Showsthatconstructionisdone
}
}///:
~
在Card中,Tag对象的定义故意到处散布,以证明它们全都会在构建器进入或者发生其他任何事情之前得到初始化。
除此之外,t3在构建器内部得到了重新初始化。
它的输入结果如下:
Tag
(1)
Tag
(2)
Tag(3)
Card()
Tag(33)
f()
因此,t3句柄会被初始化两次,一次在构建器调用前,一次在调用期间(第一个对象会被丢弃,所以它后来可被当作垃圾收掉)。
从表面看,这样做似乎效率低下,但它能保证正确的初始化——若定义了一个过载的构建器,它没有初始化t3;同时在t3的定义里并没有规定“默认”的初始化方式,那么会产生什么后果呢?
2.静态数据的初始化
若数据是静态的(static),那么同样的事情就会发生;如果它属于一个基本类型(主类型),而且未对其初始化,就会自动获得自己的标准基本类型初始值;如果它是指向一个对象的句柄,那么除非新建一个对象,并将句柄同它连接起来,否则就会得到一个空值(NULL)。
如果想在定义的同时进行初始化,采取的方法与非静态值表面看起来是相同的。
但由于static值只有一个存储区域,所以无论创建多少个对象,都必然会遇到何时对那个存储区域进行初始化的问题。
下面这个例子可将这个问题说更清楚一些:
//:
StaticInitialization.java
//Specifyinginitialvaluesina
//classdefinition.
classBowl{
Bowl(intmarker){
System.out.println("Bowl("+marker+")");
}
voidf(intmarker){
System.out.println("f("+marker+")");
}
}
classTable{
staticBowlb1=newBowl
(1);
Table(){
System.out.println("Table()");
b2.f
(1);
}
voidf2(intmarker){
System.out.println("f2("+marker+")");
}
staticBowlb2=newBowl
(2);
}
classCupboard{
Bowlb3=newBowl(3);
staticBowlb4=newBowl(4);
Cupboard(){
System.out.println("Cupboard()");
b4.f
(2);
}
voidf3(intmarker){
System.out.println("f3("+marker+")");
}
staticBowlb5=newBowl(5);
}
publicclassStaticInitialization{
publicstaticvoidmain(String[]args){
System.out.println(
"CreatingnewCupboard()inmain");
newCupboard();
System.out.println(
"CreatingnewCupboard()inmain");
newCupboard();
t2.f2
(1);
t3.f3
(1);
}
staticTablet2=newTable();
staticCupboardt3=newCupboard();
}///:
~
Bowl允许我们检查一个类的创建过程,而Table和Cupboard能创建散布于类定义中的Bowl的static成员。
注意在static定义之前,Cupboard先创建了一个非static的Bowlb3。
它的输出结果如下:
Bowl
(1)
Bowl
(2)
Table()
f
(1)
Bowl(4)
Bowl(5)
Bowl(3)
Cupboard()
f
(2)
CreatingnewCupboard()inmain
Bowl(3)
Cupboard()
f
(2)
CreatingnewCupboard()inmain
Bowl(3)
Cupboard()
f
(2)
f2
(1)
f3
(1)
static初始化只有在必要的时候才会进行。
如果不创建一个Table对象,而且永远都不引用Table.b1或Table.b2,那么staticBowlb1和b2永远都不会创建。
然而,只有在创建了第一个Table对象之后(或者发生了第一次static访问),它们才会创建。
在那以后,static对象不会重新初始化。
初始化的顺序是首先static(如果它们尚未由前一次对象创建过程初始化),接着是非static对象。
大家可从输出结果中找到相应的证据。
在这里有必要总结一下对象的创建过程。
请考虑一个名为Dog的类:
(1)类型为Dog的一个对象首次创建时,或者Dog类的static方法/static字段首次访问时,Java解释器必须找到Dog.class(在事先设好的类路径里搜索)。
(2)找到Dog.class后(它会创建一个Class对象,这将在后面学到),它的所有static初始化模块都会运行。
因此,static初始化仅发生一次——在Class对象首次载入的时候。
(3)创建一个newDog()时,Dog对象的构建进程首先会在内存堆(Heap)里为一个Dog对象分配足够多的存储空间。
(4)这种存储空间会清为零,将Dog中的所有基本类型设为它们的默认值(零用于数字,以及boolean和char的等价设定)。
(5)进行字段定义时发生的所有初始化都会执行。
(6)执行构建器。
正如第6章将要讲到的那样,这实际可能要求进行相当多的操作,特别是在涉及继承的时候。
3.明确进行的静态初始化
Java允许我们将其他static初始化工作划分到类内一个特殊的“static构建从句”(有时也叫作“静态块”)里。
它看起来象下面这个样子:
classSpoon{
staticinti;
static{
i=47;
}
//...
尽管看起来象个方法,但它实际只是一个static关键字,后面跟随一个方法主体。
与其他static初始化一样,这段代码仅执行一次——首次生成那个类的一个对象时,或者首次访问属于那个类的一个static成员时(即便从未生成过那个类的对象)。
例如:
//:
ExplicitStatic.java
//Explicitstaticinitialization
//withthe"static"clause.
classCup{
Cup(intmarker){
System.out.println("Cup("+marker+")");
}
voidf(intmarker){
System.out.println("f("+marker+")");
}
}
classCups{
staticCupc1;
staticCupc2;
static{
c1=newCup
(1);
c2=newCup
(2);
}
Cups(){
System.out.println("Cups()");
}
}
publicclassExplicitStatic{
publicstaticvoidmain(String[]args){
System.out.println("Insidemain()");
Cups.c1.f(99);//
(1)
}
staticCupsx=newCups();//
(2)
staticCupsy=newCups();//
(2)
}///:
~
在标记为
(1)的行内访问static对象c1的时候,或在行
(1)标记为注释,同时
(2)行不标记成注释的时候,用于Cups的static初始化模块就会运行。
若
(1)和
(2)都被标记成注释,则用于Cups的static初始化进程永远不会发生。
4.非静态实例的初始化
针对每个对象的非静态变量的初始化,Java1.1提供了一种类似的语法格式。
下面是一个例子:
//:
Mugs.java
//Java1.1"InstanceInitialization"
classMug{
Mug(intmarker){
System.out.println("Mug("+marker+")");
}
voidf(intmarker){
System.out.println("f("+marker+")");
}
}
publicclassMugs{
Mugc1;
Mugc2;
{
c1=newMug
(1);
c2=newMug
(2);
System.out.println("c1&c2initialized");
}
Mugs(){
System.out.println("Mugs()");
}
publicstaticvoidmain(String[]args){
System.out.println("Insidemain()");
Mugsx=newMugs();
}
}///:
~
大家可看到实例初始化从句:
{
c1=newMug
(1);
c2=newMug
(2);
System.out.println("c1&c2initialized");
}
它看起来与静态初始化从句极其相似,只是static关键字从里面消失了。
为支持对“匿名内部类”的初始化(参见第7章),必须采用这一语法格式。
- 配套讲稿:
如PPT文件的首页显示word图标,表示该PPT已包含配套word讲稿。双击word图标可打开word文档。
- 特殊限制:
部分文档作品中含有的国旗、国徽等图片,仅作为作品整体效果示例展示,禁止商用。设计者仅对作品中独创性部分享有著作权。
- 关 键 词:
- 第四章初始化和清除 44 第四 初始化 清除