1.
简述逻辑操作
(&,|,^)
与条件操作
(&&,||)
的区别。
(15
分
)
2.
下面程序运行会发生什么结果
?
如果有错误，如何改正
? (15
分
)
interfaceA{
int x = 0;
}
class B{
int x =1;
}
class C
extends B implements A {
public void pX(){
System.out.println(x);
}
public static void main(String[] args) {
new C().pX();
}
}
}
3.
简述
Java Server Page
和
Servlet
的联系和区别。
(20
分
)
4.XML
文档定义有几种形式？它们之间有何本质区别？
解析
XML
文档有哪几种方式？
(20
分
)
5.
简述
synchronized
和
java.util.concurrent.locks.Lock
的异同？
(15
分
)
6.EJB
规范规定
EJB
中禁止的操作有哪些？
(15
分
)
7.
最后还有一题考考你的眼力
:
public String toString(){
return this + "@" + this.hashCode();
}
这个
toString()
方法实现有无不当的地方
?(toString
方法其实可以按你想输出的任何内容输出一些该类的信息
)
答案：
1.
简述逻辑操作
(&,|,^)
与条件操作
(&&,||)
的区别。
(15
分
)
区别主要答两点
:
a.
条件操作只能操作布尔型的，而逻辑操作不仅可以操作布尔型
,
而且可以操作数值型
b.
逻辑操作不会产生短路
.
如
:
int a = 0;
int b = 0;
if( (a = 3) > 0 || (b = 3) > 0 ) //
操后
a =3,b=0.
if( (a = 3) > 0 | (b = 3) > 0 ) //
操后
a =3,b=3.
答对第一点得
5
分，答对第二点得
10
分
.
本题考察最最基本的知识
,
但仍然有很多大牛级开发人员下马，任何语言在开始的部分
都会详细介绍这些基本知识，但除了学习第一种语言时，没有人在学习新的语言时愿意
花五分钟来复习一下
.
2.
下面程序运行会发生什么结果
?
如果有错误，如何改正
? (15
分
)
interfaceA{
int x = 0;
}
class B{
int x =1;
}
class C
extends B implements A {
public void pX(){
System.out.println(x);
}
public static void main(String[] args) {
new C().pX();
}
}
}
本题在编译时会发生错误
(
错误描述不同的
JVM
有不同的信息，意思就是未明确的
x
调用，
两个
x
都匹配，就象在同时
import java.util
和
java.sql
两个包时直接声明
Date
一样
)
本题主要考察对接口和类的最最基本的结构的了解
.
对于父类的变量，可以用
super.x
来
明确，而接口的属性默认隐含为
public static final.
所以可以通过
A.x
来明确
.
3.
简述
Java Server Page
和
Servlet
的联系和区别。
(20
分
)
本题不用多说，在答相同点时应该明确知道
jsp
编译后是
"
类
servlet"
而
"
不是
Servlet"
，
答区别时应该回答出
"
侧重于
(
视图
/
控制逻辑
)".
其它可根据情况加减分值
.
知识很简单，
但从面试的角度看，被试者不仅要能知道它们的区别，而且要能比较准确地表达出来
(
以
后写文档要能让别人看得懂，不产生歧义
)
，回答
"jsp
编译后就是
servlet"
视为错误，回答
"jsp
用于视图，
servlet
用于控制逻辑
"
视为错误，应该用侧重于，主要
(
多数
)
用于等词语
表达
.
4.XML
文档定义有几种形式？它们之间有何本质区别？
解析
XML
文档有哪几种方式？
(20
分
)
本题三个答题点
:
a:
两种形式
dtd
，
schema
b:
本质区别
:schema
本身是
xml
的，可以被
XML
解析器解析
(
这也是从
DTD
上发展
schema
的
根本目的
)
c:
两种主要方式
:dom
，
sax.
答出两种得全分，如能答出
saxt
，或其它
(
在答出
dom
，
sax
的基
础上，如果应试者认为其它方式也可以视为对
xml
的解析应该允许
.
但没有答出
dom
，
sax
把
其它方式说成是对
XML
的解析不得分
)
应该加分
.
5.
简述
synchronized
和
java.util.concurrent.locks.Lock
的异同？
(15
分
)
主要相同点
:
Lock
能完成
synchronized
所实现的所有功能
.(
其它不重要
)
主要不同点
:
Lock
有比
synchronized
更精确的线程语义和更好的性能
(
在相同点中回答此点也行
)
synchronized
会自动释放锁
.
而
Lock
一定要求程序员手工释放
.
并且必须在
finally
从句
中释放，如果没有答出在
finally
中释放不得分
.
就如
Connection
没有在
finally
中关闭一
样
.
连最基本的资源释放都做不好，还谈什么多线程编程
.
6.EJB
规范规定
EJB
中禁止的操作有哪些？
(15
分
)
共有
8
点，答出下列
3-4
点得满分
.
·
不能操作线程和线程
API(
线程
API
指非线程对象的方法如
notify
，
wait
等
)
·
不能操作
awt
·
不能实现服务器功能
·
不能对静态属生存取
.
·
不能使用
IO
操作直接存取文件系统
·
不能加载本地库
.
·
不能将
this
作为变量和返回
.
·
不能循环调用
.
7
public String toString(){
return this + "@" + this.hashCode();
}
会变成
public String toString(){
return String.valueOf(this) + "@" + String.valueOf(this.hashCode());
}
而
valueOf
方法又将去调用
toString();
/**
public static String valueOf(Object obj) {
return (obj == null) ? "null" : obj.toString();
}
*/
这样好像会有问题
原文地址：
Java
本身没有这个能力，不过利用操作系统的命令可以做到。
public static String getMACAddress() {
String address = "";
String os = System.getProperty("os.name");
if ( os != null && os.startsWith("Windows")) {
try {
String command = "cmd.exe /c ipconfig /all";
Process p = Runtime.getRuntime().exec(command);
BufferedReader br =
new BufferedReader(
new InputStreamReader(p.getInputStream()));
String line;
while ((line = br.readLine()) != null) {
if (line.indexOf("Physical Address") > 0) {
int index = line.indexOf(":");
index += 2;
address = line.substring(index);
break;
}
}
br.close();
return address.trim();
}
catch (IOException e) { }
}
return address;
}
原文地址：
equals
方法的重要性毋须多言，只要你想比较的两个对象不愿是同一对象，你就应该实现
equals
方法，让对象用你认为相等的条件来进行比较
.
下面的内容只是
API
的规范，没有什么太高深的意义，但我之所以最先把它列在这儿，是因为
这些规范在事实中并不是真正能保证得到实现
.
1.
对于任何引用类型，
o.equals(o) == true
成立
.
2.
如果
o.equals(o1) == true
成立，那么
o1.equals(o)==true
也一定要成立
.
3.
如果
o.equals(o1) == true
成立且
o.equals(o2) == true
成立，那么
o1.equals(o2) == true
也成立
.
4.
如果第一次调用
o.equals(o1) == true
成立再
o
和
o1
没有改变的情况下以后的任何次调用
都成立
.
5.o.equals(null) == true
任何时间都不成立
.
以上几条规则并不是最完整的表述，详细的请参见
API
文档
.
对于
Object
类，它提供了一个最最严密的实现，那就是只有是同一对象是，
equals
方法才返回
true
，也就是人们常说的引用比较而不是值比较
.
这个实现严密得已经没有什么实际的意义，所以在具体子类
(
相对于
Object
来说
)
中，如果我们要进行对象的值比较，就必须实现自己的
equals
方法
.
先来看一下以下这段程序
:
public boolean equals(Object obj)
{
if (obj == null) return false;
if (!(obj instanceof FieldPosition))
return false;
FieldPosition other = (FieldPosition) obj;
if (attribute == null) {
if (other.attribute != null) {
return false;
}
}
else if (!attribute.equals(other.attribute)) {
return false;
}
return (beginIndex == other.beginIndex
&& endIndex == other.endIndex
&& field == other.field);
}
这是
JDK
中
java.text.FieldPosition
的标准实现，似乎没有什么可说的
.
我信相大多数或绝大多数程序员认为，这是正确的合法的
equals
实现
.
毕竟它是
JDK
的
API
实现啊
.
还是让我们以事实来说话吧
:
package debug;
import java.text.*;
public class Test {
public static void main(String[] args) {
FieldPosition fp = new FieldPosition(10);
FieldPosition fp1 = new MyTest(10);
System.out.println(fp.equals(fp1));
System.out.println(fp1.equals(fp));
}
}
class MyTest extends FieldPosition{
int x = 10;
public MyTest(int x){
super(x);
this.x = x;
}
public boolean equals(Object o){
if(o==null) return false;
if(!(o instanceof MyTest )) return false;
return ((MyTest)o).x == this.x;
}
}
运行一下看看会打印出什么
:
System.out.println(fp.equals(fp1));
打印
true
System.out.println(fp1.equals(fp));
打印
flase
两个对象，出现了不对称的
equals
算法
.
问题出在哪里
(
脑筋急转弯：当然出在
JDK
实现的
BUG)?
我相信有太多的程序员
(
除了那些根本不知道实现
equals
方法的程序员外
)
在实现
equals
方法
时都用过
instanceof
运行符来进行短路优化的，实事求是地说很长一段时间我也这么用过。
太多的教程，文档都给了我们这样的误导。而有些稍有了解的程序员可能知道这样的优化可能
有些不对但找不出问题的关键。另外一种极端是知道这个技术缺陷的骨灰级专家就提议不要这
样应用。
我们知道，
"
通常
"
要对两个对象进行比较，那么它们
"
应该
"
是同一类型。所以首先利用
instanceof
运行符进行短路优化，如果被比较的对象不和当前对象是同一类型则不用比较返回
false
，但事实
上，
"
子类是父类的一个实例
"
，所以如果子类
o instanceof
父类，始终返回
true
，这时肯定
不会发生短路优化，下面的比较有可能出现多种情况，一种是不能造型父类而抛出异常，另一种
是父类的
private
成员没有被子类继承而不能进行比较，还有就是形成上面这种不对称比较。可能
会出现太多的情况。
那么，是不是就不能用
instanceof
运行符来进行优化？答案是否定的，
JDK
中仍然有很多实现是正
确的，如果一个
class
是
final
的，明知它不可能有子类，为什么不用
instanceof
来优化呢？
为了维护
SUN
的开发小组的声誉，我不说明哪个类中，但有一个小组成员在用这个方法优化时在后加
mar
分享到：
发表评论
评论