java编程思想4习题答案.docx
《java编程思想4习题答案.docx》由会员分享，可在线阅读，更多相关《java编程思想4习题答案.docx（23页珍藏版）》请在冰点文库上搜索。
java编程思想4习题答案
java编程思想4习题答案
【篇一：
java编程思想第六章习题答案】
ava
//tij4chapterarrays,exercise10,page762
//modifyarrayofgeneric.javatousecontainersinsteadofarrays.
//showthatyoucaneliminatethecompile-timewarnings.
importjava.util.*;
publicclassarrayofgenerics10{
}
//arrays/containercomparison15.java
//tij4chapterarrays,exercise15,page775
//modifycontainercomparison.javabycreatingageneratorfor
//berylliumsphere,andchangemain（）tousethatgenerator
//withgenerated.array（）.
importnet.mindview.util.*;
importjava.util.*;
importstaticnet.mindview.util.print.*;
classberylliumspheregeneratorimplementsgeneratorberylliumsphere{
}
publicberylliumspherenext（）{returnnewberylliumsphere（）;}@suppresswarnings（unchecked）publicstaticvoidmain（string[]args）{}listliststringlls=newarraylistliststring（）;listlistl=newarraylistlist（）;//lls=（listliststring）l;//error:
inconvertibletypeslls.add（newarrayliststring（））;listobjectlo=newarraylistobject（）;//lo=lls;//error:
incompatibletypes//compile-timewarningeliminated:
listlistberylliumspherellb=newarraylistlistberylliumsphere（）;for（inti=0;i10;i++）{llb.add（newarraylistberylliumsphere（））;for（intj=0;j2;j++）llb.get（i）.add（newberylliumsphere（））;}system.out.println（llb）;
publicclasscontainercomparison15{
}
//reusing/sterilizer.java
//tij4chapterreusing,exercise2,page243
/*inheritanewclassfromclassdetergent.overridescrub（）andaddanewmethod*calledsterilize（）.
*/
importstaticorg.greggordon.tools.print.*;
publicclasssterilizerextendsdetergent{
}
//arrays/testarraygeneration16.java
//tij4chapterarrays,exercise16,page775
/*startingwithcountinggenerator.java,createaskipgeneratorclasspublicvoidscrub（）{append（sterilizer.scrub（））;}publicvoidsterilize（）{append（sterilize（））;}publicstaticvoidmain（string[]args）{sterilizerx=newsterilizer（）;x.dilute（）;}x.apply（）;x.scrub（）;x.foam（）;x.sterilize（）;println（x）;println（testingbaseclass:
）;detergent.main（args）;publicstaticvoidmain（string[]args）{berylliumsphere[]spheres=newberylliumsphere[5];berylliumspheregeneratorbsg=newberylliumspheregenerator（）;generated.array（spheres,bsg）;}print（arrays.tostring（spheres））;print（spheres[4]）;listberylliumspherespherelist=newarraylistberylliumsphere（）;for（inti=0;i5;i++）spherelist.add（bsg.next（））;print（spherelist）;print（spherelist.get（4））;
*thatproducesnewvaluesbyincrementingaccordingtoaconstructor*argument.modifytestarraygeneration.javatoshowthatyournew*classworkscorrectly.
*/
importjava.util.*;
importnet.mindview.util.*;
importstaticnet.mindview.util.print.*;
publicclasstestarraygeneration16{
}publicstaticvoidmain（string[]args）{}intsize=6;intskip=7;boolean[]a1=convertto.primitive（generated16.array（newboolean[size],newskipgenerator16.boolean（skip）,skip））;print（a1=+arrays.tostring（a1））;byte[]a2=convertto.primitive（generated16.array（newbyte[size],newskipgenerator16.byte（skip）,skip））;print（a2=+arrays.tostring（a2））;char[]a3=convertto.primitive（generated16.array（newcharacter[size],newskipgenerator16.character（skip）,skip））;print（a3=+arrays.tostring（a3））;short[]a4=convertto.primitive（generated16.array（newshort[size],newskipgenerator16.short（skip）,skip））;print（a4=+arrays.tostring（a4））;int[]a5=convertto.primitive（generated16.array（newinteger[size],newskipgenerator16.integer（skip）,skip））;print（a5=+arrays.tostring（a5））;long[]a6=convertto.primitive（generated16.array（newlong[size],newskipgenerator16.long（skip）,skip））;print（a6=+arrays.tostring（a6））;float[]a7=convertto.primitive（generated16.array（newfloat[size],newskipgenerator16.float（skip）,skip））;print（a7=+arrays.tostring（a7））;double[]a8=convertto.primitive（generated16.array（newdouble[size],newskipgenerator16.double（skip）,skip））;print（a8=+arrays.tostring（a8））;
//solutionincludes,insamepackage:
/***************************
importnet.mindview.util.*;
tnext（intn）;
}
publicclassskipgenerator16{
publicstaticclass
booleanimplementsskipgeneratorjava.lang.boolean{privatebooleanvalue=false;
privateintn;boolean（intn）{this.n=n;}
publicjava.lang.booleannext（）{return!
value;}
publicjava.lang.booleannext（intn）{
value=n%2==0?
true:
false;
returnvalue;
}
}
publicstaticclass
byteimplementsskipgeneratorjava.lang.byte{
privatebytevalue=0;
privateintn;
byte（intn）{this.n=n;}
publicjava.lang.bytenext（）{returnvalue++;}
publicjava.lang.bytenext（intn）{returnvalue+=n;}
}
staticchar[]chars=（abcdefghijklmnopqrstuvwxyz+
abcdefghijklmnopqrstuvwxyz）.tochararray（）;
publicstaticclass
characterimplementsskipgeneratorjava.lang.character{intindex=-1;
privateintn;
character（）{intindex=-1;}character（intn）{this.n=n;}
publicjava.lang.characternext（）{
index=（index+1）%chars.length;
returnchars[index];
}
publicjava.lang.characternext（intn）{
index=（index+1+n）%chars.length;
returnchars[index];
}
}
publicstaticclass
stringimplementsskipgeneratorjava.lang.string{privateintlength=7;
skipgeneratorjava.lang.charactercg=newcharacter（）;publicstring（）{}
publicstring（intlength）{this.length=length;}publicjava.lang.stringnext（）{
char[]buf=newchar[length];
for（inti=0;ilength;i++）
buf[i]=cg.next（）;
returnnewjava.lang.string（buf）;
}
publicjava.lang.stringnext（intn）{char[]buf=newchar[length];for（inti=0;ilength;i++）buf[i]=cg.next（n）;returnnewjava.lang.string（buf）;
}
}
publicstaticclass
shortimplementsskipgeneratorjava.lang.short{privateshortvalue=0;
privateintn;
short（intn）{this.n=n;}
publicjava.lang.shortnext（）{returnvalue++;}
publicjava.lang.shortnext（intn）{returnvalue+=n;}}
publicstaticclass
integerimplementsskipgeneratorjava.lang.integer{privateintvalue=0;
privateintn;
integer（intn）{this.n=n;}publicjava.lang.integernext（）{returnvalue++;}
publicjava.lang.integernext（intn）{returnvalue+=n;}}
publicstaticclass
longimplementsskipgeneratorjava.lang.long{privatelongvalue=0;
privateintn;long（intn）{this.n=n;}
publicjava.lang.longnext（）{returnvalue++;}
publicjava.lang.longnext（intn）{returnvalue+=n;}}
publicstaticclass
floatimplementsskipgeneratorjava.lang.float{
【篇二：
java编程思想第四版_读书笔记】
面向对象程序设计（object-orientedprogrammingoop），uml（unitiedmodellinglanguage统一建模语言）。
将对象想像成“服务提供者”，它们看起来像什么？
能够提供哪些服务？
需要哪些对象？
2.java中动态绑定是默认行为。
java采用动态内存分配方式，通过new操作在堆（heap）的内存池中动态创建对象。
java存储结构类型：
1）寄存器2）堆栈，主要存储对象引用3）堆，主要用于存放所有的java对象4）常量存储，也就是程序代码区5）非ram存储，如流对象和持久化对象。
基本类型不用new来创建变量，而且这个变量直接存储”值”，并置于堆栈中。
3.biginteger和bigdecimal的使用。
当变量作为类的成员使用时当变量作为类的成员使用时，java才确保给定其默认初当变量作为类的成员使用时始值，但是在方法中定义的变量，它有可能是任意值。
面向对象的程序设计可以归纳为“向对象发送消息”。
关键字static。
4.javadoc只能为public和protected成员进行文档注释，但是也可以通过-private进行标记注释。
javadoc常用方法：
@see引用其他类，linkpackage.class#memberlabel}，{@{@docroot}，{@inheritdoc},@version，@author，@since,@param，@return,@throws,@deprecated。
5.整数除法会直接去掉结果的小数位。
基本类型的对象如果直接对它们赋值，对象指向同一个常量存储区，但是如果通过对象来初始化则会指向不同的堆的存储区。
如：
stringst1=newstring（a）;stringst2=newstring（a）;st1==st2falsestringst1=a;stringst2=a;st1==st2true
6.逻辑操作符：
与（）、或（||）、非（!
），其中与（）、或（||）会产生短路现象。
|也支持逻辑也支持逻辑
运算操作。
运算操作
7.直接常量中l代表long，f代表float，d代表double。
显示二进制形式的话，可以通过integer和long类的静态方法tobinarystring（）。
如：
long.tobinarystring（10l）。
8.在返回void的方法中没有return语句，那么在该方法的结尾处会有一个隐式的return。
一般情况下每个方法都会有一个显示的return语句。
9.break用于强行退出循环，不执行循环中剩余的语句，而continue则停止执行当前的迭代，然后退回循环起始处，开始下一次迭代。
goto仍是java的一个保留字，但在语言中并未使用它。
break和continue与标签一起使用，可以中断循环，直到标签所在的地方。
this用法：
publicclassleaf{inti=0;leafincrement（）{i++;returnthis;}}
10.回答一个新技术的问题大概思路和步骤是：
我们想干什么，怎么干，干的过程中遇到了什么问题，现在用什么方式来解决。
答题时，先答是什么，再答有什么作用和要注意什么（这部分最重要，展现自己的心得）。
11.finalize的使用：
垃圾回收只与内存有关，当“垃圾回收”时，finalize（）得到调用。
java中的对象都能被垃圾回收器回收，但是在“本地方法”的情况下，有可能在分配内存时采用类似c语言的做法通过malloc（）函数来分配存储空间时，这时只能通过free（）函数来释放空间，而这些释放操作必须要放到finalize（）方法中，垃圾回收器才能正确的释放内存。
“垃圾回收”都不保证一定会发生。
12.垃圾回收原理：
引用记数引用记数是一种简单但速度很慢的垃圾回收技术。
每个对象都含有一个引用记数
1
java编程思想第四版读书笔记
引用记数器，当有引用连接至对象时，引用计数加1。
当引用离开作用域或被置为null时，引用计数减1。
垃圾回收器会在含有全部对象的列表上遍历，当发现某个对象的引用计数为0时，就立即释放其占用的空间。
定位交互自引用的对象组所需的工作量极大，所以并没有被应用于任何一种java虚拟机中。
java虚拟机采用一种自适应自适应的垃圾
回收技术，java虚拟机会自适应进行监视，如果所有对象都很稳定，垃圾回收器的效率降低的话，就切换到“标记-清扫”方式；同样，java虚拟机会跟踪“标记-清扫”的效果，要是堆空间出现很多碎片，就会切换回“停止-复制”方式。
“停止-复制”，先暂停程序的运行，然后将所有存活存活的对象从当前存活堆复制到另一个堆，没有被复制的全部都是垃圾。
“标记-清扫”，从堆栈和静态存储区出发，遍历所有的引用，进而找出所有存活的对象，每当它找到一个存活对象，就会给对象设一个标记，这个过程中不会回收任何对象，只有全部标记工作完成的时候，清理动作才会开始。
在清理过程中，没有标记的对象将被释放，不会发生下任何复制动作。
13.初始化顺序:
先静态对象，后“非静态”对象，先变量，再构造函数，然后是方法。
静态初始化只有在必要时刻才会进行，如果不引用其对象，那么该对象中的静态成员将不会被创建，而且它们只会在第一次被访问时进行初始化，其后不会再次被初始化。
14.对象的创建过程：
1）当首次创建对象时，或类的静态方法/静态域首次被访问时，java解释器必须查找类路径，以定位.class文件。
2）载入.class，有关静态初始化的所有动作都会执行。
3）当用new创建对象时，在堆上为对象分配存储空间，而且这块存储空间会被清零，也就是说它会自动地将对象中的所有基本类型数据都设置成默认值，而引用是被设置成null。
4）执行所有出现于字段定义处的初始化动作。
5）执行构造器。
15.数组：
java.util.arrays常用方法的使用。
binarysearch（）,copyof（）,aslist（）,copyofrange（）,equals（）,fill（）,sort（）,tostring（）,hashcode（）。
可变参数列表:
voidf（floati,character?
args）。
枚举类型:
enum,它可以在switch语句内使用。
16.类的结构依次为：
1）包的注释2）package的设置3）import导入设置4）类的注释5）类的编写。
17.java的访问权限：
类的访问权限只有public和默认包访问权限，成员和方法有public,protected,默认包访问权限和private。
使用类的客户端程序是无法访问包访问权限成员的。
包访问权限的类的对象可以由包内任何其他类来创建和使用，但是包外则不行。
18.为了继承，一般的规则是将所有的数据成员都指定为private，将所有的方法指定为public或protected。
java会自动在导出类的构造器中插入对基类构造器的调用。
调用基类的构造器必须是你在导出类构造器中要做的第一件事。
19.代理，它是继承与组合之间的中庸之道，因为我们将一个成员对象置于所要构造的类中（就像组合），但与此同时我们在新类中暴露了该成员对象的所有方法（就像继承）。
20.清理方法的顺序：
首先，执行类的所有特定的清理动作，其顺序同生成顺序相反；然后，调用基类的清理方法。
除了内存之外，不能依赖垃圾回收器去做任何事，如果需要进行清理，最好是编写自己的清理方法，但不要使用finalize（）。
@override注解可以防止在你不
升级会员 