java问题总结.docx
《java问题总结.docx》由会员分享，可在线阅读，更多相关《java问题总结.docx（21页珍藏版）》请在冰点文库上搜索。
java问题总结
Java基础问题
问题1：
Question49：
publicclassQues49{
publicstaticvoidmain（String[]args）{
Employeeemployee=newEmployee（"4321"）;
System.out.println（employee.empID）;
}
}
classPerson{
Stringname="Noname";
/*publicPerson（）{
this（"fern"）;
System.out.println（"Person1"）;
};*/
publicPerson（Stringnm）{
name=nm;
System.out.println（"Person2="+nm）;
}
}
classEmployeeextendsPerson{
StringempID="0000";
publicEmployee（Stringid）{
//super（id）;
empID=id;
}
}
问题：
为什么需要在父类中定义一个默认的构造函数或者需要在子类的构造函数中加super
问题2：
Question101：
publicclassQues101extendsFruit1{
intsize=42;
publicstaticvoidmain（String[]args）{
Ques101b=newQues101（）;
//对象序列化
ObjectOutputStreamoos=null;
try{
oos=newObjectOutputStream（newFileOutputStream（"D:
\\food.txt"））;
oos.writeObject（b）;
}catch（Exceptione）{
e.printStackTrace（）;
}finally{
}
//反序列化
ObjectInputStreamois=null;
try{
ois=newObjectInputStream（newFileInputStream（"D:
\\food.txt"））;
b=（Ques101）ois.readObject（）;
System.out.println（"restored"+b.size+""）;
}catch（Exceptione）{
e.printStackTrace（）;
}finally{
}
}
}
classFood1{
Food1（）{
System.out.println（"1"）;
}
}
classFruit1extendsFood1implementsSerializable{
privatestaticfinallongserialVersionUID=1L;
publicFruit1（）{
System.out.println（"2"）;
}
}
输出：
121restored42
问题：
反序列化机制无需通过构造器来初始化对象，如何理解？
问题3：
Question29：
publicclassQues29{
publicstaticvoidmain（String[]args）{
int[]x={1,2,3,4,5,6};
int[]y=x;
/**
*输出结果相同，“[I@de6ced[I@de6ced”，内存地址相同，说明x和y指向同一个对堆内存空间
*/
System.out.println（x）;
System.out.println（y）;
System.out.println（x[2]）;
System.out.println（y[2]）;
}
}
输出结果：
[I@de6ced
[I@de6ced
3
3
问题：
数组x和数组y的栈内存和堆内存的情况？
问题4：
Question102：
publicclassQues102implementsSerializable{
privateintx;
publicintgetX（）{
returnx;
}
publicQues102（intx）{
this.x=x;
}
privatevoidwriteObject（ObjectOutputStreams,Objectb）throwsIOException{
//s.defaultWriteObject（）;
s.writeObject（b）;
}
publicstaticvoidmain（String[]args）{
Ques102b=newQues102（100）;
//对象序列化
ObjectOutputStreamoos=null;
try{
oos=newObjectOutputStream（newFileOutputStream（"D:
\\food.txt"））;
//oos.writeObject（b）;
//oos.defaultWriteObject（）;//使用默认的“写对象”
//b.writeObject（oos）;
b.writeObject（oos,b）;
}catch（Exceptione）{
e.printStackTrace（）;
}finally{
}
//反序列化
ObjectInputStreamois=null;
try{
ois=newObjectInputStream（newFileInputStream（"D:
\\food.txt"））;
b=（Ques102）ois.readObject（）;
System.out.println（"restored"+b.x+""）;
}catch（Exceptione）{
e.printStackTrace（）;
}finally{
}
}
}
问题：
defaultWriteObject（）的使用
问题5：
Question119：
publicclassQues119extendsThread{
privateintx=2;
publicstaticvoidmain（String[]args）throwsException{
newQues119（）.makeItSo（）;
newQues119（）.go（）;
}
publicQues119（）{
x=5;
System.out.println（Thread.currentThread（）.getName（））;
start（）;
}
publicvoidmakeItSo（）throwsException{
join（）;
x=x-1;
System.out.println（"makeItSo"+x）;
}
publicvoidrun（）{
System.out.println（Thread.currentThread（）.getName（））;
x*=2;
System.out.println（"run"+x）;
}
publicvoidgo（）{
System.out.println（"gogogo"+x）;
}
}
输出：
main
Thread-0
run10
makeItSo9
main
gogogo5
Thread-1
run10
问题：
join（）
问题6：
Question123：
publicclassQues123{
privatestaticObjectresource=newObject（）;
privatestaticvoiddelay（longn）{
try{
Thread.sleep（n）;
}catch（Exceptione）{
System.out.println（"error"）;
e.printStackTrace（）;
}
}
publicstaticvoidmain（String[]args）{
System.out.println（"StartMain"）;
newThread1（）.start（）;
delay（1000）;
Thread2thread2=newThread2（）;
thread2.start（）;
delay（1000）;
thread2.interrupt（）;
delay（1000）;
System.out.println（"EndMain"）;
}
staticclassThread1extendsThread{
publicvoidrun（）{
synchronized（resource）{
System.out.println（"Start1"）;
delay（6000）;
System.out.println（"End1"）;
}
}
}
staticclassThread2extendsThread{
publicvoidrun（）{
synchronized（resource）{
System.out.println（"Start2"）;
delay（2000）;
System.out.println（"End2"）;
}
}
}
}
输出结果：
StartMain
Start1
EndMain
End1
java.lang.InterruptedException:
sleepinterruptedStart2
error
End2
atjava.lang.Thread.sleep（NativeMethod）
atQues123.delay（Ques123.java:
11）
atQues123.access$1（Ques123.java:
9）
atQues123$Thread2.run（Ques123.java:
50）
问题：
interrupt（）;后为何报错
问题6：
Question125：
publicclassQues125{
intx=0;
publicclassRunnerimplementsRunnable{
@Override
publicvoidrun（）{
intcurrent=0;
for（inti=0;i<4;i++）{
current=x;
System.out.println（current+","+Thread.currentThread（）.getName（））;
x=current+2;
}
}
}
publicstaticvoidmain（String[]args）{
newQues125（）.go（）;
}
publicvoidgo（）{
Runnablerunnable=newRunner（）;
newThread（runnable）.start（）;
newThread（runnable）.start（）;
}
}
选题答案：
0，2，4，4，6，8，10，6
和0，2，4，6，8，10，12，14
自己试验的结果如下：
输出结果1：
0,Thread-0
0,Thread-1
2,Thread-0
2,Thread-1
4,Thread-0
4,Thread-1
6,Thread-1
6,Thread-0
输出结果2：
0,Thread-0
2,Thread-0
2,Thread-1
4,Thread-0
4,Thread-1
6,Thread-0
6,Thread-1
8,Thread-1
输出结果3：
0,Thread-0
2,Thread-0
4,Thread-0
6,Thread-0
8,Thread-1
10,Thread-1
12,Thread-1
14,Thread-1
问题7：
Question126：
publicclassQues126{
privateListnames=newArrayList（）;
publicsynchronizedvoidadd（Stringname）{
names.add（name）;
}
publicsynchronizedvoidprintAll（）{
for（inti=0;iSystem.out.println（names.get（i）+""）;
}
}
publicstaticvoidmain（String[]args）{
finalQues126sl=newQues126（）;
for（inti=0;i<2;i++）{
newThread（）{
publicvoidrun（）{
sl.add（"A"+Thread.currentThread（）.getName（））;
sl.add（"B"+Thread.currentThread（）.getName（））;
sl.add（"C"+Thread.currentThread（）.getName（））;
sl.printAll（）;
}
}.start（）;
}
}
}
答案结果：
ABCABCABC
ABCAABCABC
试验输出结果：
结果1：
AThread-0
BThread-0
CThread-0
AThread-0
BThread-0
CThread-0
AThread-1
BThread-1
CThread-1
结果2：
AThread-0
AThread-1
BThread-0
BThread-1
CThread-0
CThread-1
AThread-0
AThread-1
BThread-0
BThread-1
CThread-0
CThread-1
设计模式篇
问题1：
傅
各种设计模式在实际开发中的应用？
我们在将来的实际项目开发中，将如何正确使用设计模式？
设计模式是一套被反复使用验证,对代码设计经验的总结。
使用设计模式是为了可重用代码、提高代码可维护性,可理解性、保证代码可靠性。
一方面,设计模式是对代码设计经验的总结,另一方面,设计模式也被经常的使用到各高效,成熟,稳定的系统架构中
也就是说在现有成熟系统中运行着无数这样的高质量的代码,比如Java本身,Android的设计,无处不存在对设计模式的运用
撰写高质量的代码是每个开发人员应当追求的目标
设计模式学习和使,我总结的经验是1.多写代码,2.多看代码,3.设计模式的案列结合实际系统来看,比如学习一个设计模式,可以去找找java中,android哪里用到了,是怎么用的
另外一点,设计模式并不是生搬硬套的,有时会出现各种变种,或者交叉使用
问题2：
黄
工厂模式中，子类实例化的好处？
与父类实例化的区别？
工厂方法定义一个创建产品的接口,由子类（工厂）来实现这个接口,在这个接口方法里来实例化具体产品
相比简单工厂,是更高一层的抽象,简单工厂在一个类里面来实例化多种产品,对于要扩展一个新产品就会需要修改代码,而工厂方法就能在不修改原有代码的情况下,新增一个工厂类来产生新产品,从这点来说工厂方法更易于扩展
问题3：
黄
接口和抽象类的区别？
为什么接口让代码更具有弹性？
具体体现在哪里？
这个很基本的东西了,很多面试题都会提到这个吧,建议多看看书和相关资料先,如果这个没明白,后面讲再多也白搭
问题4：
黄
命令模式与模块方法模式的区别？
理论的东西不讲了,我举个列子
Java的线程实现了Runnable接口,这就是个典型的命令模式
Activity生命周期,就是一个典型的模块方法
问题5：
顾
抽象工厂模式？
看书去
问题6：
傅
模板方法模式，P295页中，如何理解将这些步骤实现成钩子，而不是实现成抽象方法，这样就可以让抽象类的子类的负荷减轻？
书本中提到的例子哪些地方体现上句话的内容？
以Activity生命周期为例,为什么有些步骤在父类实现,为什么有的才让子类来实现:
Activity负责全局的生命周期,很多钩子方法在父类中已有默认实现,但子类可以改写他来做更深的定制
抽象方法在父类不实现,全由子类来实现
子类在不改写钩子的情况下默认调用父类的实现,当然减轻了负荷,至少代码变少了啊
P300页开始的“用模板方法排序”中，如何理解“排序”也是一种模板方法？
不是“排序”也是一种模板方法
是可以用模板方法模式来实现排序算法
比如,java中list类的sort方法就是用的模板方法模式（某种程度上也可认为是策略模式）
他只提供了一个sort方法,这个方法实现了一个归并排序算法的模板,但排序最根本,大家知道对于数字就是比大小,字母就是比先后,但其他对象呢,怎么得到这个准则,所以sort方法对外暴露了一个实现了compare方法的Comparator接口对象
compare方法就是用来得知,俩对象,俩俩比较的时候,谁排第一谁排第二
问题7：
傅
模板方法和策略的比较，及其在实际场合的应用。
前面讲到了,Activity生命周期就是典型的模板方法模式
模板方法和策略有相通的地方,都是子类来实现父类需要实现的方法
但策略侧重于多个子类来实现同样的接口或者抽象方法,在编译时或运行时通过判断（配置或某种策略）来加载/实例化具体子类,并且这些子类是可以置换的
策略模式,android中状态栏运用了此模式,分别实现了phone和pad的相关类,并通过配置来决定使用那种模式
问题8：
傅
网上看到的话：
“设计模式就是定式，碰到这种场合你才用得上，所以学习设计模式，你只需要花2个小时过一遍，脑子里面有个印象就赶快收手，到用的时候再去copy&paste”。
对于我们这些没有什么项目经验的初学者来说，设计模式的学习是一个怎样的过程？
如果把《HeadFirst设计模式》中所有的例子都消化了，但是在实际应用中却还是不知道该用什么设计模式怎么办？
公司开发的项目中有没有一些固定的模块使用了相关的设计模式，我们在以后的实际开发中可以套用这些模块？
见问题1
//问题9：
傅
p136页，工厂模式中。
工厂模式的好处：
将创建对象的代码集中在一个对象或方法中，可以避免代码中的重复，并且方便以后的维护。
这意味着客户实例化对象时，只会依赖于接口，而不是具体类。
我在学习中可以发现，这可以帮助我针对接口编程，而不是针对实现编程。
这让代码更具有弹性，可以应对未来的扩展。
书本中的例子：
以上将创建对象的代码集中在一个方法中。
这方法之前你要产生NYStylePepperonPizza是不是得依赖具体类NYStylePepperonPizza.class
使用之后,你只要调用NYPizzaStore.CreatePizza（“pepperoni”）,就不用依赖具体类了
从下面的代码中如何理解“这意味着客户实例化对象时，只会依赖于接口，而不是具体类”？
依赖于orderPizza接口方法而不是具体去new某个具体类
p156页中，“抽象工厂允许客户使用抽象的接口来创建一组相关的产品，而不需要知道（或关心）实际产出的具体产品是什么。
”如何在代码中体现？
看书看代码去
这么说吧
简单工厂就是抽象产品,一个工厂生产多个产品,告诉工厂需要什么就能得到什么
工厂方法就是从工厂层次进行抽象,一个工厂对应一个产品,告知我要什么工厂就能得到什么产品
抽象工厂同时抽象产品和工厂,n个工厂,每个工厂产生多种产品,告诉
每一次都是站在更高的层次来进行抽象以获得更高层次的扩展或更多的对象,更好的弹性
开场白
许多学生认为数学是枯燥的、乏味的。
一些非数学老师在听完一堂数学课后，往往这样评价：
思路清晰、语言精练、解题严谨，就是太乏味、缺少趣味性，让人昏昏欲睡。
那么，如何调动学生的上课积极性，引发他们的好奇心？
设计好“开场白”，非常关键。
下面是数学课的几个片断：
动手实验式“开场白”：
桌上摆满了切成各种形状的萝卜，大伙好像还在热列地讨论着什么。
老师微笑问：
“同学们，用一个平面去截一个正方体，截出的面可能是什么形状？
”
悬念式“开场白”：
老师一上讲台，故意神神秘秘地说“你们每人随便想一个自然数，将这个数乘5减7，再把结果乘2加14”。
……“你们算得的结果个位数字一定是0”。
顿时教室里象炸了锅似的，……“等你学了字母表示数，你也会算了”。
……
故事式“开场白”：
为了让学生体会图形的边长、周长、面积在变化过程中的关系，领会列方程解应用题时，关键是捕捉到不变的量。
老师先给学生讲了一个故事：
父亲的羊越来越多，想拆旧羊圈扩大面积，可是没有多余的篱笆，怎么办呢？
他叫来了儿子,儿子不慌不忙地说：
“爸，我有办法”。
“你看，旧羊圈长70米，宽30米，面积2100平方米。
如果改成50米见方的新羊圈，不用添篱笆，羊圈面积就有2500平方米”。
诸如此类的还有：
“贴近生活式”开场白；“设疑式”开场白；“名言式”开场白；“趣味式”开场白；“实例式”开场白；“比喻式”开场白等等。
向学生提出恰当的问题，激发起学生的兴趣，提高他们学习的积极性。
开场白
许多学生认为数学是枯燥的、乏味的。
一些非数学老师在听完一堂数学课后，往往这样评价：
思路清晰、语言精练、解题严谨，就是太乏味、缺少趣味性，让人昏昏欲睡。
那么，如何调动学生的上课积极性，引
升级会员 