（2.1）代码
（2.1.1）调用顺序类
以下代码的输出结果是？
问这个程序的输出结果。
个人理解，类分为——编译、加载、链接、初始化、实例化
What is the result?
1，字符串在java中存储在字符串常量区中
2，==判断的是对象引用是否是同一个引用，判断字符串相等要用equals方法
首先判断a==MESSAGE ,由于常量池的优化策略，a为编译时连接，同一份字符串常量在内存中只有一份，因此是同一地址，返回true
以下程序的输出结果是？
false
下面为true的是
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
public
class
B
{
public
static
B t1 =
new
B();
public
static
B t2 =
new
B();
{
System.out.println(
"构造块"
);
}
static
{
System.out.println(
"静态块"
);
}
public
static
void
main(String[] args)
{
B t =
new
B();
}
}
|
- 静态块 构造块 构造块 构造块
- 构造块 静态块 构造块 构造块
- 构造块 构造块 静态块 构造块
- 构造块 构造块 构造块 静态块
静态块：用static申明，JVM加载类时执行，仅执行一次
构造块：类中直接用{}定义，每一次创建对象时执行
执行顺序优先级：静态块>main()>构造块>构造方法
静态块按照申明顺序执行，所以先执行publicstaticB t1 = newB();该语句创建对象，则又会调用构造块，输出构造块
接着执行public
static
B t1 = new
B();输出构造块
再执行
static
{
System.out.println("静态块");
}输出静态块
最后main方法执行，创建对象，输出构造块。
|
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"
);
}
}
|
- 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
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
|
class
B
extends
Object
{
static
{
System.out.println(
"Load B"
);
}
public
B()
{
System.out.println(
"Create B"
);
}
}
class
A
extends
B
{
static
{
System.out.println(
"Load A"
);
}
public
A()
{
System.out.println(
"Create A"
);
}
}
public
class
Testclass
{
public
static
void
main(String[] args)
{
new
A();
}
}
|
- Load B ->Create B->Load A -> Create A
- Load B -> Load A ->Create B ->Create A
- Load B -> Create B-> Create A -> Load A
- Create B ->Create A ->Load B ->Load A
（2.1.2）重载覆盖类
下面代码的输出是什么？
|
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
|
public
class
Base
{
private
String baseName =
"base"
;
public
Base()
{
callName();
}
public
void
callName()
{
System. out. println(baseName);
}
static
class
Sub
extends
Base
{
private
String baseName =
"sub"
;
public
void
callName()
{
System. out. println (baseName) ;
}
}
public
static
void
main(String[] args)
{
Base b =
new
Sub();
}
}
|
- null
- sub
- base
new Sub();在创造派生类的过程中首先创建基类对象，然后才能创建派生类。
创建基类即默认调用Base()方法，在方法中调用callName()方法，由于派生类中存在此方法，则被调用的callName（）方法是派生类中的方法，此时派生类还未构造，所以变量baseName的值为null
|
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
|
package
Wangyi;
class
Base
{
public
void
method()
{
System.out.println(
"Base"
);
}
}
class
Son
extends
Base
{
public
void
method()
{
System.out.println(
"Son"
);
}
public
void
methodB()
{
System.out.println(
"SonB"
);
}
}
public
class
Test01
{
public
static
void
main(String[] args)
{
Base base =
new
Son();
base.method();
base.methodB();
}
}
|
- Base SonB
- Son SonB
- Base Son SonB
- 编译不通过
这句new 了一个派生类，赋值给基类，所以下面的操作编译器认为base对象就是Base类型的
Base类中不存在methodB()方法，所以编译不通过
class StaticBlock {
static final int c = 3;
static final int d;
static int e = 5;
static {
d = 5;
e = 10;
System.out.println("Initializing");
}
StaticBlock() {
System.out.println("Building");
}
}
public class StaticBlockTest {
public static void main(String[] args) {
System.out.println(StaticBlock.c);
System.out.println(StaticBlock.d);
System.out.println(StaticBlock.e);
}
}
执行一下，结果为：
3
Initializing
5
10
初始化完成 static引入
实例化完成构造函数调用
编译时常量必须满足3个条件：static的，final的，常量。 不会引起初始化
调用类的静态方法，会引起初始化
http://blog.csdn.net/fei20121106/article/details/44450193
（2.1.3）类型比较、转换和函数传值类
以下代码将打印出
|
1
2
3
4
5
6
7
8
|
public
static
void
main(String[] args)
{
Listlist1 =
new
ArrayList();
list1.add(O);
Listlist2 = list1;
System.out.println(list1.get(O)
instanceof
Integer);
System.out.println(list2.get(O)
instanceof
Integer);
}
|
- 编译错误
- true true
- true false
- false false
0被自动装箱为integer
Which lines of the following will produce an error?
|
1
2
3
4
|
1
.
byte
a1 =
2
, a2 =
4
, a3;
2
.
short
s =
16
;
3
. a2 = s;
4
. a3 = a1 * a2;
|
- Line 3 and Line 4
- Line 1 only
- Line 3 only
- Line 4 only
byte+byte=int，低级向高级是隐式类型转换，高级向低级必须强制类型转换，byte<char<short<int<long<float<double
下列 java 程序输出结果为______。
|
1
2
3
4
|
int
i=
0
;
Integer j =
new
Integer(
0
);
System.out.println(i==j);
System.out.println(j.equals(i));
|
- true,false
- true,true
- false,true
- false,false
- 对于不同的环境结果不同
- 程序无法执行
基本类型的== 比较内容值 equale（）先比较格式、再比较内容
包装类和类类型的 == 比较对象地值 equale()比较内容
i==j 涉及基本类型 自动拆包为 基本类型比较 比较值
j.equals(i) 自动装包 包装类的equale 比较格式和内容 也是相等
iven:
|
1
2
3
4
5
6
7
8
9
10
|
public
class
IfTest{
public
static
void
main(string[]args){
int
x=
3
;
int
y=
1
;
if
(x=y)
system.out.println(“Not equal”);
else
system.out.println(“Equal”);
}
}
|
- The output is “Equal”
- The output in “Not Equal”
- An error at line 5 causes compilation to fall.
- The program executes but does not print a message.
我来解析下：
其实这个是由于java和C语言的不同处理机制导致的：
C语言中
当if语句中的条件为赋值语句时，实际上是将赋值后的结果与0进行比较【左值】
if（1） 由于1>0 所以认为是true
java语言中，虽然也用了左值，但是不再与0比较，而是直接将0放入if()中
但是int类型，不能转换为低级的boolean，所以会报错：“ Type mismatch: cannot convert from int to boolean
”
JVM规范指出boolean当做int处理,也就是4字节,boolean数组当做byte数组处理。
给出以下代码,请给出结果.
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
class
Two{
Byte x;
}
class
PassO{
public
static
void
main(String[] args){
PassO p=
new
PassO();
p.start();
}
void
start(){
Two t=
new
Two();
System.out.print(t.x+””);
Two t2=fix(t);
System.out.print(t.x+” ” +t2.x);
}
Two fix(Two tt){
tt.x=
42
;
return
tt;
}
}
|
- null null 42
- null 42 42
- 0 0 42
- 0 42 42
- An exception is thrown at runtime
- Compilation
基本类型作为对象成员会有默认值，但是封装类没有，为null
这里的Byte是byte的封装类，x就是一个对象，对象的话，怎么可能等于0嘛，相信大家还是可以理解的。
如果是byte的话，就会有默认初始值 0 。
像int , short 都会默认为0，但如果是Integer , Short的话，就会NULL ，因为是创建的对象嘛。
What results from the following code fragment?
|
1
2
3
|
int
i =
5
;
int
j =
10
;
System.out.println(i + ~j);
|
- Compilation error because”~”doesn’t operate on integers
- -5
- -6
- 15
10原码：0000000000000000,0000000000001010；
~10： 1111111111111111,1111111111110101 变为负数，计算机用补码存储
~10反码：10000000000000000,0000000000001010
~10补码：10000000000000000,0000000000001011，等于 -11
故程序结果-6
有如下一段代码，请选择其运行结果（）
|
1
2
3
4
5
6
7
8
9
10
|
public
class
StringDemo{
private
static
final
String MESSAGE=
"taobao"
;
public
static
void
main(String [] args) {
String a =
"tao"
+
"bao"
;
String b=
"tao"
;
String c=
"bao"
;
System.out.println(a==MESSAGE);
System.out.println((b+c)==MESSAGE);
}
}
|
- true true
- false false
- true false
- false true
-
2，==判断的是对象引用是否是同一个引用，判断字符串相等要用equals方法
首先判断a==MESSAGE ,由于常量池的优化策略，a为编译时连接，同一份字符串常量在内存中只有一份，因此是同一地址，返回true
再次比较(b+c)==MESSAGE 这相当于运行时创建， new String(b+c)==MESSAGE 这里new了一个String对象，所以返回false
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
public
class
Example {
String str =
new
String(
"good"
);
char
[] ch = {
'a'
,
'b'
,
'c'
};
public
static
void
main(String args[]) {
Example ex =
new
Example();
ex.change(ex.str, ex.ch);
System.out.print(ex.str +
" and "
);
System.out.print(ex.ch);
}
public
void
change(String str,
char
ch[])
{
str =
"test ok"
;
ch[0] =
'g'
;
}
}
|
- good and abc
- good and gbc
- test ok and abc
- test ok and gbc
考察值传递和引用传递...
given the following code,what will be the output?
|
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
|
class
Value{
public
int
i=
15
;
}
public
class
Test{
public
static
void
main(String argv[]){
Test t=
new
Test( );
t.first( );
}
public
void
first( ){
int
i=
5
;
Value v=
new
Value( );
v.i=
25
;
second(v,i);
System.out.println(v.i);
}
public
void
second(Value v,
int
i){
i =
0
;
v.i =
20
;
Value val =
new
Value( );
v = val;
System.out.println(v.i+
" "
+i);
}
}
|
- 15 0 20
- 15 0 15
- 20 0 20
- 0 15 20
v = val; 把v赋值 就相当于改变了v的指向 但是原先的V 的内容是不会改变的 和上面s1一样会改变
在jdk1.5的环境下，有如下4条语句：
|
1
2
3
4
|
Integer i01 =
59
;
int
i02 =
59
;
Integer i03 =Integer.valueOf(
59
);
Integer i04 =
new
Integer(
59
)。
|
以下输出结果为false的是：
- System.out.println(i01== i02);
- System.out.println(i01== i03);
- System.out.println(i03== i04);
- System.out.println(i02== i04);
第一点： 引用类的== 比的是对象地址是否一致 C错误
第二点：包装类的常量池复用原则 A B正确
JVM对除了浮点型之外的包装类都提供了类似于String这样的常量池机制（不过范围仅仅是-128到127之间）。Integer.valueOf(59)这个方法的结果和Integer i=59 的效果一样，都是在常量池里面。所以i04仅仅可以和放在栈里面的i01相等。其它的三个都可以相等---当然，要是超出了范围的话就不一定了。例如：Integer i=300; Integer j=300; 但是 i==j 是false
第三点：拆包原则 i04被拆包为基本类型 基本值类型的==比较的是值是否相等
以下Java程序运行的结构是:
|
1
2
3
4
5
6
7
8
9
10
11
12
|
public class Tester{
public static void main(String[] args){
Integer var1=
new
Integer(1);
Integer var2=var1;
doSomething(var2);
System.out.print(var1.intValue());
System.out.print(var1==var2);
}
public static void doSomething(Integer integer){
integer=
new
Integer(2);
}
}
|
- 1true
- 2true
- 1false
- 2false
基本类型作为形式参数传递不会改变实际参数，引用类型作为形式参数传递会改变实际参数
但是JDK1.5以后，对基本类型的包装类型（int-Integer,double-Double）提供了自动拆装箱的功能，把Integer类型作为参数传递，会自动拆箱为基本类型，不会改变实际参数的值
Consider the following code:
|
1
2
3
|
Integer s=
new
Integer(
9
);
Integer t=
new
Integer(
9
);
Long u=
new
Long(
9
);
|
Which test would return true?
- (s==u)
- (s==t)
- (s.equals(t))
- (s.equals(9))
- (s.equals(new Integer(9))
==默认比较的是对象或者变量所存储的地址，equals方法则可以则继承的类里重写，
基本类型包装类中的equals实际比较的是所存储的变量值，而对象直接用==则比较的是地址，D中涉及到了自动装箱
下面的输出结果是什么？
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
public
class
Demo {
public
static
void
main(String args[])
{
String str=
new
String(
"hello"
);
if
(str==
"hello"
)
{
System.out.println(
"true"
);
}
else
{
System.out.println(
"false"
);
}
}
}
|
==用来判断两个变量是否相等时，如果两个变量是基本类型变量，且都是数值类型(不要求数据类型严格相同)，则只要两个变量的值相等，就返回true；对于两个引用类型变量，必须指向同一个对象，==才会返回true。
java中使用new String("hello")时，jvm会先使用常量池来管理"hello"常量，再调用String类的构造器创建一个新的String对象，新创建的对象被保存在堆内存中；而直接使用"hello"的字符串直接量，jvm会用常量池来管理这些字符串。故上述程序中str=="hello"返回结果为false
|
1
2
3
|
Integer i =
42
;
Long l = 42l;
Double d =
42.0
;
|
- (i == l)
- (i == d)
- (l == d)
- i.equals(d)
- d.equals(l)
- i.equals(l)
- l.equals(42L)
A、B、C 用==比较的是对象的地址，返回false
JAVA当中所有的类都是继承于Object这个基类的，在Object中的基类中定义了一个equals的方法，这个方法的初始行为是比较对象的内存地 址，但在一些类库当中这个方法被覆盖掉了，如String,Integer,Date在这些类当中equals有其自身的实现，而不再是比较类在堆内存中的存放地址了。
基本类型的equals()会先判断类型，再判断值。
首先会判断d是否是Integer类型，如果否则返回false，如果是，则进一步判断i的intValue值是否等于d的intValue
根据下面的程序代码，哪些选项的值返回true？
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
public
class
Square {
long
width;
public
Square(
long
l) {
width = l;
}
public
static
void
main(String arg[]) {
Square a, b, c;
a =
new
Square(42L);
b =
new
Square(42L);
c = b;
long
s = 42L;
}
}
|
- a == b
- s == a
- b == c
- a.equals(s)
来看4个选项：
A: a == b
由图可以看出a和b指向的不是同一个引用，故A错
B：s == a
一个Square类型不能与一个long型比较，编译就错误，故B错
c：b == c
由图可以看出b和c指向的是同一个引用，故C正确
d：a equal s
程序会把s封装成一个Long类型，由于Square没有重写Object的equals方法， 所以
调用的是Object类的equals方法，还是比较对象地址
（2.1.4）其他类
以下代码将打印出
|
1
2
3
4
|
public
static
void
main (String[] args) {
String classFile =
"com. jd. "
. replaceA11(
"."
,
"/"
) +
"MyClass.class"
;
System.out.println(classFile);
}
|
- com. jd
- com/jd/MyClass.class
- ///MyClass.class
- com.jd.MyClass
由于replaceAll方法的第一个参数是一个正则表达式，而"."在正则表达式中表示任何字符，所以会把前面字符串的所有字符都替换成"/"。如果想替换的只是"."，那么久要写成"\\.".
已知表达式int m[]={0，1，2，3，4，5，6}；下面哪个表达式的值与数组下标量最大值相等？
- m. length()
- m. length-1
- m. length()+1
- m. length+1
数组有length变量，而不是length（）方法；
String中有length（）方法来获得字符串长度；
Given the following code:
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
1
.
public
class
Enclosingone
2
.{
3
.
public
class
InsideOne {}
4
.
5
.}
6
.
public
class
inertest
7
.{
8
.
public
static
void
main(string[]args)
9
. {
10
. EnclosingOne eo =
new
EnclosingOne();
11
.
//insert code here
12
. }
13
.
14
.}
|
Which statement at line 7 constructs an instance of the inner class?
- InsideOne ei=eo.new InsideOne();
- eo.InsideOne ei=eo.new InsideOne();
- InsideOne ei=EnclosingOne.new InsideOne();
- EnclosingOne.InsideOne ei=eo.new InsideOne();
说明输出结果。
|
1
2
3
4
5
6
7
8
9
10
11
12
|
package test;
import java.util.Date;
public class SuperTest extends Date{
private static final long serialVersionUID = 1L;
private void test(){
System.out.println(
super
.getClass().getName());
}
public static void main(String[]args){
newSuperTest().test();
}
}
|
- SuperTest
- SuperTest.class
- test.SuperTest
- test.SuperTest.class
TestSuper和Date的getClass都没有重写，他们都是调用Object的getClass，而Object的getClass作用是返回的是运行时的类的名字。这个运行时的类就是当前类
要返回Date类的名字需要写super.getClass().getSuperclass()
Which statement declares a variable a which is suitable for referring to an array of 50 string objects?
- char a[][];
- String a[];
- String[]a;
- Object a[50];
- String a[50];
- Object a[];
BCF
在java 中，声明一个数组时，不能直接限定数组长度，只有在创建实例化对象时，才能对给定数组长度.。
如下，1，2,3可以通过编译，4，5不行。而String是Object的子类，所以上述BCF均可定义一个存放50个String类型对象的数组。
1. String a[]=new String[50];
2. String b[];
3. char c[];
4. String d[50];
5. char e[50];
|
1
2
3
4
5
6
7
8
9
|
void
waitForSignal()
{
Object obj =
new
Object();
synchronized
(Thread.currentThread())
{
obj.wait();
obj.notify();
}
}
|
Which statement is true?
This code may throw an InterruptedException
这题有两个错误的地方，第一个错误是 wait() 方法要以 try/catch 包覆，或是掷出 InterruptedException 才行
因此答案就是因为缺少例外捕捉的 InterruptedException
第二个错误的地方是， synchronized 的目标与 wait() 方法的物件不相同，会有 IllegalMonitorStateException ，不过 InterruptedException 会先出现，所以这不是答案
最后正确的程式码应该是这样：
void waitForSignal() {
Object obj = new Object();
synchronized (obj) {
try {
obj.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
obj.notify();
}
}
what is the result of the following code?
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
enum
AccountType
{
SAVING, FIXED, CURRENT;
private
AccountType()
{
System.out.println(“It is a account type”);
}
}
class
EnumOne
{
public
static
void
main(String[]args)
{
System.out.println(AccountType.FIXED);
}
}
|
- Compiles fine and output is prints”It is a account type”once followed by”FIXED”
- Compiles fine and output is prints”It is a account type”twice followed by”FIXED”
- Compiles fine and output is prints”It is a account type”thrice followed by”FIXED”
- Compiles fine and output is prints”It is a account type”four times followed by”FIXED”
- Compilation fails
（2.1）概念
2.1.1名词类
下列不属于Java语言性特点的是
- Java致力于检查程序在编译和运行时的错误
- Java能运行虚拟机实现跨平台
- Java自己操纵内存减少了内存出错的可能性
- Java还实现了真数组，避免了覆盖数据类型的可能
注意，是避免数据覆盖的可能，而不是数据覆盖类型
下列不属于java语言鲁棒性特点的是
- java能检查程序在变异和运行时的错误
- java能运行虚拟机实现跨平台
- java自己操纵内存减少了内存出错的可能性
- java还实现了真数组，避免了覆盖数据的可能
鲁棒性是指健壮性，而jvm实现了跨平台是增强了扩展性
下列说法错误的有（ ）
- 能被java.exe成功运行的java class文件必须有main()方法
- J2SDK就是Java API
- Appletviewer.exe可利用jar选项运行.jar文件
- 能被Appletviewer成功运行的java class文件必须有main()方法
B ：J2Sdk是Sun公司开发的编程工具。
java api是应用程序接口
C：JAR（Java Archive，Java 归档文件）是与平台无关的文件格式，它允许将许多文件组合成一个
压缩文件 。为 J2EE 应用程序创建的 JAR 文件是 EAR 文件（企业 JAR 文件）。打开方式java -jar
AppletViewer是与html有关的
D：appletviewer 提供了一个Java运行环境，在其中可测试小应用程序Applet。appletviewer 读取包含小应用程序的HTML文件并在一个窗口中运行它们。
下列说法正确的有（ ）
- 环境变量可在编译source code时指定
- 在编译程序时，所能指定的环境变量不包括class path
- javac一次可同时编译数个Java源文件
- javac.exe能指定编译结果要置于哪个目录（directory）
a选项-d即可设置系统属性
c选项一次编译多个java文件用
javac *.java. 即可编译当前目录下的所有java文件
d选项－s指定存放生成的源文件的位置
下列哪个选项是Java调试器？如果编译器返回程序代码的错误，可以用它对程序进行调试。
- java.exe
- javadoc.exe
- jdb.exe
- javaprof.exe
在运行时，由java解释器自动引入，而不用import语句引入的包是()。
- java.lang
- java.system
- java.io
- java.util
java.lang包是java语言的核心包，lang是language的缩写
java.lang包定义了一些基本的类型，包括Integer,String之类的，是java程序必备的包，有解释器自动引入，无需手动导入
以下哪一个不是赋值符号？
- +=
- <<=
- <<<=
- >>>=
<<表示左移位
>>表示带符号右移位
>>>表示无符号右移，
它不会将所处理的值的最高位视为正负符号，所以作位移处理时，会直接在空出的高位填入0
但是没有<<<运算符
下面哪个标识符是合法的？
下面哪段程序能够正确的实现了GBK编码字节流到UTF-8编码字节流的转换：
- "9HelloWorld"
- "_Hello World"
- "Hello*World"
- "Hello$World"
1、标识符是以字母开头的字母数字序列：
2、数字是指0~9，字母指大小写英文字母、下划线（_)和美元符号（$），也可以是Unicode字符集中的字符，如汉字；
3、字母、数字等字符的任意组合，不能包含+、- *等字符；
@&
4、不能使用关键字；
5、大小写敏感
由此可以看出： A：不可以数字开头
B：用下划线开头符合，但是中间有空格
C:不能包含“*”
下面哪段程序能够正确的实现了GBK编码字节流到UTF-8编码字节流的转换：
|
1
|
byte
[] src,dst;
|
- dst=String.fromBytes(src，"GBK").getBytes("UTF-8")
- dst=new String(src，"GBK").getBytes("UTF-8")
- dst=new String("GBK"，src).getBytes()
- dst=String.encode(String.decode(src，"GBK"))，"UTF-8" )
选B，先通过GBK编码还原字符串，在该字符串正确的基础上得到“UTF-8”所对应的字节串。
一般用()创建InputStream对象,表示从标准输入中获取数据,用()创建OutputStream对象，表示输出到标准输出设备中。
- System.in System.out
- System.out System.in
- System.io.in System.io.out
- System.io.out System.io.in
标准输入指键盘输入；标准输出指输出到屏幕上。
System.in 和 System.out 是java中的标准输入输出流，一般情况下代表从控制台输入和输出到控制台
BufferedReader的父类是以下哪个？
下列哪个选项是正确计算42度（角度）的余弦值？
- FilterReader
- InputStreamReader
- PipedReader
- Reader
java.io.Reader是一个读取字符流的抽象类，通过继承Reader类，可以很方便的读取字符流，比如，我们可以将一个字符串读取为一串串（字符）流，还可以读取一个文件里的内容为一串串的流。
Java(1.6.x)里提供了几种Reader的直接继承类，具体的有：BufferedReader, CharArrayReader, FileReader, InputStreamReader, PipedReader, StringReader等，子类须实现的方法只有 read(char[], int, int) 和 close()。
下列哪个选项是正确计算42度（角度）的余弦值？
- double d=Math.cos（42）
- double d=Math.cosine（42）
- double d=Math.cos（Math.toRadians（42））
- double d=Math.cos（Math.toDegrees（42））
讲角度转换为弧度
下面有关文件系统元数据的描述，说法错误的是？
- 元数据指用来描述一个文件的特征的系统数据，诸如访问权限、文件拥有者以及文件数据块的分布信息等等
- 我们可以使用stat命令来查看文件更多的元数据信息
- Unix/Linux系统允许，多个文件名指向同一个inode号码
- 文件A和文件B的inode号码虽然不一样，但是文件A的内容是文件B的路径。读取文件A时，系统会自动将访问者导向文件B，这是文件A就称为文件B的"硬链接"
题目中描述的是软链接的情况， 硬链接的 inode 是一样的
2.1.2 关键词类
true、false、null、sizeof、goto、 synchronized 哪些是Java关键字？
- true
- false
- null
- sizeof
- goto
- synchronized
volatile关键字的说法错误的是
- 能保证线程安全
- volatile关键字用在多线程同步中，可保证读取的可见性
- JVM保证从主内存加载到线程工作内存的值是最新的
- volatile能禁止进行指令重排序
以下关于final关键字说法错误的是
- final是java中的修饰符，可以修饰类、接口、抽象类、方法和属性
- final修饰的类肯定不能被继承
- final修饰的方法不能被重载 final修饰的方法不能被重写而不是重载！
- final修饰的变量不允许被再次赋值
|
1
2
3
4
5
6
7
|
class
Foo {
final
int
i;
int
j;
public
void
doSomething() {
System.out.println(++j + i);
}
}
|
1、 final在类中必须初始化
2、类中的final，如果不初始化，必须在构造函数中初始化
代码片段：
|
1
2
3
4
5
|
byte
b1=
1
,b2=
2
,b3,b6;
final
byte
b4=
4
,b5=
6
;
b6=b4+b5;
b3=(b1+b2);
System.out.println(b3+b6);
|
关于上面代码片段叙述正确的是（）
- 输出结果：13
- 语句：b6=b4+b5编译出错
- 语句：b3=b1+b2编译出错
- 运行期抛出异常
final变量被编译器优化，b6=10； 但是b1+b2会返回为int型，int--》byte 不能默认向低位转换，编译报错
有关下述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
testMethod方法用static修饰的，是存在方法区中的，所以可以调用，如果把static去掉，就会报空指针异常
Which of the following can be applied to constructors:
- final
- static
- synchronized
- native
- None of these.
声明常量时通常会用关键字const和static，下面关于两者的区别说法正确的是？
- static表示这个变量可以在其他文件中使用
- static变量连接期被分配到了data段，即使是在函数调用中定义也不会在栈中产生，而是在程序加载期就被加入了内存
- const表面含义是个常量，但实际上还是占据一个内存位置的变量，但是它的值一般实在编译时期就决定了
- 上面说法都不正确
static修饰的全局变量只能在本文件中使用。 可以避免因其他源文件的调用而产生错误。
static静态变量存储在静态域中；final常量编译器存储在常量池中
注意 const 是java的保留字 这个应该是C++题
下述说法中抽象类与接口的区别正确的有哪些？
- 抽象类中可以有普通成员变量，接口中没有普通成员变量。
- 抽象类和接口中都可以包含静态成员变量。
- 一个类可以实现多个接口，但只能继承一个抽象类
- 抽象类中可以包含非抽象的普通方法，接口中的方法必须是抽象的，不能有非抽象的普通方法。
接口中的方法定义默认为public abstract类型，接口中的成员变量类型默认为public static final，属于静态成员变量
忽略内部接口的情况，不能用来修饰interface的有（ ）
- private
- public
- protected
- static
选a,c,d，only public & abstract are permitted
你既然定义了interface(接口)，那肯定是要其它的类去实现它的， 不然你定义它干吗，所以不能用protected去修饰， 而要用public去修饰。
接口可以去继承一个已有的接口。
接口只能被public和默认修饰符修饰，protected也不行所以除了public其他的都要选
下列哪个修饰符可以使在一个类中定义的成员变量只能被同一包中的类访问？
- private
- 无修饰符
- public
- protected
类B从类A派生，则类B可以访问类A中的（ ）成员？
- public成员
- private成员
- protected成员
- 数据成员
- 函数成员
2.1.3 Object类
语句：char foo='中'，是否正确？（假设源文件以GB2312编码存储，并且以javac – encoding GB2312命令编译）
- 正确
- 错误
这在java中是正确的，在C语言中是错误的，java的char类型占两个字节，默认使用GBK编码存储。这种写法是正确的，此外java还可以用中文做变量名
下列说法正确的是（ ）
A. 数组是一种对象
A. 数组是一种对象
B. 数组属于一种原生类
C. int number=[]={31,23,33,43,35,63}
D. 数组的大小可以任意改变
不管在其他语言中是什么，数组在Java中可得看作一个对象，它有一些值得探讨的特性。
（《java jdk5.0 学习笔记》良葛格）
（《java jdk5.0 学习笔记》良葛格）
下面有关java object默认的基本方法，说法错误的是？
下面属于java包装类的是？
下列关于容器集合类的说法正确的是？
- equals(Object obj) 指示某个其他对象是否与此对象“相等”
- copy() 创建并返回此对象的一个副本 Object中没有copy方法
- wait() 导致当前的线程等待，直到其他线程调用此对象的 notify() 方法或 notifyAll() 方法
- toString() 返回该对象的字符串表示
下面属于java包装类的是？
- String String和Date本身就是类。所以也就不存在什么包装类的概念
- Long
- Character
- Short
下列关于容器集合类的说法正确的是？
- LinkedList继承自List
- AbstractSet继承自Set
- HashSet继承自AbstractSet
- WeakMap继承自HashMap
只有WeakHashMap，没有WeakMap
以下集合对象中哪几个是线程安全的？( )
- ArrayList
- Vector
- Hashtable
- Stack
线程安全的map在JDK 1.5及其更高版本环境 有哪几种方法可以实现?
- Map map = new HashMap()
- Map map = new TreeMap()
- Map map = new ConcurrentHashMap();
- Map map = Collections.synchronizedMap(new HashMap());
HashMap和HashTable的描述，错误的是？
- 他们都实现了Map接口。
- HashMap非线程安全，在多个线程访问Hashtable时，不需要自己为它的方法实现同步，而HashMap就必须为之提供额外同步。
- HashMap允许将null作为一个entry的key或者value，而Hashtable不允许。
- 通过contains方法可以判断一个对象是否存在于HashMap或者Hashtable中。
HashMap 把 Hashtable 的 contains 方法去掉了 ，改成 containsvalue 和containsKey 。因为 contains 方法容易让人引起误解。
ArrayList list = new ArrayList(20);中的list扩充几次
- 0
- 1
- 2
- 3
（1）ArrayList()构造一个初始容量为 10 的空列表。 扩充时 以一半扩充
（2）ArrayList(Collection<? extends E> c)构造一个包含指定 collection 的元素的列表，这些元素是按照该 collection 的迭代器返回它们的顺序排列的。
（3）ArrayList(int initialCapacity)构造一个具有指定初始容量的空列表。
调用的是第三个构造函数，直接初始化为大小为20的list，没有扩容，所以选择A
list是一个ArrayList的对象，哪个选项的代码填到//todo delete处，可以在Iterator遍历的过程中正确并安全的删除一个list中保存的对象？（）
|
1
2
3
4
5
6
7
8
9
10
11
|
Iterator it = list.iterator();
int
index =
0
;
while
(it.hasNext())
{
Object obj = it.next();
if
(needDelete(obj))
//needDelete返回boolean，决定是否要删除
{
//todo delete
}
index ++;
}
|
- it.remove();
- list.remove(obj);
- list.remove(index);
- list.remove(obj,index);
如果在循环的过程中调用集合的remove()方法，就会导致循环出错，例如：
for(int i=0;i<list.size();i++){
list.remove(...);
}
循环过程中list.size()的大小变化了，就导致了错误。
所以，如果你想在循环语句中删除集合中的某个元素，就要用迭代器iterator的remove()方法，因为它的remove()方法不仅会删除元素，还会维护一个标志，用来记录目前是不是可删除状态，例如，你不能连续两次调用它的remove()方法，调用之前至少有一次next()方法的调用。
for(int i=0;i<list.size();i++){
list.remove(...);
}
循环过程中list.size()的大小变化了，就导致了错误。
所以，如果你想在循环语句中删除集合中的某个元素，就要用迭代器iterator的remove()方法，因为它的remove()方法不仅会删除元素，还会维护一个标志，用来记录目前是不是可删除状态，例如，你不能连续两次调用它的remove()方法，调用之前至少有一次next()方法的调用。
下面哪些类可以被继承？ Java.lang.Thread、java.lang.Number、java.lang.Number.Double、java.lang.Number.Math、 java.lang.Number.ClassLoader
- Thread
- Number
- Double
- Math
- ClassLoader
下面有关JAVA异常类的描述，说法错误的是？
- 异常的继承结构：基类为Throwable，Error和Exception继承Throwable，RuntimeException和IOException等继承Exception
- 非RuntimeException一般是外部错误，其必须被 try{}catch语句块所捕获
- Error类体系描述了Java运行系统中的内部错误以及资源耗尽的情形，Error不需要捕捉
- RuntimeException体系包括错误的类型转换、数组越界访问和试图访问空指针等等，必须被 try{}catch语句块所捕获
下面代码运行结果是（）
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
public
class
Test{
public
int
add(
int
a,
int
b){
try
{
return
a+b;
}
catch
(Exception e) {
System.out.println(
"catch语句块"
);
}
finally
{
System.out.println(
"finally语句块"
);
}
return
0
;
}
public
static
void
main(String argv[]){
Test test =
new
Test();
System.out.println(
"和是："
+test.add(
9
,
34
));
}
}
|
- catch语句块，和是：43
- 编译异常
- finally语句块，和是：43
- 和是：43，finally语句块
对于try块中的return，先计算return 后面的表达式，缓存结果
跳到finally语句块中执行，如果finally语句块中有return语句，则不会再去执行try中的语句。
如果finally中没有return语句，则会再次去try语句块中执行return
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
public
class
Test{
public
static
int
a(){
int
a =
0
;
try
{
a =
1
;
return
a;
}
catch
(Exception e) {
}
finally
{
a =
2
;
}
return
3
;
}
public
static
void
main(String[] args){
System.out.println(a());
}
}
|
打印结果是1
1、假设利用 return 语句从 try 语句块中退出。在方法返回前，finally子句的内容将被执行。
2、他首先检测是否有finally，如果有，就将return值保存。然后进入fianlly执行，finally执行完成后，再执行return的操作
3、如果 finally 子句中也有一个 return 语句，这个返回值将会覆盖原始的返回值。
以下关于对象序列化描述正确的是
- 使用FileOutputStream可以将对象进行传输
- 使用PrintWriter可以将对象进行传输
- 使用transient修饰的变量不会被序列化
- 对象序列化的所属类需要实现Serializable接口
2、能够对对象进行传输的貌似只有ObjectOutputStream和ObjectInputStream这些以Object开头的流对象。
3、D项继承Seriallizable接口是经常见到的，这毋庸置疑。
4、
transient 修饰的变量在对象串化的时侯并不会将所赋值的值保存到传中，串化的对象从磁盘读取出来仍然是null。
5、这值得说下Volatile这个修饰符，它是针对多线程情况下出现的。当线程读取它修饰的变量时，都会强迫从主存中重新读取。
2.1.4 并发类
Thread. sleep()是否会抛出checked exception?
- 会
关于ThreadLocal以下说法正确的是
- ThreadLocal继承自Thread
- ThreadLocal实现了Runnable接口
- ThreadLocal重要作用在于多线程间的数据共享
- ThreadLocal是采用哈希表的方式来为每个线程都提供一个变量的副本
- ThreadLocal保证各个线程间数据安全，每个线程的数据不会被另外线程访问和破坏
1、ThreadLocal的类声明：
public class ThreadLocal<T>
可以看出ThreadLocal并没有继承自Thread，也没有实现Runnable接口。所以AB都不对。
2、ThreadLocal类为每一个线程都维护了自己独有的变量拷贝。每个线程都拥有了自己独立的一个变量。
所以ThreadLocal重要作用并不在于多线程间的数据共享，而是数据的独立，C选项错。
由于每个线程在访问该变量时，读取和修改的，都是自己独有的那一份变量拷贝，不会被其他线程访问，
变量被彻底封闭在每个访问的线程中。所以E对。
3、ThreadLocal中定义了一个哈希表用于为每个线程都提供一个变量的副本：
下面有关java threadlocal说法正确的有？
- ThreadLocal存放的值是线程封闭，线程间互斥的，主要用于线程内共享一些数据，避免通过参数来传递
- 线程的角度看，每个线程都保持一个对其线程局部变量副本的隐式引用，只要线程是活动的并且 ThreadLocal 实例是可访问的；在线程消失之后，其线程局部实例的所有副本都会被垃圾回收
- 在Thread类中有一个Map，用于存储每一个线程的变量的副本。
- 对于多线程资源共享的问题，同步机制采用了“以时间换空间”的方式，而ThreadLocal采用了“以空间换时间”的方式
“ThreadLocal存放的值是线程封闭，线程间互斥的”这个在《java并发编程》P.37面有讲
“主要用于线程内共享一些数据，避免通过参数来传递”
下列关于Java并发的说法中正确的是（）
- CopyOnWriteArrayList适用于写多读少的并发场景
- ReadWriteLock适用于读多写少的并发场景
- ConcurrentHashMap的写操作不需要加锁，读操作需要加锁
- 只要在定义int类型的成员变量i的时候加上volatile关键字，那么多线程并发执行i++这样的操作的时候就是线程安全的了
答案：B
A，CopyOnWriteArrayList适用于
写少读多的并发场景
B，ReadWriteLock即为读写锁，他要求写与写之间互斥，读与写之间互斥，
读与读之间可以并发执行。在读多写少的情况下可以提高效率
C，ConcurrentHashMap是同步的HashMap，读写都加锁
D，volatile只保证多线程操作的可见性，不保证原子性
java用（）机制实现了进程之间的异步执行
- 监视器
- 虚拟机
- 多个CPU
- 异步调用
首先jvm中没有进程的概念 ，但是jvm中的线程映射为操作系统中的进程，对应关系为1：1。那这道题的问的就是jvm中线程如何异步执行 。 在jvm中 是使用监视器锁来实现不同线程的异步执行， 在语法的表现就是synchronized
Java通过synchronized关键字使用同步代码块或者同步方法进行多线程的同步
2.1.5 数据库驱动、加载器类
下面哪一项不是加载驱动程序的方法？
以下描述正确的是
- 通过DriverManager.getConnection方法加载
- 调用方法 Class.forName
- 通过添加系统的jdbc.drivers属性
- 通过registerDriver方法注
DriverManager.getConnection方法返回一个Connection对象，这是加载驱动之后才能进行的
下面有关java类加载器，说法正确的是？
- 引导类加载器（bootstrap class loader）：它用来加载 Java 的核心库，是用原生代码来实现的
- 扩展类加载器（extensions class loader）：它用来加载 Java 的扩展库。
- 系统类加载器（system class loader）：它根据 Java 应用的类路径（CLASSPATH）来加载 Java 类
- tomcat为每个App创建一个Loader，里面保存着此WebApp的ClassLoader。需要加载WebApp下的类时，就取出ClassLoader来使用
- CallableStatement是PreparedStatement的父接口
- PreparedStatement是CallableStatement的父接口
- CallableStatement是Statement的子接口
- PreparedStatement是Statement的父接口
public interface
CallableStatement extends
PreparedStatement
public interface
PreparedStatement extends
Statement
下面有关jdbc statement的说法错误的是？
- JDBC提供了Statement、PreparedStatement 和 CallableStatement三种方式来执行查询语句，其中 Statement 用于通用查询， PreparedStatement 用于执行参数化查询，而 CallableStatement则是用于存储过程
- 对于PreparedStatement来说，数据库可以使用已经编译过及定义好的执行计划，这种预处理语句查询比普通的Statement查询运行速度更快
- PreparedStatement中，“?” 叫做占位符，一个占位符可以有一个或者多个值
- PreparedStatement可以阻止常见的SQL注入式攻击
？在sql中是占位符，只能有一个值代替
http://blog.csdn.net/fei20121106/article/details/47910925
ResultSet中记录行的第一列索引为？
- -1
- 0
- 1
- 以上都不是
ResultSet跟普通的数组不同，索引从1开始而不是从0开始
（2.1.2） 函数、类、接口
下列说法正确的是（）
- JAVA程序的main方法必须写在类里面
- JAVA程序中可以有多个main方法
- JAVA程序中类名必须与文件名一样
- JAVA程序的main方法中，如果只有一条语句，可以不用{}（大括号）括起来
A，java是强类型语言，所有的方法必须放在类里面，包括main
B ,java中可以有多个重载的main方法，只有public static void main(String[] args){}是函数入口
C，内部类的类名一般与文件名不同
D，函数都必须用{}括起来，不管是一条语句还是多条语句
在java的多态调用中，new的是哪一个类就是调用的哪个类的方法。
错
java多态有两种情况：重载和覆写
在覆写中，运用的是动态单分配，是根据new的类型确定对象，从而确定调用的方法；
在重载中，运用的是静态多分派，即根据静态类型确定对象，因此不是根据new的类型确定调用的方法
在使用super 和this关键字时，以下描述正确的是
- 在子类构造方法中使用super（）显示调用父类的构造方法，super（）必须写在子类构造方法的第一行，否则编译不通过
- super（）和this（）不一定要放在构造方法内第一行
- this（）和super（）可以同时出现在一个构造函数中
- this（）和super（）可以在static环境中使用，包括static方法和static语句块
1）调用super()必须写在子类构造方法的第一行，否则编译不通过。每个子类构造方法的第一条语句，都是隐含地调用super()，如果父类没有这种形式的构造函数，那么在编译的时候就会报错。
2）super()和this()类似,区别是，super从子类中调用父类的构造方法，this()在同一类内调用其它方法。
3）super()和this()均需放在构造方法内第一行。
4）尽管可以用this调用一个构造器，但却不能调用两个。
5）this和super不能同时出现在一个构造函数里面，因为this必然会调用其它的构造函数，其它的构造函数必然也会有super语句的存在，所以在同一个构造函数里面有相同的语句，就失去了语句的意义，编译器也不会通过。
6）this()和super()都指的是对象，所以，均不可以在static环境中使用。包括：static变量,static方法，static语句块。
7）从本质上讲，this是一个指向本对象的指针, 然而super是一个Java关键字。
class A {}
class B extends A {}
class C extends A {}
class D extends B {}
Which three statements are true ?
class B extends A {}
class C extends A {}
class D extends B {}
Which three statements are true ?
- The type List<A>is assignable to List.
- The type List<B>is assignable to List<A>.
- The type List<Object>is assignable to List<?>.
- The type List<D>is assignable to List<?extends B>.
- The type List<?extends A>is assignable to List<A>.
- The type List<Object>is assignable to any List reference.
- The type List<?extends B>is assignable to List<?extends A>.
A，C，D，G对，本人亲测
- The type List<A>is assignable to List.
关于抽象类与接口，下列说法正确的有？
- 优先选用接口，尽量少用抽象类
- 抽象类可以被声明使用，接口不可以被声明使用
- 抽象类和接口都不能被实例化。
- 以上说法都不对
下列哪一种叙述是正确的（ ）
- abstract修饰符可修饰字段、方法和类
- 抽象方法的body部分必须用一对大括号{ }包住
- 声明抽象方法，大括号可有可无
- 声明抽象方法不可写出大括号
1：用abstract修饰的类表示抽象类，抽象类位于继承树的抽象层，抽象类不能被实例化。
2：用abstract修饰的方法表示抽象方法,抽象方法没有方法体。抽象方法用来描述系统具有什么功能，但不提供具体的实现。
下列说法错误的有（ ）
- Java面向对象语言容许单独的过程与函数存在
- Java面向对象语言容许单独的方法存在
- Java语言中的方法属于类中的成员（member）
- Java语言中的方法必定隶属于某一类（对象），调用方法与过程或函数相同
java不允许单独的方法，过程或函数存在,需要隶属于某一类中。——AB错
java语言中的方法属于对象的成员,而不是类的成员。不过，其中静态方法属于类的成员。——C错
下列说法错误的有（ ）
- 在类方法中可用this来调用本类的类方法
- 在类方法中调用本类的类方法时可直接调用
- 在类方法中只能调用本类中的类方法
- 在类方法中绝对不能调用实例方法
a，静态方法中没有this指针
c，可以通过类名作用域的方式调用Class::fun();
d，太绝对化了，在类中申请一个类对象或者参数传递一个对象或者指针都可以调用;
（2.3）java web
有关会话跟踪技术描述正确的是（）
- Cookie是Web服务器发送给客户端的一小段信息，客户端请求时，可以读取该信息发送到服务器端
- 关闭浏览器意味着会话ID丢失，但所有与原会话关联的会话数据仍保留在服务器上，直至会话过期
- 在禁用Cookie时可以使用URL重写技术跟踪会话
- 隐藏表单域将字段添加到HTML表单并在客户端浏览器中显示
在Struts框架中如果要使用Validation作验证的话，需要使用以下哪个Form？
- ActionForm
- ValidatorActionForm
- ValidatorForm
- DynaValidatorActionForm
ASP中Session对象默认有效期为多少分钟？
- 10
- 20
- 30
- 60
常用的servlet包的名称是？
- java.servlet
- javax.servlet
- servlet.http
- javax.servlet.http
下面有关servlet中init,service,destroy方法描述错误的是？
- init()方法是servlet生命的起点。一旦加载了某个servlet，服务器将立即调用它的init()方法
- Service()方法处理客户机发出的所有请求
- destroy()方法标志servlet生命周期的结束
- servlet在多线程下使用了同步机制，因此，在并发编程下servlet是线程安全的
下列有关Servlet的生命周期，说法不正确的是？
- 在创建自己的Servlet时候，应该在初始化方法init()方法中创建Servlet实例
- 在Servlet生命周期的服务阶段，执行service()方法，根据用户请求的方法，执行相应的doGet()或是doPost()方法
- 在销毁阶段，执行destroy()方法后会释放Servlet 占用的资源
- destroy()方法仅执行一次，即在服务器停止且卸载Servlet时执行该方法
创建Servlet的实例是由Servlet容器来完成的，且创建Servlet实例是在初始化方法init()之前
ServletConfig接口默认是哪里实现的？
从以下哪一个选项中可以获得Servlet的初始化参数?
- Servlet
- GenericServlet
- HttpServlet
- 用户自定义servlet
GenericServlet类的实现接口中包括了ServletConfig接口，但是它自身的init(ServletConfig config)方法又需要外界给它传递一个实现ServletConfig的对象，就是说GenericServlet和ServletConfig的依赖关系既是继承关系，也是一种关联关系
从以下哪一个选项中可以获得Servlet的初始化参数?
- Servlet
- ServletContext
- ServletConfig
- GenericServlet
ServletContext对象：servlet容器在启动时会加载web应用，并为每个web应用创建唯一的servlet context对象，可以把ServletContext看成是一个Web应用的
服务器端组件的共享内存，在ServletContext中可以存放共享数据。ServletContext对象是真正的一个全局对象，凡是web容器中的Servlet都可以访问。
整个web应用只有唯一的一个ServletContext对象
servletConfig对象：用于封装servlet的配置信息。从一个servlet被实例化后，对任何客户端在任何时候访问有效，但仅对servlet自身有效，一个servlet的ServletConfig对象不能被另一个servlet访问。
如何获取ServletContext设置的参数值？
- context.getParameter()
- context.getInitParameter()
- context.getAttribute()
- context.getRequestDispatcher()
java如何接受request域中的参数？
- request.getRequestURL()
- request. getAttribute()
- request.getParameter()
- request.getWriter()
下面哪个不属于HttpServletResponse接口完成的功能？
- 设置HTTP头标
- 设置cookie
- 读取路径信息
- 输出返回数据
HttpServletResponse完成：设置http头标，设置cookie，设置返回数据类型，输出返回数据；读取路径信息是HttpServletRequest做的
下面不属于HttpServletRequest接口完成功能的是？
- 读取cookie
- 读取HTTP头
- 设定响应的content类型
- 读取路径信息
1.读取和写入HTTP头标
2.取得和设置cookies
3.取得路径信息
4.标识HTTP会话
HttpSession session = request.getSession(false) 与HttpSession session = request.getSession(true)的区别？
- 没有区别
- 如果当前reqeust中的HttpSession 为null，当传入参数为空时，就创建一个新的Session，否则返回null
- 如果当前reqeust中的HttpSession 为null，当传入参数为true时，就创建一个新的Session，否则返回null
返回当前请求的会话。如果当前请求不属于任何会话，而且create参数为true，则创建一个会话，否则返回null。此后所有来自同一个的请求都属于这个会话，通过它的getSession返回的是当前会话。
HttpSession session = request.getSession() 等同于 request.getSession(true),如果不存在就创建一个新的session
在J2EE中，使用Servlet过滤器，需要在web.xml中配置（）元素
- <filter>
- <filter-mapping>
- <servlet-filter>
- <filter-config>
下面有关forward和redirect的描述，正确的是？
- forward是服务器将控制权转交给另外一个内部服务器对象，由新的对象来全权负责响应用户的请求 控制权不转交
- 执行forward时，浏览器不知道服务器发送的内容是从何处来，浏览器地址栏中还是原来的地址
- 执行redirect时，服务器端告诉浏览器重新去请求地址
- forward是内部重定向，redirect是外部重定向
- redirect默认将产生301 Permanently moved的HTTP响应 302申请临时url
下面哪项技术可以用在WEB开发中实现会话跟踪实现？
- session
- Cookie
- 地址重写
- 隐藏域
有四种方法可以实现会话跟踪技术：URL重写、隐藏表单域、Cookie、Session。
1）.隐藏表单域：<input type="hidden">，非常适合步需要大量数据存储的会话应用。
2）.URL 重写:URL 可以在后面附加参数，和服务器的请求一起发送，这些参数为名字/值对。
3）.Cookie:一个 Cookie 是一个小的，已命名数据元素。服务器使用 SET-Cookie 头标将它作为 HTTP
响应的一部分传送到客户端，客户端被请求保存 Cookie 值，在对同一服务器的后续请求使用一个
Cookie 头标将之返回到服务器。与其它技术比较，Cookie 的一个优点是在浏览器会话结束后，甚至
在客户端计算机重启后它仍可以保留其值
4）.Session：使用 setAttribute(String str,Object obj)方法将对象捆绑到一个会话
1）.隐藏表单域：<input type="hidden">，非常适合步需要大量数据存储的会话应用。
2）.URL 重写:URL 可以在后面附加参数，和服务器的请求一起发送，这些参数为名字/值对。
3）.Cookie:一个 Cookie 是一个小的，已命名数据元素。服务器使用 SET-Cookie 头标将它作为 HTTP
响应的一部分传送到客户端，客户端被请求保存 Cookie 值，在对同一服务器的后续请求使用一个
Cookie 头标将之返回到服务器。与其它技术比较，Cookie 的一个优点是在浏览器会话结束后，甚至
在客户端计算机重启后它仍可以保留其值
4）.Session：使用 setAttribute(String str,Object obj)方法将对象捆绑到一个会话
下面有关servlet和cgi的描述，说法错误的是？
- servlet处于服务器进程中，它通过多线程方式运行其service方法
- CGI对每个请求都产生新的进程，服务完成后就销毁
- servlet在易用性上强于cgi，它提供了大量的实用工具例程，例如自动地解析和解码HTML表单数据、读取和设置HTTP头、处理Cookie、跟踪会话状态等
- cgi在移植性上高于servlet，几乎所有的主流服务器都直接或通过插件支持cgi
servlet处于服务器进程中，它通过多线程方式运行其service方法，一个实例可以服务于多个请求，并且其实例一般不会销毁，而CGI对每个请求都产生新的进程，服务完成后就销毁，所以效率上低于servlet。
CGI程序不可移植，为某一特定平台编写的CGI程序只能运行在这一特定的环境下
关于spring说法错误的是（）
- spring是一个轻量级JAVA EE的框架集合
- spring是“依赖注入”模式的实现
- 使用spring可以实现声明事务
- spring提供了AOP方式的日志系统
答案 ： D
Spring通过对AOP的支持，借助Spring与日志系统log4j实现日志系统
Spring通过对AOP的支持，借助Spring与日志系统log4j实现日志系统
Spring Framework是一个开源的Java／Java EE全功能栈（full-stack）的应用程序框架，Spring中包含的关键特性:
1.强大的基于JavaBeans的采用控制翻转（Inversion of Control，IoC）原则的配置管理，使得应用程序的组建更加快捷简易。
2.一个可用于从applet到Java EE等不同运行环境的核心Bean工厂。
数据库事务的一般化抽象层，允许声明式（Declarative）事务管理器，简化事务的划分使之与底层无关。
3.内建的针对JTA和单个JDBC数据源的一般化策略，使Spring的事务支持不要求Java EE环境，这与一般的JTA或者EJB CMT相反。
4.JDBC 抽象层提供了有针对性的异常等级（不再从SQL异常中提取原始代码），简化了错误处理，大大减少了程序员的编码量。再次利用JDBC时，你无需再写出另一个'终止'（finally）模块。并且面向JDBC的异常与Spring通用数据访问对象（Data Access Object）异常等级相一致。
5.以资源容器，DAO实现和事务策略等形式与Hibernate，JDO和iBATIS SQL Maps集成。利用众多的翻转控制方便特性来全面支持，解决了许多典型的Hibernate集成问题。所有这些全部遵从Spring通用事务处理和通用数据访问对象异常等级规范。
6.灵活的基于核心Spring功能的MVC网页应用程序框架。开发者通过策略接口将拥有对该框架的高度控制，因而该框架将适应于多种呈现（View）技术，例如JSP、FreeMarker、Velocity、Tiles、iText以及POI。值得注意的是，Spring中间层可以轻易地结合于任何基于MVC框架的网页层，例如Struts、WebWork或Tapestry。
7.提供诸如事务管理等服务的面向方面编程框架。
1.强大的基于JavaBeans的采用控制翻转（Inversion of Control，IoC）原则的配置管理，使得应用程序的组建更加快捷简易。
2.一个可用于从applet到Java EE等不同运行环境的核心Bean工厂。
数据库事务的一般化抽象层，允许声明式（Declarative）事务管理器，简化事务的划分使之与底层无关。
3.内建的针对JTA和单个JDBC数据源的一般化策略，使Spring的事务支持不要求Java EE环境，这与一般的JTA或者EJB CMT相反。
4.JDBC 抽象层提供了有针对性的异常等级（不再从SQL异常中提取原始代码），简化了错误处理，大大减少了程序员的编码量。再次利用JDBC时，你无需再写出另一个'终止'（finally）模块。并且面向JDBC的异常与Spring通用数据访问对象（Data Access Object）异常等级相一致。
5.以资源容器，DAO实现和事务策略等形式与Hibernate，JDO和iBATIS SQL Maps集成。利用众多的翻转控制方便特性来全面支持，解决了许多典型的Hibernate集成问题。所有这些全部遵从Spring通用事务处理和通用数据访问对象异常等级规范。
6.灵活的基于核心Spring功能的MVC网页应用程序框架。开发者通过策略接口将拥有对该框架的高度控制，因而该框架将适应于多种呈现（View）技术，例如JSP、FreeMarker、Velocity、Tiles、iText以及POI。值得注意的是，Spring中间层可以轻易地结合于任何基于MVC框架的网页层，例如Struts、WebWork或Tapestry。
7.提供诸如事务管理等服务的面向方面编程框架。
另外，Spring并没有提供日志系统，我们需要使用AOP（面向方面编程）的方式，借助Spring与日志系统log4j实现我们自己的日志系统
下面哪一项不属于优化Hibernate所鼓励的？
- 使用单向一对多关联，不使用双向一对多
- 不用一对一，用多对一取代
- 配置对象缓存，不使用集合缓存
- 继承类使用显式多态
下面有关maven和ant的描述，描述错误的是？
- Ant 没有正式的约定如一个一般项目的目录结构，你必须明确的告诉 Ant 哪里去找源代码
- Maven 拥有约定，因为你遵循了约定，它已经知道你的源代码在哪里
- maven和ant都有“生命周期”的概念，当你输入一个命令后，maven或者ant会执行一系列的有序的步骤，直到到达你指定的生命周期
- Ant构建文件默认命名为build.xml，Maven默认构建文件为pom.xml
（2.6）Java Swing
关于AWT和Swing说法正确的是？
- Swing是AWT的子类
- AWT在不同操作系统中显示相同的风格
- AWT不支持事件类型，Swing支持事件模型
- Swing在不同的操作系统中显示相同的风格
AWT，抽象窗口工具包，是Java提供的建立图形用户界面的工具集，可用于生成现代的、鼠标控制的图形应用接口，且无需修改，就可以在各种软硬件平台上运行。
而swing是Java语言在编写图形用户界面方面的新技术，Swing采用模型-视图-控制设计范式，Swing可以使Java程序在同一个平台上运行时能够有不同外观以供用户选择。
两者不同在于一个是初代工具集，一个是进化版的工具集，用户不会再满足于初始的功能，而是更加注重于附加价值，明显从这点上，Swing是比AWT要好很多。
写法上，Swing的头文件引用包需要用到Javax，组件调用时也需要在AWT的基础上加上“J”。
AWT ：是通过调用操作系统的native方法实现的，所以在Windows系统上的AWT窗口就是Windows的风格，而在Unix系统上的则是XWindow风格。
AWT
中的图形函数与
操作系统
所提供的图形函数之间有着一一对应的关系，我们把它称为peers。 也就是说，当我们利用
AWT
来构件图形用户界面的时候，我们实际上是在利用
操作系统
所提供的图形库。由于不同
操作系统
的图形库所提供的功能是不一样的，在一个平台上存在的功能在另外一个平台上则可能不存在。为了实现Java语言所宣称的"一次编译，到处运行"的概念，AWT 不得不通过牺牲功能来实现其平台无关性，也就是说，AWT 所提供的图形功能是各种通用型操作系统所提供的图形功能的交集。由于AWT 是依靠本地方法来实现其功能的，我们通常把AWT控件称为重量级控件。
Swing ：是所谓的Lightweight组件，不是通过native方法来实现的，所以Swing的窗口风格更多样化。但是,Swing里面也有heaveyweight组件。比如JWindow，Dialog,JFrame
Swing是所谓的Lightweight组件，不是通过native方法来实现的，所以Swing的窗口风格更多样化。但是,Swing里面也有heaveyweight组件。比如JWindow，Dialog,JFrame
Swing由纯Java写成，可移植性好，外观在不同平台上相同。所以Swing部件称为轻量级组件（ Swing是由纯JAVA CODE所写的，因此SWING解决了JAVA因窗口类而无法跨平台的问题，使窗口功能也具有跨平台与延展性的特性，而且SWING不需占有太多系统资源，因此称为轻量级组件！！！）
下列Java常见事件类中哪个是鼠标事件类？（）
- InputEvent
- KeyEvent
- MouseEvent
- WindowEvent
(2.5)设计模式
下列关于静态工厂和工厂方法表述错误的是：（）
- 在工厂方法模式中，对于存在继承等级结构的产品树，产品的创建是通过相应等级结构的工厂创建的
- 不能形成静态工厂的继承结构
- 静态工厂对具体产品的创建类别和创建时机的判断是混和在一起的，这点在工厂方法中
- 二者都满足开闭原则：静态工厂以if else方式创建对象，增加需求的时候会修改源代码
结构型模式中最体现扩展性的几种模式是（）
- 装饰模式
- 合成模式
- 桥接模式
- 适配器
关于AWT和Swing说法正确的是？
- Swing是AWT的子类
- AWT在不同操作系统中显示相同的风格
- AWT不支持事件类型，Swing支持事件模型
- Swing在不同的操作系统中显示相同的风格
AWT，抽象窗口工具包，是Java提供的建立图形用户界面的工具集，可用于生成现代的、鼠标控制的图形应用接口，且无需修改，就可以在各种软硬件平台上运行。
而swing是Java语言在编写图形用户界面方面的新技术，Swing采用模型-视图-控制设计范式，Swing可以使Java程序在同一个平台上运行时能够有不同外观以供用户选择。
两者不同在于一个是初代工具集，一个是进化版的工具集，用户不会再满足于初始的功能，而是更加注重于附加价值，明显从这点上，Swing是比AWT要好很多。
写法上，Swing的头文件引用包需要用到Javax，组件调用时也需要在AWT的基础上加上“J”。
AWT ：是通过调用操作系统的native方法实现的，所以在Windows系统上的AWT窗口就是Windows的风格，而在Unix系统上的则是XWindow风格。
AWT
中的图形函数与
操作系统
所提供的图形函数之间有着一一对应的关系，我们把它称为peers。 也就是说，当我们利用
AWT
来构件图形用户界面的时候，我们实际上是在利用
操作系统
所提供的图形库。由于不同
操作系统
的图形库所提供的功能是不一样的，在一个平台上存在的功能在另外一个平台上则可能不存在。为了实现Java语言所宣称的"一次编译，到处运行"的概念，AWT 不得不通过牺牲功能来实现其平台无关性，也就是说，AWT 所提供的图形功能是各种通用型操作系统所提供的图形功能的交集。由于AWT 是依靠本地方法来实现其功能的，我们通常把AWT控件称为重量级控件。
Swing ：是所谓的Lightweight组件，不是通过native方法来实现的，所以Swing的窗口风格更多样化。但是,Swing里面也有heaveyweight组件。比如JWindow，Dialog,JFrame
Swing是所谓的Lightweight组件，不是通过native方法来实现的，所以Swing的窗口风格更多样化。但是,Swing里面也有heaveyweight组件。比如JWindow，Dialog,JFrame
Swing由纯Java写成，可移植性好，外观在不同平台上相同。所以Swing部件称为轻量级组件（ Swing是由纯JAVA CODE所写的，因此SWING解决了JAVA因窗口类而无法跨平台的问题，使窗口功能也具有跨平台与延展性的特性，而且SWING不需占有太多系统资源，因此称为轻量级组件！！！）
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
public
class
Test{
public
static
int
a(){
int
a =
0
;
try
{
a =
1
;
return
a;
}
catch
(Exception e) {
}
finally
{
a =
2
;
}
return
3
;
}
public
static
void
main(String[] args){
System.out.println(a());
}
}
|
打印结果是1
1、假设利用 return 语句从 try 语句块中退出。在方法返回前，finally子句的内容将被执行。
2、他首先检测是否有finally，如果有，就将return值保存。然后进入fianlly执行，finally执行完成后，再执行return的操作
3、如果 finally 子句中也有一个 return 语句，这个返回值将会覆盖原始的返回值。
扫一扫
222
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
