【Java】Java选择题错题集（二）
socket编程中，以下哪个socket的操作是不属于服务端操作的（）？
正确答案: C 你的答案: B (错误)
accept
listen
connect
close
以下代码执行的结果显示是多少（ ）？
public class Demo { class Super{ int flag=1; Super(){ test(); } void test(){ System.out.println("Super.test() flag="+flag); } } class Sub extends Super { Sub(int i){ flag=i; System.out.println("Sub.Sub()flag="+flag); } void test(){ System.out.println("Sub.test()flag="+flag); } } public static void main(String[] args) { new Demo().new Sub(5); }
}
正确答案: A 你的答案: D (错误)
Sub.test() flag=1 Sub.Sub() flag=5
Sub.Sub() flag=5 Sub.test() flag=5
Sub.test() flag=0 Sub.Sub() flag=5
Super.test() flag=1 Sub.Sub() flag=5
1.首先调用父类构造方法，即super（）
2.调用test（）方法。
3.
由于在子类sub（）中重写了test（）方法，所以调用子类test（）
4.
输出Sub.test() flag=1
5.
调用sub的有参构造方法
6.
输出Sub.Sub() flag=5
重点在于要时刻记得子类重写父类方法，调用时会调用子类重写之后的方法
当然，这一切的前提都是
实例化子类对象
下列有关Servlet的生命周期，说法不正确的是？
正确答案: A 你的答案: D (错误)
在创建自己的Servlet时候，应该在初始化方法init()方法中创建Servlet实例
在Servlet生命周期的服务阶段，执行service()方法，根据用户请求的方法，执行相应的doGet()或是doPost()方法
在销毁阶段，执行destroy()方法后会释放Servlet 占用的资源
destroy()方法仅执行一次，即在服务器停止且卸载Servlet时执行该方法
Servlet的生命周期分为5个阶段：加载、创建、初始化、处理客户请求、卸载。
(1)
加载
：容器通过类加载器使用servlet类对应的文件加载servlet
(2)
创建
：通过调用servlet构造函数创建一个servlet对象
(3)
初始化
：调用init方法初始化
(4)
处理客户请求
：每当有一个客户请求，容器会创建一个线程来处理客户请求
(5)
卸载
：调用destroy方法让servlet自己释放其占用的资源
下面哪一项不属于优化Hibernate所鼓励的？
正确答案: A 你的答案: B (错误)
使用单向一对多关联，不使用双向一对多
不用一对一，用多对一取代
配置对象缓存，不使用集合缓存
继承类使用显式多态
优化Hibernate所鼓励的7大措施：
1.尽量使用many-to-one，避免使用单项one-to-many
2.灵活使用单向one-to-many
3.不用一对一，使用多对一代替一对一
4.配置对象缓存，不使用集合缓存
5.一对多使用Bag 多对一使用Set
6.继承使用显示多态 HQL:from object polymorphism="exlicit" 避免查处所有对象
7.消除大表，使用二级缓存
关于 访问权限说法正确 的是 ？ ( )
正确答案: B 你的答案: D (错误)
类定义前面可以修饰public,protected和private
内部类前面可以修饰public,protected和private
局部内部类前面可以修饰public,protected和private
以上说法都不正确
对于
外部类
来说，只有两种修饰，
public和默认（default）
，因为外部类放在包中，只有两种可能，包可见和包不可见。
对于
内部类
来说，可以有
所有的修饰
，因为内部类放在外部类中，与成员变量的地位一致，所以有四种可能。
Java 的屏幕坐标是以像素为单位，容器的左下角被确定为坐标的起点。
正确答案: B 你的答案: A (错误)
正确
错误
给出以下代码,请给出结果.
|
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;
}
}
|
正确答案: B 你的答案: F (错误)
null null 42
null 42 42
0 0 42
0 42 42
An exception is thrown at runtime
Compilation
关于sleep()和wait()，以下描述错误的一项是（ ）
正确答案: D 你的答案: A (错误)
sleep是线程类（Thread）的方法，wait是Object类的方法；
sleep不释放对象锁，wait放弃对象锁
sleep暂停线程、但监控状态仍然保持，结束后会自动恢复
wait后进入等待锁定池，只有针对此对象发出notify方法后获得对象锁进入运行状态
共同点 ：
1. 他们都是在多线程的环境下，都可以在程序的调用处阻塞指定的毫秒数，并返回。
2. wait()和sleep()都可以通过interrupt()方法 打断线程的暂停状态 ，从而使线程立刻抛出InterruptedException 。
如果线程A希望立即结束线程B，则可以对线程B对应的Thread实例调用interrupt方法。如果此刻线程B正在wait/sleep/join，则线程B会立刻抛出InterruptedException，在catch() {} 中直接return即可安全地结束线程。
需要注意的是， InterruptedException是线程自己从内部抛出的，并不是interrupt()方法抛出的 。对某一线程调用 interrupt()时，如果该线程正在执行普通的代码，那么该线程根本就不会抛出InterruptedException。但是，一旦该线程进入到 wait()/sleep()/join()后，就会立刻抛出InterruptedException 。
不同点 ：
1.每个对象都有一个锁来控制同步访问。Synchronized关键字可以和对象的锁交互，来实现线程的同步。
sleep方法没有释放锁，而wait方法释放了锁 ，使得其他线程可以使用同步控制块或者方法。
2. wait，notify和notifyAll只能在同步控制方法或者同步控制块里面使用，而sleep可以在任何地方使用
3. sleep必须捕获异常，而wait，notify和notifyAll不需要捕获异常
1. 他们都是在多线程的环境下，都可以在程序的调用处阻塞指定的毫秒数，并返回。
2. wait()和sleep()都可以通过interrupt()方法 打断线程的暂停状态 ，从而使线程立刻抛出InterruptedException 。
如果线程A希望立即结束线程B，则可以对线程B对应的Thread实例调用interrupt方法。如果此刻线程B正在wait/sleep/join，则线程B会立刻抛出InterruptedException，在catch() {} 中直接return即可安全地结束线程。
需要注意的是， InterruptedException是线程自己从内部抛出的，并不是interrupt()方法抛出的 。对某一线程调用 interrupt()时，如果该线程正在执行普通的代码，那么该线程根本就不会抛出InterruptedException。但是，一旦该线程进入到 wait()/sleep()/join()后，就会立刻抛出InterruptedException 。
不同点 ：
1.每个对象都有一个锁来控制同步访问。Synchronized关键字可以和对象的锁交互，来实现线程的同步。
sleep方法没有释放锁，而wait方法释放了锁 ，使得其他线程可以使用同步控制块或者方法。
2. wait，notify和notifyAll只能在同步控制方法或者同步控制块里面使用，而sleep可以在任何地方使用
3. sleep必须捕获异常，而wait，notify和notifyAll不需要捕获异常
4.
sleep是线程类（Thread）的方法
，导致此线程暂停执行指定时间，给执行机会给其他线程，但是监控状态依然保持，到时后会自动恢复。调用sleep不会释放对象锁。
5.
wait是Object类的方法
，对此对象调用wait方法导致本线程放弃对象锁，进入等待此对象的等待锁定池，
只有针对此对象发出notify方法（或notifyAll）
后本线程才进入对象锁定池准备获得对象锁进入运行状态。
ResultSet中记录行的第一列索引为？
正确答案: C 你的答案: B (错误)
-1
0
1
以上都不是
以下描述正确的是
正确答案: B 你的答案: C (错误)
CallableStatement是PreparedStatement的父接口
PreparedStatement是CallableStatement的父接口
CallableStatement是Statement的父接口
PreparedStatement是Statement的父接口
下列有关Thread的描述，哪个是正确的？
正确答案: C 你的答案: B (错误)
启动一个线程的方法是：thread. run()
结束一个线程的通常做法是：thread. stop()
将一个线程标记成daemon线程，意味着当主线程结束，并且没有其它正在运行的非daemon线程时，该daemon线程也会自动结束。
让一个线程等待另一个线程的通知的方法是：thread. sleep()
A:thread.start()
B:不建议，结束线程设置一个flag变量或者结合interrupt()方法
C:设置为后台线程
D：thread.wait()
B:不建议，结束线程设置一个flag变量或者结合interrupt()方法
C:设置为后台线程
D：thread.wait()
如果希望监听TCP端口9000，应该怎样创建socket?
正确答案: B 你的答案: A (错误)
new Socket("localhost",9000);
new ServerSocket(9000);
new Socket(9000);
new ServerSocket("localhost",9000);
创建一个serversocket 绑定在特定的端口
Socket( InetAddress address, int port)
创建一个socket流，连接到特定的端口和ip地址
在Java语言中，下列关于字符集编码（Character set encoding）和国际化（i18n）的问题，哪些是正确的？
正确答案: C D 你的答案: A C (错误)
每个中文字符占用2个字节，每个英文字符占用1个字节
假设数据库中的字符是以GBK编码的，那么显示数据库数据的网页也必须是GBK编码的。
Java的char类型，通常以UTF-16 Big Endian的方式保存一个字符。
实现国际化应用常用的手段是利用ResourceBundle类
A 显然是错误的，
Java一律采用Unicode编码方式，每个字符无论中文还是英文字符都占用2个字节
。
B 也是不正确的，不同的编码之间是可以转换的，通常流程如下：
将字符串S以其自身编码方式分解为字节数组，再将字节数组以你想要输出的编码方式重新编码为字符串。
例：String newUTF8Str = new String(oldGBKStr.getBytes("GBK"), "UTF8");
C 是正确的。
Java虚拟机中通常使用UTF-16的方式保存一个字符
D 也是正确的。
ResourceBundle能够依据Local的不同，选择性的读取与Local对应后缀的properties文件，以达到国际化的目的。
综上所述，答案是 C 和 D。
在 Java 中，属于整数类型变量的是（）
正确答案: C 你的答案: D (错误)
single
double
byte
char
Java中的四类八种基本数据类型
第一类：整数类型 byte short int long
第二类：浮点型 float double
第三类：逻辑型 boolean(它只有两个值可取true false)
第四类：字符型 char
What results from the following code fragment?
|
1
2
3
|
int
i =
5
;
int
j =
10
;
System.out.println(i + ~j);
|
正确答案: C 你的答案: D (错误)
Compilation error because”~”doesn’t operate on integers
-5
-6
15
公式-n=~n+1可推出~n=-n-1，所以~10=-11再加5结果为-6
执行如下代码段后，变量s1引用的字符串值是( )。
String s1 = "ABCD"; String s2 = "1234"; System.out.println(s1 + s2); |
正确答案: A 你的答案: C (错误)
ABCD
1234
ABCD1234
1234ABCD
用命令方式运行以下代码的运行结果是（）
|
1
2
3
4
5
6
7
|
public
class
f{
public
static
void
main(String[] args){
String foo1 = args[
1
];
String foo2 = args[
2
];
String foo3 = args[
3
];
}
}
|
命令: java T11 a b c
正确答案: C 你的答案: B (错误)
程序编译错误
a b c
程序运行错误
t11
jre 判断程序是否执行结束的标准是（）
正确答案: A 你的答案: C (错误)
所有的前台线程执行完毕
所有的后台线程执行完毕
所有的线程执行完毕
和以上都无关
以下是java concurrent包下的4个类，选出差别最大的一个
正确答案: C 你的答案: B (错误)
Semaphore
ReentrantLock
Future
CountDownLatch
1、答案选C。
a、它是个接口。
b、别的类都处理线程间的关系，处理并发机制，但该类只用于获取线程结果。
2、Future表示获取一个正在指定的线程的结果。对该线程有取消和判断是否执行完毕等操作。
3、CountDownLatch 是个锁存器，他表示我要占用给定的多少个线程且我优先执行，我执行完之前其他要使用该资源的都要等待。
4、 Semaphore，就像是一个许可证发放者，也想一个数据库连接池。证就这么多，如果池中的证没换回来，其他人就不能用。
5、 ReentrantLock 和 synchronized一样，用于锁定线程。
给出以下代码
请给出结果：（）
|
1
2
3
4
5
6
7
8
9
10
|
public
class
TestObj{
public
static
void
main(String[] args){
Object o=
new
Object(){
public
boolean
equals(Object obj){
return
true
;
}
};
System.out.println(o.equals(“Fred”));
}
}
|
正确答案: B 你的答案: A (错误)
运行时抛出异常
true
Fred
第三行编译错误
内部类
public
class
TestObj {
public
static
void
main(String[] args){
Object o=
new
Object(){
//重写了equals(),不管参数是什么，都是返回true
public
boolean
equals(Object obj){
return
true
;
}
};
System.out.println(o.equals(
"Fred"
));
}
}
在Java中,下列说法错误的有（ ）
正确答案: B C D 你的答案: D (错误)
数组是一种对象
数组属于一种原生类
int number = []{31,23,33,43,35,63};
数组的大小可以任意改变
整数：byte，short，int，long（默认是int类型）
浮点类型： float，double（默认是double类型）
字符类型：char
布尔类型：boolean
引用数据类型3种：数组，类，接口
关于以下程序代码的说明正确的
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
class
HasStatic{
private
static
int
x =
100
;
public
static
void
main(String args[ ]){
HasStatic hs1 =
new
HasStatic();
hs1.x++;
HasStatic hs2 =
new
HasStatic();
hs2.x++;
hs1=
new
HasStatic();
hs1.x++;
HasStatic.x--;
System.out.println(
"x="
+x);
}
}
|
正确答案: D 你的答案: A (错误)
5行不能通过编译，因为引用了私有静态变量
10行不能通过编译，因为x是私有静态变量
程序通过编译，输出结果为：x=103
程序通过编译，输出结果为：x=102
因为x的 修饰符为 static 所以x为类变量，即对于所有的实例来说，他们访问的x为同一个x，类变量存储在方法区，不属于每个实例的私有，
刚开始x=100
调用hs1.x++ x为101;
调用hs2.x++ x为102;
调用hs1.x++ x为103 (此时hs1指向了一个新的HasStatic实例，但是依然访问的是同一个X)
调用HasStatic.x-- x为102
所以结果为D
如果变量被static修饰，那么该变量属于类，该类的所有对象操作的都是同一个变量。
两种访问方式都可以，如下：
public class Java_class {
private static int number=100;
public static void main(String[] args){
Java_class jc=new Java_class();
jc.number++;
Java_class.number++;
System.out.print(number);
}
}
以下哪项陈述是正确的？
正确答案: E 你的答案: C (错误)
垃圾回收线程的优先级很高，以保证不再 使用的内存将被及时回收
垃圾收集允许程序开发者明确指定释放 哪一个对象
垃圾回收机制保证了JAVA程序不会出现 内存溢出
进入”Dead”状态的线程将被垃圾回收器回收
以上都不对
B：垃圾收集器（GC）程序开发者只能推荐JVM进行回收，但何时回收，回收哪些，程序员不能控制。
C：垃圾回收机制 只是回收不再使用的JVM内存 ， 如果程序有严重BUG，照样内存溢出 。
D：进入DEAD的线程，它还可以恢复，GC不会回收
Java 提供的事件处理模型是一种人机交互模型。它有三个基本要素
正确答案: A B D 你的答案: B C D (错误)
事件源
事件对象
事件过程
事件监听器
Java
提供的事件处理模型是一种人机交互模型。它有三个基本要素：
1) 事件源（Event Source）：即事件发生的场所，就是指各个组件，如按钮等，点击按钮其实就是组件上发生的一个事件；
2) 事件（Event）：事件封装了组件上发生的事情，比如按钮单击、按钮松开等等；
3) 事件监听器（Event Listener）：负责监听事件源上发生的特定类型的事件，当事件到来时还必须负责处理相应的事件；
下列描述错误的是?
正确答案: B D 你的答案: C D (错误)
类只能继承一个父类，但是可以实现多个接口
抽象类自身可以定义成员而接口不可以
抽象类和接口都不能被实例化(忽略匿名内部类)
一个类可以有多个基类和多个基接口
B、 接口允许定义成员，但必须是 常量。java 接口中可以定义成员变量，且必须是 static final的
C、 抽象类和接口类的无法实例化，任何编译器中直接使用new会报错。
D、 同 A ，单继承，多实现。
下面有关forward和redirect的描述，正确的是() ？
正确答案: B C D 你的答案: B D (错误)
forward是服务器将控制权转交给另外一个内部服务器对象，由新的对象来全权负责响应用户的请求
执行forward时，浏览器不知道服务器发送的内容是从何处来，浏览器地址栏中还是原来的地址
执行redirect时，服务器端告诉浏览器重新去请求地址
forward是内部重定向，redirect是外部重定向
redirect默认将产生301 Permanently moved的HTTP响应
1.从地址栏显示来说
forward是服务器请求资源
,服务器直接访问目标地址的URL,把那个URL的响应内容读取过来,然后把这些内容再发给浏览器.浏览器根本不知道服务器发送的内容从哪里来的,
所以它的地址栏还是原来的地址
.
redirect是服务端根据逻辑
,发送一个状态码,
告诉浏览器重新去请求那个地址.所以地址栏显示的是新的URL.
2.从数据共享来说
forward:转发页面和转发到的页面可以共享request里面的数据.
redirect:不能共享数据.
3.从运用地方来说
forward:一般用于用户登陆的时候
,根据角色转发到相应的模块.
redirect:一般用于用户注销登陆时返回主页面和跳转到其它的网站等
.
4.从效率来说
forward:高.
redirect:低.
redirect默认是302码，包含两次请求和两次响应
A选项 服务器会直接访问目标地址的URL，不会把控制权转交，因此错误！
下面赋值语句中正确的是（）
正确答案: A 你的答案: D (错误)
double d=5.3e12;
float f=11.1;
int i=0.0;
Double oD=3;
int 转为 封装类型Double，是无法编译的
Double oD = 3.0， 会把double类型的3.0自动装箱为Double，没有问题
执行语句“int a= ’ 2 ’ ”后，a的值是（ ）
正确答案: B 你的答案: A (错误)
2
50
49
0
常见字符的ASCII码值如下：空格的ASCII码值为32；数字0到9的ASCII码值分别为48到57；大写字母“A”到“Z”的ASCII码值分别为65到90；小写字母“a”到“z”的ASCII码值分别为97到到122。
关于匿名内部类叙述正确的是？ ( )
正确答案: B 你的答案: D (错误)
匿名内部类可以继承一个基类，不可以实现一个接口
匿名内部类不可以定义构造器
匿名内部类不能用于形参
以上说法都不正确
以下程序段的输出结果为：
|
1
2
3
4
5
6
7
8
9
10
11
|
public
class
EqualsMethod
{
public
static
void
main(String[] args)
{
Integer n1 =
new
Integer(
47
);
Integer n2 =
new
Integer(
47
);
System.out.print(n1 == n2);
System.out.print(
","
);
System.out.println(n1 != n2);
}
}
|
正确答案: B 你的答案: C (错误)
false，false
false，true
true，false
true，true
使用Integer a = 1;或Integer a = Integer.valueOf(1); 在值介于-128至127直接时，作为基本类型。
使用
Integer a = new Integer(1); 时，无论值是多少，都作为对象。
class
Foo {
final
int
i;
int
j;
public
void
doSomething() {
System.out.println(++j + i);
}
}
|
正确答案: D 你的答案: B (错误)
0
1
2
不能执行，因为编译有错
选项中哪一行代码可以添加 到题目中而不产生编译错误？
|
1
2
3
4
5
6
|
public
abstract
class
MyClass {
public
int
constInt = 5;
//add code here
public
void
method() {
}
}
|
正确答案: A 你的答案: B (错误)
public abstract void method(int a);
constInt = constInt + 5;
public int method();
public abstract void anotherMethod() {}
答案是A
A是抽象方法，抽象类可以包含抽象方法，也可以不包含，虽然A 方法名是method，与题目中的方法同名，但是参数不同，是重载方法
B
在类中不能constInt = constInt + 5; 方法中可以
C 的方法名与题目中的方法名相同，返回值不能作为重载的依据
D 抽象方法没有方法体
关于AWT和Swing说法正确的是？
正确答案: D 你的答案: C (错误)
Swing是AWT的子类
AWT在不同操作系统中显示相同的风格
AWT不支持事件类型，Swing支持事件模型
Swing在不同的操作系统中显示相同的风格
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并发的说法中正确的是：
正确答案: B 你的答案: D (错误)
copyonwritearraylist适用于写多读少的并发场景
readwritelock适用于读多写少的并发场景
concurrenthashmap的写操作不需要加锁，读操作需要加锁
只要在定义int类型的成员变量i的时候加上volatile关键字，那么多线程并发执行i++这样的操作的时候就是线程安全的了
CopyOnWriteArrayList适合使用在读操作远远大于写操作的场景里，比如缓存。
ReadWriteLock 当写操作时，其他线程无法读取或写入数据，而当读操作时，其它线程无法写入数据，但却可以读取数据 。适用于 读取远远大于写入的操作。
ConcurrentHashMap是一个线程安全的Hash Table，它的主要功能是提供了一组和HashTable功能相同但是线程安全的方法。ConcurrentHashMap可以做到读取数据不加锁，并且其内部的结构可以让其在进行写操作的时候能够将锁的粒度保持地尽量地小，不用对整个ConcurrentHashMap加锁。
要使 volatile 变量提供理想的线程安全，必须同时满足下面两个条件：
- （1）对变量的写操作不依赖于当前值。
- （2）该变量没有包含在具有其他变量的不变式中。
- 实际上，这些条件表明，可以被写入 volatile 变量的这些有效值独立于任何程序的状态，包括变量的当前状态。
-
变量a是一个64位有符号的整数，初始值用16进制表示为：0Xf000000000000000； 变量b是一个64位有符号的整数，初始值用16进制表示为：0x7FFFFFFFFFFFFFFF。 则a-b的结果用10进制表示为多少？（）
正确答案: C 你的答案: D (错误)
1
-(2^62+2^61+2^60+1)
2^62+2^61+2^60+1
2^59+(2^55+2^54+…+2^2+2^1+2^0)
（1）原码是符号位加上真值的绝对值，即用第一位表示符号位，其余位表示值。
（2）正数的反码是其本身。负数的反码是在原码的基础上，符号位不变，其余按位取反。
（3）正数的补码是其本身。负数的补码是在原码的基础上，符号位不变，其余按位取反，最后加1。
（4）计算机进行符号运算时，会以补码表示，符号位和数字位会一起参与运算。
a-b实际转换为[a-b]补=[a]补+[-b]补
a为1111（后面60个0），1开头，所以为一个负数；补码为1001（后面60个0）
b为0111（后面60个1），0开头，所以为一个正数；补码为其本身。
-b为1111（后面60个1），补码为1000（后面59个0，最后有个1）
所以1001（后面60个0） + 1000（后面59个0.最后有个1） = 0001（后面59个0，最后有个1），发生了溢出，比如采用双高位判别法处理溢出，则补码1001（后面59个0，最后有个1）转换为原码为1110（后面60个1），即-（7 *2的60次方+1）=-（2的62次方+2的61次方+2的60次方 + 1）
答案：-(2^62+2^61+2^60+1)
-
在开发中使用泛型取代非泛型的数据类型（比如用ArrayList
取代ArrayList），程序的运行时性能会变得更好。 泛型仅仅是java的一颗语法糖，它不会影响java虚拟机生成的汇编代码，在编译阶段，虚拟机就会把泛型的类型擦除，还原成没有泛型的代码，顶多编译速度稍微慢一些，执行速度是完全没有什么区别的。正确答案: B 你的答案: A (错误)
对
错
jdk1.8中，下面有关java 抽象类和接口的区别，说法错误的是？
正确答案: B D 你的答案: D (错误)
抽象类可以有构造方法，接口中不能有构造方法
抽象类中可以包含非抽象的普通方法，接口中的方法必须是抽象的，不能有非抽象的普通方法
一个类可以实现多个接口，但只能继承一个抽象类
接口中可以有普通成员变量，抽象类中没有普通成员变量
下面哪些赋值语句是正确的（）
正确答案: A B D 你的答案: C (错误)
long test=012
float f=-412
int other =(int)true
double d=0x12345678
byte b=128
A和B中long和float，正常定义需要加l和f，但是long和float属于基本类型，会进行转化，所以不会报出异常。AB正确
boolean类型不能和任何类型进行转换，会报出类型异常错误。所以C错。
D选项可以这样定义，D正确。
E选项中，
byte的取值范围是-128—127
。报出异常： cannot convert from int to byte.所以E选项错误。
|
1
2
3
|
Integer i =
42
;
Long l = 42l;
Double d =
42.0
;
|
正确答案: G 你的答案: F (错误)
(i == l)
(i == d)
(l == d)
i.equals(d)
d.equals(l)
i.equals(l)
l.equals(42L)
ABC3 个选项很明显，不同类型引用的 == 比较，会出现编译错误，不能比较。
DEF 调用 equals 方法，因为此方法先是比较类型，而 i ， d ， l 是不同的类型，所以返回假。
选项 G ，会自动装箱，将 42L 装箱成 Long 类型，所以调用 equals 方法时，类型相同，且值也相同，因此返回真。
transient变量和下面哪一项有关（）？
正确答案: A 你的答案: D (错误)
Serializable
Cloneable
Runnable
Throwable
Comparable
我们都知道一个对象只要实现了Serilizable接口，这个对象就可以被序列化，java的这种序列化模式为开发者提供了很多便利，我们可以不必关系具体序列化的过程，只要这个类实现了Serilizable接口，这个类的所有属性和方法都会自动序列化。
这个类的有些属性需要序列化，而其他属性不需要被序列化；
java 的transient关键字为我们提供了便利，你只需要实现Serilizable接口，将不需要序列化的属性前添加关键字transient，序列化对象的时候，这个属性就不会序列化到指定的目的地中。
总之，java 的transient关键字为我们提供了便利，你只需要实现Serilizable接口，将不需要序列化的属性前添加关键字transient，序列化对象的时候，这个属性就不会序列化到指定的目的地中。
哪个关键字可以对对象加互斥锁？（）
正确答案: A 你的答案: B (错误)
synchronized
volatile
serialize
static
synchronized
关键字
:
用来给对象和方法或者代码块加锁，当它锁定一个方法或者一个代码块的时候，同一时刻最多只有一个线程执行这个段代码。
volatile：用来确保将变量的跟新操作通知到其他线程，
当把变量声明为volatile类型后，编译器与运行时都会注意到这个变量是共享的
，因此不会将该变量上的操作与其他内存操作一起重排序。然而，
在访问volatile变量时不会执行加锁操作
，因此也就不会使执行线程阻塞，因此volatile变量是一种比 synchronized
关键字更轻量级的同步机制。
以下代码运行输出的是
|
1
2
3
4
5
6
7
8
9
10
11
|
public
class
Person{
private
String name =
"Person"
;
int
age=
0
;
}
public
class
Child
extends
Person{
public
String grade;
public
static
void
main(String[] args){
Person p =
new
Child();
System.out.println(p.name);
}
}
|
正确答案: C 你的答案: D (错误)
输出：Person
没有输出
编译出错
运行出错
Java中对字段属性是静态绑定，方法成员是动态绑定，这里错在：在子类中试图访问父类的private字段，所以编译不通过，将private去掉就可访问，不是动态绑定的问题，它本来就属于静态绑定。
下面程序的输出结果是什么。
|
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
33
34
35
|
public
class
A2{
public
static
void
main(String[] args){
int
[] a={
2
,
4
,
6
,
8
,
3
,
6
,
9
,
12
};
doSomething(a,
0
,a.length-
1
);
for
(
int
i=
0
;i<=a.length-
1
;i++)
System.out.print(a[i]+
" "
);
}
private
static
void
doSomething(
int
[] a,
int
start,
int
end){
if
(start
int
p=core(a,start,end);
doSomething(a,start,p-
1
);
doSomething(a,p+
1
,end);
}
}
private
static
int
core(
int
[] a,
int
start,
int
end)
{
int
x=a[end];
int
i=start;
for
(
int
j=start;j<=end-
1
;j++){
if
(a[j]>=x){
swap(a,i,j);
i++;
//交换了几次
}
}
//把最大的放到最后
swap(a,i,end);
//把最大的放到i的位置
return
i;
}
private
static
void
swap(
int
[] a,
int
i,
int
j)
{
int
tmp=a[i];
a[i]=a[j];
a[j]=tmp;
}
}
|
正确答案: C 你的答案: D (错误)
找到最大值
找到最小值
从大到小的排序
从小到大的排序
在Struts框架中如果要使用Validation作验证的话，需要使用以下哪个Form？
正确答案: D 你的答案: C (错误)
ActionForm
ValidatorActionForm
ValidatorForm
DynaValidatorActionForm
DynaValidatorActionForm 动态验证表单
Test.main() 函数执行后的输出是（）
正确答案: D 你的答案: 空 (错误)
11 17 34
22 74 74
6 7 7
22 34 17
首先，super()函数指的是调用父类的构造方法
①
new B()
执行B的构造函数，第一行是super(5);
此时执行的是A的构造函数，A的构造函数调用的是setValue()方法，由于B重写了A的这个方法，
所以！！！执行的是B的 setValue()方法。
即传入的参数是2*5=10
此时，因为super，所以调用的是父类的 setValue()方法，即value=10
第一行执行完毕。
第二行是 setValue(getValue()-3);
B没有getValue()方法，故执行父类的此方法，
try返回的是value=10+1=11，保存在临时栈中
finally中调用this的方法，这个this指的是B的对象，又重写，故就是B的 setValue()方法
value=2*11=22，第一个打印到屏幕上的数字
接下来参数 getValue()-3=11-3=8
传入B的 setValue()方法
此时value=2*8=16
至此，new B()执行结束
②
new B(). getValue()
B没有 getValue()，故执行A的 getValue()
try返回16+1=17，保存到临时栈中
finally调用B的 setValue()方法
value=17*2=34，第二个打印到屏幕上面的数字
最后主函数打印返回值，也就是try保存到临时栈的17
|
1
|
答案就是：
22
,
34
,
17
|
常用的servlet包的名称是？
正确答案: B D 你的答案: 空 (错误)
java.servlet
javax.servlet
servlet.http
javax.servlet.http
javax是Sun公司提供的一个扩展包，算是对原 JAVA 包的一些优化处理，现在已经有很多都是基于JAVAX的程序开发而不是java包。
下面有关java类加载器，说法正确的是？
正确答案: A B C D 你的答案: B (错误)
引导类加载器（bootstrap class loader）：它用来加载 Java 的核心库，是用原生代码来实现的
扩展类加载器（extensions class loader）：它用来加载 Java 的扩展库。
系统类加载器（system class loader）：它根据 Java 应用的类路径（CLASSPATH）来加载 Java 类
tomcat为每个App创建一个Loader，里面保存着此WebApp的ClassLoader。需要加载WebApp下的类时，就取出ClassLoader来使用
What might cause the current thread to stop executing
正确答案: A B E 你的答案: A B D (错误)
An InterruptedException is thrown.
The thread executes a wait() call.
The thread constructs a new Thread.
A thread of higher priority becomes ready.
The thread executes a waitforID()call on a MediaTracker.
D选项有问题啊，优先级高只能是说明，它获得时间片的概率大，但不是一定会执行它