JAVA面试题小练习2参考答案.docx
《JAVA面试题小练习2参考答案.docx》由会员分享，可在线阅读，更多相关《JAVA面试题小练习2参考答案.docx（15页珍藏版）》请在冰点文库上搜索。
JAVA面试题小练习2参考答案
T142面试题小练习参考答案（总分100’+20’）
一、JavaScript部分
1）程序运行后k的结果是多少？
（5’）
for（vari=0,j=0;i<10,j<6;i++,j++）{
k=i+j;
}
10，要小心陷阱
2）程序运行后y和z的值是多少？
（5’）
varx=1;
vary=0;
varz=0;
functionadd（n）{n=n+1;}
y=add（x）;
functionadd（n）{n=n+3;}
z=add（add（x）;
undefined，因为两个函数都没有返回值。
3）简述DIV元素和SPAN元素的区别。
（5’）
DIV是块级元素，默认换行显示；SPAN是行内（内嵌）元素，默认同一行显示。
扩展：
DIV默认为块元素，定义display属性值为inline后以行内（内嵌）元素显示；而SPAN默认为内嵌元素，定义display属性值为block后则以块元素显示。
4）说说innerHTML和innerText的区别。
（5’）
innerHTML是指从对象起始位置到终止位置的全部内容，包括标签,而innerText是指从对象起始位置到终止位置的内容，除去标签
扩展：
outerHTML：
除了包含innerHTML的全部内容外, 还包含对象标签本身。
innerHTML是符合W3C标准的属性，而innerText只适用于IE浏览器，因此，尽可能地去使用innerHTML，而少用innerText，如果要输出不含HTML标签的内容，可以使用innerHTML取得包含HTML标签的内容后，再用正则表达式去除
5）填充注释部分的函数体，使得foo（）函数调用弹出“成功”的对话框。
代码应尽量简短。
（20’）
functionfoo（）{
varstr=reverse（'a,b,c,d,e,f,g'）;
alert（str）;
if（str=='g,f,e,d,c,b,a'）
alert（'成功'）;
else
alert（'失败'）;
}
functionreverse（str）{
//在此处加入代码，完成字符串翻转功能
}
参考答案：
（其他可以达到效果的Code同样给分）
方法一：
functionreverse（str）{
varspl=str.split（','）;
varnewstr="";
for（i=spl.length-1;i>=0;i--）{
newstr+=spl[i]+',';
}
newstr=newstr.substring（0,newstr.length-1）
returnnewstr;
}
方法二：
functionreverse（str）{
returnstr.split（","）.reverse（）.join（","）;
}
扩展：
JavaScript中允许存在同名同参的函数。
存在同名函数时，会执行最后一个定义的（覆盖前面定义的）函数。
二、Java-OOP部分
1）一个".java"源文件中是否可以包括多个类（不是内部类）？
有什么限制？
（8’）
可以有多个类，但只能有一个public的类，而且这个类必须与文件名相同。
2）Overload和Override的区别。
参数列表相同、返回值类型不同是否构成Overload?
（上海银之杰科技有限公司、上海快钱等）（8’）
Overload：
重载，方法同名不同参构成方法的重载，而不关注方法的返回值类型；
Override：
重写，表示子类对继承过来的父类的方法的重新定义，它要求参数列表必须跟父类的相同，返回值类型原则上也要求相同。
（子类当父类用的返回值类型除外）
不构成，因为构成重载要求不同的参数列表。
3）Static方法有什么作用？
（宏基（上海））（4’）
能够通过类名，而不用创建实例化对象就能直接调用。
扩展：
演示TStatic代码。
4）说说final和finally的作用（上海快钱、启明星等）（10’）
Final关键字：
修饰变量时，表示常量，只能赋值一次；
修饰方法时，该方法不能被重写；
修饰类时，该类不能被继承。
Finally关键字：
是异常处理语句结构的一部分，表示总是执行。
扩展：
finalize是Object类的一个方法，在垃圾收集器执行的时候会调用被回收对象的此方法，可以覆盖此方法提供垃圾收集时的其他资源回收，例如关闭文件等。
JVM不保证此方法总被调用。
JVM:
JavaVirtualMachine，Java虚拟机，是一种用于计算设备的规范，是一个虚构出来的计算机，是通过在实际的计算机上仿真模拟各种计算机功能来实现的。
5）接口是否可继承接口?
抽象类是否可实现接口?
抽象类是否可继承实体类?
（15’）
可以，可以，可以
扩展：
抽象类中是否可以有静态的main方法？
可以。
作为一个程序开发者，明白了开发语言设计的本质和规范，判断一种程序设计是否合理在于你能不能说出它的不合理之处，不能说出的话那就是合理的。
6）华为科技面试题：
①.Pleasewritetheoutputresult。
（15’）
publicclassTest{
publicstaticvoidchangeStr（Stringstr）{
str="welcome";
}
publicstaticvoidmain（String[]args）{
Stringstr="1234";
changeStr（str）;
System.out.println（str）;
}
}
1234
②.拓展：
Whatistheresult?
（+20’,供有兴趣同学做）
staticbooleanfoo（charc）{
System.out.print（c）;
returntrue;
}
publicstaticvoidmain（String[]argv）
{
inti=0;
for（foo（'A'）;foo（'B'）&&（i<2）;foo（'C'））
{
i++;
foo（'D'）;
}
}
ABDCBDCB
拓展：
关于堆和栈
1.寄存器：
最快的存储区,由编译器根据需求进行分配,我们在程序中无法控制.
2.栈：
存放基本类型的变量数据和对象的引用，但对象本身不存放在栈中，而是存放在堆（new出来的对象）或者常量池中（字符串常量对象存放在常量池中。
）
3.堆：
存放所有new出来的对象。
4.静态域：
存放静态成员（static定义的）
5.常量池：
存放字符串常量和基本类型常量（publicstaticfinal）。
6.非RAM存储：
硬盘等永久存储空间
这里我们主要关心栈，堆和常量池，对于栈和常量池中的对象可以共享，对于堆中的对象不可以共享。
栈中的数据大小和生命周期是可以确定的，当没有引用指向数据时，这个数据就会消失。
堆中的对象的由垃圾回收器负责回收，因此大小和生命周期不需要确定，具有很大的灵活性。
对于字符串：
其对象的引用都是存储在栈中的，如果是编译期已经创建好（直接用双引号定义的）的就存储在常量池中，如果是运行期（new出来的）才能确定的就存储在堆中。
对于equals相等的字符串，在常量池中永远只有一份，在堆中有多份。
newString（"China"）;
对于通过new产生一个字符串（假设为”china”）时，会先去常量池中查找是否已经有了”china”对象，如果没有则在常量池中创建一个此字符串对象，然后堆中再创建一个常量池中此”china”对象的拷贝对象。
这也就是有道面试题：
Strings=newString（“xyz”）;产生几个对象？
一个或两个，如果常量池中原来没有”xyz”,就是两个。
对于成员变量和局部变量：
成员变量就是方法外部，类的内部定义的变量；局部变量就是方法或语句块内部定义的变量。
局部变量必须初始化。
形式参数是局部变量，局部变量的数据存在于栈内存中。
栈内存中的局部变量随着方法的消失而消失。
成员变量存储在堆中的对象里面，由垃圾回收器负责回收。
（二）、Java内存分配中的栈
在函数中定义的一些基本类型的变量数据和对象的引用变量都在函数的栈内存中分配。
当在一段代码块定义一个变量时，Java在栈中为这个变量分配内存空间，当该变量退出其作用域后，Java会自动释放掉为该变量所分配的内存空间，该内存空间可以立即被另作他用。
Java内存分配中的堆
堆内存用来存放由new创建的对象和数组。
在堆中分配的内存，由Java虚拟机的自动垃圾回收器来管理。
在堆中产生了一个数组或对象后，还可以在栈中定义一个特殊的变量，让栈中这个变量的取值等于数组或对象在堆内存中的首地址，栈中的这个变量就成了数组或对象的引用变量。
引用变量就相当于是为数组或对象起的一个名称，以后就可以在程序中使用栈中的引用变量来访问堆中的数组或对象。
引用变量就相当于是为数组或者对象起的一个名称。
引用变量是普通的变量，定义时在栈中分配，引用变量在程序运行到其作用域之外后被释放。
而数组和对象本身在堆中分配，即使程序运行到使用new产生数组或者对象的语句所在的代码块之外，数组和对象本身占据的内存不会被释放，数组和对象在没有引用变量指向它的时候，才变为垃圾，不能在被使用，但仍然占据内存空间不放，在随后的一个不确定的时间被垃圾回收器收走（释放掉）。
这也是Java比较占内存的原因。
实际上，栈中的变量指向堆内存中的变量，这就是Java中的指针！
常量池（constantpool）
常量池指的是在编译期被确定，并被保存在已编译的.class文件中的一些数据。
除了包含代码中所定义的各种基本类型（如int、long等等）和对象型（如String及数组）的常量值（final）还包含一些以文本形式出现的符号引用，比如：
类和接口的全限定名；
字段的名称和描述符；
方法和名称和描述符。
虚拟机必须为每个被装载的类型维护一个常量池。
常量池就是该类型所用到常量的一个有序集和，包括直接常量（string,integer和floatingpoint常量）和对其他类型，字段和方法的符号引用。
对于String常量，它的值是在常量池中的。
而JVM中的常量池在内存当中是以表的形式存在的，对于String类型，有一张固定长度的CONSTANT_String_info表用来存储文字字符串值，注意：
该表只存储文字字符串值，不存储符号引用。
说到这里，对常量池中的字符串值的存储位置应该有一个比较明了的理解了。
在程序执行的时候,常量池会储存在MethodArea,而不是堆中。
堆与栈
Java的堆是一个运行时数据区,类的（对象从中分配空间。
这些对象通过new、newarray、anewarray和multianewarray等指令建立，它们不需要程序代码来显式的释放。
堆是由垃圾回收来负责的，堆的优势是可以动态地分配内存大小，生存期也不必事先告诉编译器，因为它是在运行时动态分配内存的，Java的垃圾收集器会自动收走这些不再使用的数据。
但缺点是，由于要在运行时动态分配内存，存取速度较慢。
栈的优势是，存取速度比堆要快，仅次于寄存器，栈数据可以共享。
但缺点是，存在栈中的数据大小与生存期必须是确定的，缺乏灵活性。
栈中主要存放一些基本类型的变量数据（int,short,long,byte,float,double,boolean,char）和对象句柄（引用）。
栈有一个很重要的特殊性，就是存在栈中的数据可以共享。
假设我们同时定义：
inta=3;intb=3；编译器先处理inta=3；首先它会在栈中创建一个变量为a的引用，然后查找栈中是否有3这个值，如果没找到，就将3存放进来，然后将a指向3。
接着处理intb=3；在创建完b的引用变量后，因为在栈中已经有3这个值，便将b直接指向3。
这样，就出现了a与b同时均指向3的情况。
这时，如果再令a=4；那么编译器会重新搜索栈中是否有4值，如果没有，则将4存放进来，并令a指向4；如果已经有了，则直接将a指向这个地址。
因此a值的改变不会影响到b的值。
要注意这种数据的共享与两个对象的引用同时指向一个对象的这种共享是不同的，因为这种情况a的修改并不会影响到b,它是由编译器完成的，它有利于节省空间。
而一个对象引用变量修改了这个对象的内部状态，会影响到另一个对象引用变量。
String是一个特殊的包装类数据。
可以用：
Stringstr=newString（"abc"）;Stringstr="abc";两种的形式来创建，第一种是用new（）来新建对象的，它会在存放于堆中。
每调用一次就会创建一个新的对象。
而第二种是先在栈中创建一个对String类的对象引用变量str，然后通过符号引用去字符串常量池里找有没有"abc",如果没有，则将"abc"存放进字符串常量池，并令str指向”abc”，如果已经有”abc”则直接令str指向“abc”。
比较类里面的数值是否相等时，用equals（）方法；当测试两个包装类的引用是否指向同一个对象时，用==，下面用例子说明上面的理论。
Stringstr1="abc";
Stringstr2="abc";
System.out.println（str1==str2）;//true
可以看出str1和str2是指向同一个对象的。
Stringstr1=newString（"abc"）;
Stringstr2=newString（"abc"）;
System.out.println（str1==str2）;//false
用new的方式是生成不同的对象。
每一次生成一个。
因此用第二种方式创建多个”abc”字符串,在内存中其实只存在一个对象而已.这种写法有利与节省内存空间.同时它可以在一定程度上提高程序的运行速度，因为JVM会自动根据栈中数据的实际情况来决定是否有必要创建新对象。
而对于Stringstr=newString（"abc"）；的代码，则一概在堆中创建新对象，而不管其字符串值是否相等，是否有必要创建新对象，从而加重了程序的负担。
另一方面,要注意:
我们在使用诸如Stringstr="abc"；的格式定义类时，总是想当然地认为，创建了String类的对象str。
担心陷阱！
对象可能并没有被创建！
而可能只是指向一个先前已经创建的对象。
只有通过new（）方法才能保证每次都创建一个新的对象。
由于String类的immutable性质，当String变量需要经常变换其值时，应该考虑使用StringBuffer类，以提高程序效率。
1.首先String不属于8种基本数据类型，String是一个对象。
因为对象的默认值是null，所以String的默认值也是null；但它又是一种特殊的对象，有其它对象没有的一些特性。
2.newString（）和newString（”"）都是申明一个新的空字符串，是空串不是null；
3.Stringstr=”kvill”；Stringstr=newString（”kvill”）的区别
示例：
Strings0="kvill";
Strings1="kvill";
Strings2="kv"+"ill";
System.out.println（s0==s1）;
System.out.println（s0==s2）;
结果为：
truetrue
首先，我们要知结果为道JAVA会确保一个字符串常量只有一个拷贝。
因为例子中的s0和s1中的”kvill”都是字符串常量，它们在编译期就被确定了，所以s0==s1为true；而"kv”和"ill”也都是字符串常量，当一个字符串由多个字符串常量连接而成时，它自己肯定也是字符串常量，所以s2也同样在编译期就被解析为一个字符串常量，所以s2也是常量池中”kvill”的一个引用。
所以我们得出s0==s1==s2；用newString（）创建的字符串不是常量，不能在编译期就确定，所以newString（）创建的字符串不放入常量池中，它们有自己的地址空间。
示例：
Strings0="kvill";
Strings1=newString（"kvill"）;
Strings2="kv"+newString（"ill"）;
System.out.println（s0==s1）;
System.out.println（s0==s2）;
System.out.println（s1==s2）;
结果为：
falsefalsefalse
例2中s0还是常量池中"kvill”的应用，s1因为无法在编译期确定，所以是运行时创建的新对象”kvill”的引用，s2因为有后半部分newString（”ill”）所以也无法在编译期确定，所以也是一个新创建对象”kvill”的应用;明白了这些也就知道为何得出此结果了。
4.String.intern（）：
再补充介绍一点：
存在于.class文件中的常量池，在运行期被JVM装载，并且可以扩充。
String的intern（）方法就是扩充常量池的一个方法；当一个String实例str调用intern（）方法时，Java查找常量池中是否有相同Unicode的字符串常量，如果有，则返回其的引用，如果没有，则在常量池中增加一个Unicode等于str的字符串并返回它的引用；看示例就清楚了
示例：
Strings0="kvill";
Strings1=newString（"kvill"）;
Strings2=newString（"kvill"）;
System.out.println（s0==s1）;
System.out.println（"**********"）;
s1.intern（）;
s2=s2.intern（）;//把常量池中"kvill"的引用赋给s2
System.out.println（s0==s1）;
System.out.println（s0==s1.intern（））;
System.out.println（s0==s2）;
结果为：
falsefalse//虽然执行了s1.intern（）,但它的返回值没有赋给s1true//说明s1.intern（）返回的是常量池中"kvill"的引用true
最后我再破除一个错误的理解：
有人说，“使用String.intern（）方法则可以将一个String类的保存到一个全局String表中，如果具有相同值的Unicode字符串已经在这个表中，那么该方法返回表中已有字符串的地址，如果在表中没有相同值的字符串，则将自己的地址注册到表中”如果我把他说的这个全局的String表理解为常量池的话，他的最后一句话，”如果在表中没有相同值的字符串，则将自己的地址注册到表中”是错的：
示例：
Strings1=newString（"kvill"）;
Strings2=s1.intern（）;
System.out.println（s1==s1.intern（））;
System.out.println（s1+""+s2）;
System.out.println（s2==s1.intern（））;
结果：
falsekvillkvilltrue
在这个类中我们没有声名一个”kvill”常量，所以常量池中一开始是没有”kvill”的，当我们调用s1.intern（）后就在常量池中新添加了一个”kvill”常量，原来的不在常量池中的”kvill”仍然存在，也就不是“将自己的地址注册到常量池中”了。
s1==s1.intern（）为false说明原来的”kvill”仍然存在；s2现在为常量池中”kvill”的地址，所以有s2==s1.intern（）为true。
5.关于equals（）和==:
这个对于String简单来说就是比较两字符串的Unicode序列是否相当，如果相等返回true;而==是比较两字符串的地址是否相同，也就是是否是同一个字符串的引用。
6.关于String是不可变的
这一说又要说很多，大家只要知道String的实例一旦生成就不会再改变了，比如说：
Stringstr=”kv”+”ill”+”“+”ans”;就是有4个字符串常量，首先”kv”和”ill”生成了”kvill”存在内存中，然后”kvill”又和””生成“kvill“存在内存中，最后又和生成了”kvillans”;并把这个字符串的地址赋给了str,就是因为String的”不可变”产生了很多临时变量，这也就是为什么建议用StringBuffer的原因了，因为StringBuffer是可改变的。
下面是一些String相关的常见问题：
String中的final用法和理解
finalStringBuffera=newStringBuffer（"111"）;
finalStringBufferb=newStringBuffer（"222"）;
a=b;//此句编译不通过finalStringBuffera=newStringBuffer（"111"）;
a.append（"222"）;//编译通过
可见，final只对引用的"值"（即内存地址）有效，它迫使引用只能指向初始指向的那个对象，改变它的指向会导致编译期错误。
至于它所指向的对象的变化，final是不负责的。
String常量池问题的几个例子
下面是几个常见例子的比较分析和理解：
Stringa="a1";
Stringb="a"+1;
System.out.println（（a==b））;//result=true
Stringa="atrue";
Stringb="a"+"true";
System.out.println（（a==b））;//result=true
Stringa="a3.4";
Stringb="a"+3.4;
System.out.println（（a==b））;//result=true
分析：
JVM对于字符串常量的"+"号连接，将程序编译期，JVM就将常量字符串的"+"连接优化为连接后的值，拿"a"+1来说，经编译器优化后在class中就已经是a1。
在编译期其字符串常量的值就确定下来，故上面程序最终的结果都为true。
Stringa="ab";
Stringbb="b";
Stringb="a"+bb;
System.out.println（（a==b））;//result=false
分析：
JVM对于字符串引用，由于在字符串的"+"连接中，有字符串引用存在，而引用的值在程序编译期是无法确定的，即"a"+bb无法被编译器优化，只有在程序运行期来动态分配并将连接后的新地址赋给b。
所以上面程序的结果也就为false。
St
升级会员 