正确答案: A 你的答案: B (错误)
类可以实现多个接口，接口可以继承（或扩展）多个接口
类可以实现多个接口，接口不能继承（或扩展）多个接口
类和接口都可以实现多个接口
类和接口都不可以实现多个接口
1.类与类之间的关系为继承，只能单继承，但可以多层继承。 2.类与接口之间的关系为实现，既可以单实现，也可以多实现。 3.接口与接口之间的关系为继承，既可以单继承，也可以多继承。 故为A
下列说法错误的有（ ）
正确答案: A B C D 你的答案: A D (错误)
Java面向对象语言容许单独的过程与函数存在
Java面向对象语言容许单独的方法存在
Java语言中的非静态方法属于类中的成员（member）
Java语言中的方法必定隶属于某一类（对象），调用方法与过程或函数相同
Java的静态方法属于类的成员，实例方法属于对象的成员。
java不允许单独的方法，过程或函数存在,需要隶属于某一类中。
ArrayList和LinkList的描述，下面说法错误的是？
正确答案: D 你的答案: B (错误)
LinkedeList和ArrayList都实现了List接口
ArrayList是可改变大小的数组，而LinkedList是双向链接串列
LinkedList不支持高效的随机元素访问
在LinkedList的中间插入或删除一个元素意味着这个列表中剩余的元素都会被移动；而在ArrayList的中间插入或删除一个元素的开销是固定的
这个说法说反了
Arraylist的内存结构是数组，当超出数组大小时创建一个新的数组，吧原数组中元素拷贝过去。其本质是顺序存储的线性表，插入和删除操作会引发后续元素移动，效率低，但是随机访问效率高
LinkedList的内存结构是用双向链表存储的，链式存储结构插入和删除效率高，不需要移动。但是随机访问效率低，需要从头开始向后依次访问
下面选项中,哪些是interface中合法方法定义?()
正确答案: A C D 你的答案: C D (错误)
public void main(String [] args);
private int getSum();
boolean setFlag(Boolean [] test);
public float get(int x);
A：只是方法名称和参数名称取的比较特殊，java中正确的main方法定义是 public static void main(String[] args){ }
Servlet的生命周期可以分为初始化阶段，运行阶段和销毁阶段三个阶段，以下过程属于初始化阶段是（）。
正确答案: A C D 你的答案: C D (错误)
加载Servlet类及.class对应的数据
创建serletRequest和servletResponse对象
创建ServletConfig对象
创建Servlet对象
Servlet的生命周期一般可以用三个方法来表示：
init()：仅执行一次，负责在装载Servlet时初始化Servlet对象
service() ：核心方法，一般HttpServlet中会有get,post两种处理方式。在调用doGet和doPost方法时会构造servletRequest和servletResponse请求和响应对象作为参数。
destory()：在停止并且卸载Servlet时执行，负责释放资源
初始化阶段：Servlet启动，会读取配置文件中的信息，构造指定的Servlet对象，创建ServletConfig对象，将ServletConfig作为参数来调用init()方法。所以选ACD。B是在调用service方法时才构造的
以下关于final关键字说法错误的是
正确答案: A C 你的答案: B C D (错误)
final是java中的修饰符，可以修饰类、接口、抽象类、方法和属性
final修饰的类肯定不能被继承
final修饰的方法不能被重载
final修饰的变量不允许被再次赋值
final修饰的方法不能被重写而不是重载！
final不能修饰抽象类
下面有关maven和ant的描述，描述错误的是？
正确答案: C 你的答案: 空 (错误)
Ant 没有正式的约定如一个一般项目的目录结构，你必须明确的告诉 Ant 哪里去找源代码
Maven 拥有约定，因为你遵循了约定，它已经知道你的源代码在哪里
maven和ant都有“生命周期”的概念，当你输入一个命令后，maven或者ant会执行一系列的有序的步骤，直到到达你指定的生命周期
Ant构建文件默认命名为build.xml，Maven默认构建文件为pom.xml
Ant和Maven都是基于Java的构建(build)工具。理论上来说，有些类似于（Unix）C中的make ，但没有make的缺陷。Ant是软件构建工具，Maven的定位是软件项目管理和理解工具。
Ant特点
没有一个约定的目录结构 必须明确让ant做什么，什么时候做，然后编译，打包 没有生命周期，必须定义目标及其实现的任务序列 没有集成依赖管理
Maven特点
拥有约定，知道你的代码在哪里，放到哪里去 拥有一个生命周期，例如执行 mvn install 就可以自动执行编译，测试，打包等构建过程 只需要定义一个pom.xml,然后把源码放到默认的目录，Maven帮你处理其他事情 拥有依赖管理，仓库管理
以下哪个式子有可能在某个进制下成立（）？
正确答案: A 你的答案: 空 (错误)
13*14=204
12*34=568
14*14=140
1+1=3
（3+x）*(4+x)=2x^2+4
检查程序，是否存在问题，如果存在指出问题所在，如果不存在，说明输出结果。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
|
public
class
HelloB
extends
HelloA
{
public
HelloB()
{
}
{
System.out.println(
"I’m B class"
);
}
static
{
System.out.println(
"static B"
);
}
public
static
void
main(String[] args)
{
new
HelloB();
}
}
class
HelloA
{
public
HelloA()
{
}
{
System.out.println(
"I’m A class"
);
}
static
{
System.out.println(
"static A"
);
}
}
|
正确答案: C 你的答案: 空 (错误)
static A I’m A class static B I’m B class
I’m A class I’m B class static A static B
static A static B I’m A class I’m B class
I’m A class static A I’m B class static B
1.静态初始化块
2普通初始化块
3构造器
正确答案: A 你的答案: B (错误)
进程对管道进行读操作和写操作都可能被阻塞
一个管道只能有一个进程或一个写进程对其操作
一个管道可实现双向数据传输
管道的容量仅受磁盘容量大小限制
B.可以有多个进程对其读；也可以有多个进程写， 只不过不能同时写 。并且题目没有说“同时”，B不对
C. 匿名管道只能单向；命名管道可以双向 ；所以C过于绝对
D. 管道是内存中的 ，所以D不对
正确答案: A 你的答案: B (错误)
正确
错误
{
Object obj = new Object();
synchronized(Thread.currentThread())
{
obj.wait();
obj.notify();
}
}
Which statement is true?
正确答案: A 你的答案: A (正确)
This code may throw an InterruptedException
This code may throw an IllegalStateException
This code may throw a TimeOutException after ten minutes
This code will not compile unless”obj.wait()”is replaced with”(Thread)obj).wait()”
Reversing the order of obj.wait()and obj.notify()may cause this method to complete normally
因此答案就是因为缺少例外捕捉的 InterruptedException
第二个错误的地方是， synchronized 的目标与 wait() 方法的物件不相同，会有 IllegalMonitorStateException ，不过 InterruptedException 会先出现，所以这不是答案
最后正确的程式码应该是这样：
void waitForSignal() {
Object obj = new Object();
synchronized (obj) {
try {
obj.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
obj.notify();
}
}
正确答案: A B 你的答案: C (错误)
<filter>
<filter-mapping>
<servlet-filter>
<filter-config>
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
package algorithms.com.guan.javajicu;
public class Inc {
public static void main(String[] args) {
Inc inc =
new
Inc();
int i = 0;
inc.fermin(i);
i= i ++;
System.out.println(i);
}
void fermin(int i){
i++;
}
}
|
0
1
2
3
i= i ++;
容器panel缺省使用的布局编辑策略是( )
正确答案: B 你的答案: C (错误)
Border Layout
Flow Layout
GridLayout
Card Layout
FlowLayout的布局管理器
下面叙述那个是正确的？（）
正确答案: B 你的答案: C (错误)
java中的集合类（如Vector）可以用来存储任何类型的对象，且大小可以自动调整。但需要事先知道所存储对象的类型，才能正常使用。
在java中，我们可以用违例（Exception）来抛出一些并非错误的消息，但这样比直接从函数返回一个结果要更大的系统开销。
java接口包含函数声明和变量声明。
java中，子类不可以访问父类的私有成员和受保护的成员。
A.vector是线程安全的ArrayList，在内存中占用连续的空间。初始时有一个初始大小，当数据条数大于这个初始大小后会重写分配一个更大的连续空间。如果Vector定义为保存Object则可以存放任意类型。
B.try{}catch{}会增加额外的开销
C.接口中声明的'变量'必须为public final static,所以为常量
D.子类可以访问父类受保护的成员
What will happen when you attempt to compile and run the following code?
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
public
class
Test{
static
{
int
x=
5
;
}
static
int
x,y;
public
static
void
main(String args[]){
x--;
myMethod( );
System.out.println(x+y+ ++x);
}
public
static
void
myMethod( ){
y=x++ + ++x;
}
}
|
compiletime error
prints:1
prints:2
prints:3
prints:7
prints:8
- 执行x--后 x=-1
- 调用myMethod方法，x执行x++结果为-1(后++)，但x=0，++x结果1，x=1 ，则y=0
- x+y+ ++x,先执行x+y，结果为1，执行++x结果为2，得到最终结果为3
正确答案: B 你的答案: D (错误)
final类的方法肯定不能被同一个包的类访问
final类的方法能否被同一个包的类访问不是由final决定
final方法等同于private方法
final对象本身的引用和值都不能改变
final变量，如果是基本数据类型，则其数值一旦初始化后就不能被改变。如果是引用类型的变量，则对其初始化后，便不能再指向另一个对象，但是其里面的值是可以改变的。引用变量所指向的对象中的内容是可以改变的。
有关下述Java代码描述正确的选项是____。
|
1
2
3
4
5
6
7
8
|
public
class
TestClass {
private
static
void
testMethod(){
System.out.println(
"testMethod"
);
}
public
static
void
main(String[] args) {
((TestClass)
null
).testMethod();
}
}
|
编译不通过
编译通过，运行异常，报NullPointerException
编译通过，运行异常，报IllegalArgumentException
编译通过，运行异常，报NoSuchMethodException
编译通过，运行异常，报Exception
运行正常，输出testMethod
1）此处是类对方法的调用，不是对象对方法的调用。
2）方法是static静态方法，直接使用"类.方法"即可，因为静态方法使用不依赖对象是否被创建。
null可以被强制类型转换成任意类型（不是任意类型对象），于是可以通过它来执行静态方法。
3）非静态的方法用"对象.方法"的方式，必须依赖对象被创建后才能使用，若将testMethod()方法前的static去掉，则会报 空指针异常 。此处也验证了2）的观点
当然，不管是否静态方法，都是已经存在的，只是访问方式不同。
如何获取ServletContext设置的参数值？
正确答案: B 你的答案: A (错误)
context.getParameter()
context.getInitParameter()
context.getAttribute()
context.getRequestDispatcher()
getParameter()是获取POST/GET传递的参数值；
getInitParameter获取Tomcat的server.xml中设置Context的初始化参数
getAttribute()是获取对象容器中的数据值；
getRequestDispatcher是请求转发。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
|
public
class
NameList
{
private
List names =
new
ArrayList();
public
synchronized
void
add(String name)
{
names.add(name);
}
public
synchronized
void
printAll() {
for
(
int
i =
0
; i < names.size(); i++)
{
System.out.print(names.get(i) + ””);
}
}
public
static
void
main(String[]args)
{
final
NameList sl =
new
NameList();
for
(
int
i =
0
; i <
2
; i++)
{
new
Thread()
{
public
void
run()
{
sl.add(“A”);
sl.add(“B”);
sl.add(“C”);
sl.printAll();
}
} .start();
}
}
}
|
正确答案: E G 你的答案: 空 (错误)
An exception may be thrown at runtime.
The code may run with no output, without exiting.
The code may run with no output, exiting normally(正常地).
The code may rum with output “A B A B C C “, then exit.
The code may rum with output “A B C A B C A B C “, then exit.
The code may ruin with output “A A A B C A B C C “, then exit.
The code may ruin with output “A B C A A B C A B C “, then exit.
在每个线程中都是顺序执行的，所以sl.printAll();必须在前三句执行之后执行，也就是输出的内容必有（连续或非连续的）ABC。
而线程之间是穿插执行的，所以一个线程执行 sl.printAll();之前可能有另一个线程执行了前三句的前几句。
E答案相当于线程1顺序执行完然后线程2顺序执行完。
G答案则是线程1执行完前三句add之后线程2插一脚执行了一句add然后线程1再执行 sl.printAll();输出ABCA。接着线程2顺序执行完输出ABCABC
输出加起来即为ABCAABCABC。