牛客网_java选择题

如何跳出Array的forEach循环？（）
正确答案: A 你的答案: A (正确)
break
return true
return false
以上都不是

JAVA题目,选A。BC项可以跳出一个返回值为boolean类型的函数里面的forEach。有牛友回答的是JS，JS不可以使用break，原因是js中的forEach（）无法在所有元素都传递给调用的函数之前终止遍历。也就是说，没有像for循环中使用的相应的break语句。如果要提前终止，必须把forEach（）方法放在一个try块中，并能抛出一个异常。如果forEach（）调用的函数抛出foreach.break异常，循环会提前终止。

接口不能扩展（继承）多个接口。（）
正确答案: B 你的答案: A (错误)
正确
错误

java类是单继承的。classB Extends classA
java接口可以多继承。Interface3 Extends Interface0, Interface1, interface……
不允许类多重继承的主要原因是，如果A同时继承B和C，而b和c同时有一个D方法，A如何决定该继承那一个呢？
但接口不存在这样的问题，接口全都是抽象方法继承谁都无所谓，所以接口可以继承多个接口。

静态内部类不可以直接访问外围类的非静态数据，而非静态内部类可以直接访问外围类的数据，包括私有数据。（）
正确答案: A 你的答案: B (错误)
正确
错误

public static void main(String args[]) {
List Listlist1 = new ArrayList();
Listlist1.add(0);
List Listlist2 = Listlist1;
System.out.println(Listlist1.get(0) instanceof Integer);
System.out.println(Listlist2.get(0) instanceof Integer);
}
正确答案: B 你的答案: C (错误)
编译错误
true true
true false
false false

collection类型的集合（ArrayList,LinkedList）只能装入对象类型的数据，该题中装入了0，是一个基本类型，但是JDK5以后提供了自动装箱与自动拆箱，所以int类型自动装箱变为了Integer类型。编译能够正常通过。
将list1的引用赋值给了list2，那么list1和list2都将指向同一个堆内存空间。instanceof是Java中关键字，用于判断一个对象是否属于某个特定类的实例，并且返回boolean类型的返回值。显然，list1.get(0)和list2.get(0)都属于Integer的实例

计算机所能处理的最小的数据项称为（）
正确答案: A 你的答案: B (错误)
位
字节
字
双字

位<字节<字<双字

假如某个JAVA进程的JVM参数配置如下：
-Xms1G -Xmx2G -Xmn500M -XX:MaxPermSize=64M -XX:+UseConcMarkSweepGC -XX:SurvivorRatio=3,
请问eden区最终分配的大小是多少？
正确答案: C 你的答案: B (错误)
64M
500M
300M
100M

java -Xmx2G -Xms1G -Xmn500M -Xss128k
-Xmx2G：设置JVM最大可用内存为2G。
-Xms1G：设置JVM促使内存为1G。此值可以设置与-Xmx相同，以避免每次垃圾回收完成后JVM重新分配内存。
-Xmn500M：设置年轻代大小为2G。整个JVM内存大小=年轻代大小 + 年老代大小 + 持久代大小。
-XX:SurvivorRatio=3:新生代中又会划分为 Eden 区，from Survivor、to Survivor 区。
其中 Eden 和 Survivor 区的比例默认是 8:1:1，当然也支持参数调整 -XX:SurvivorRatio=3的话就是3:1:1。

在Struts框架中如果要使用Validation作验证的话，需要使用以下哪个Form？
正确答案: D 你的答案: B (错误)
ActionForm
ValidatorActionForm
ValidatorForm
DynaValidatorActionForm

DynaValidatorActionForm 动态验证表单
Validation 确认的意思

有关线程的哪些叙述是对的（）
正确答案: B C D 你的答案: B (错误)
A.一旦一个线程被创建，它就立即开始运行。
B.使用start()方法可以使一个线程成为可运行的，但是它不一定立即开始运行。
C.当一个线程因为抢先机制而停止运行，它可能被放在可运行队列的前面。
D.一个线程可能因为不同的原因停止并进入就绪状态。

在抢先式系统下，由高优先级的线程参与调度。分为2种情况：
1.若多个线程都处于就绪状态，则具有高优先级的线程会在低优先级之前得到执行；
2.在当前线程的运行过程中，如果有较高级别的线程准备就绪，则正在运行的较低级别的线程将被挂起，转到较高级别的线程运行，直到结束后又会转到原来被挂起的线程。
第二种情况就描述了C所代表的情况，可以看到当较高级别的线程抢去运行权并运行完成之后，是先将权利转给原来的线程的，所以C是正确的。

在抢先式系统下，由高优先级的线程参与调度。分为2种情况：
1.若多个线程都处于就绪状态，则具有高优先级的线程会在低优先级之前得到执行；
2.在当前线程的运行过程中，如果有较高级别的线程准备就绪，则正在运行的较低级别的线程将被挂起，转到较高级别的线程运行，直到结束后又会转到原来被挂起的线程。
第二种情况就描述了C所代表的情况，可以看到当较高级别的线程抢去运行权并运行完成之后，是先将权利转给原来的线程的，所以C是正确的。

线程同步：喂，蛇（SHE）
喂（Vector）
S（Stack）
H（hashtable）
E（enumeration）

以下哪种JAVA得变量声明方式可以避免程序在多线程竞争情况下读到不正确的值( )
正确答案: A B 你的答案: C D (错误)
volatile
static volatile
synchronized
static

synchronized不是修饰变量的它修饰方法或代码块或对象

如果类的方法没有返回值，该方法的返回类型应是：( )
正确答案: A 你的答案: A (正确)
void
null
abstract
default
Which of the following class is not implement java.util.Map interface?
正确答案: C 你的答案: A (错误)
Hashtable
HashMap
Vector
IdentityHashMap

A，B，D都实现了Map接口，其中A与B的区别是一个是线程安全的，一个是线程不安全的
C中Vector是实现了List接口，是一个线程安全的List
____技术是一种可以使音频，视频和其他多媒体信息在 Internet 及 Intranet 上以实时的，无需下载等待的方式进行播放的技术。

正确答案: A 你的答案: A (正确)
流媒体
多媒体
复合媒体
音视媒体

流媒体技术是一种可以使音频，视频和其他多媒体信息在 Internet 及 Intranet 上以实时的，无需下载等待的方式进行播放的技术。
流媒体又叫流式媒体，它是指商家用一个视频传送服务器把节目当成数据包发出，传送到网络上。

以下代码的循环次数是
public class Test {
public static void main(String args[]) {
int i = 7;
do {
System.out.println(–i);
–i;
} while (i != 0);
System.out.println(i);
}
}
正确答案: D 你的答案: D (正确)
0
1
7
无限次

单独的–i和i–没有区别，但是在表达式中，–i会先进行自减再执行语句，而i–是先执行语句再进行自减，这一题每次循环执行输出语句时i自减1，执行–i时再次自减1，每次循环减2，总值为7，第四次执行循环时，i=-1，不等于0，所以会无限循环

关于抽象类和接口叙述正确的是？ ( )
正确答案: D 你的答案: D (正确)
抽象类和接口都能实例化的
抽象类不能实现接口
抽象类方法的访问权限默认都是public
接口方法的访问权限默认都是public

抽象类
特点:
1.抽象类中可以构造方法
2.抽象类中可以存在普通属性，方法，静态属性和方法。
3.抽象类中可以存在抽象方法。
4.如果一个类中有一个抽象方法，那么当前类一定是抽象类；抽象类中不一定有抽象方法。
5.抽象类中的抽象方法，需要有子类实现，如果子类不实现，则子类也需要定义为抽象的。
6,抽象类不能被实例化，抽象类和抽象方法必须被abstract修饰
关键字使用注意：
抽象类中的抽象方法（其前有abstract修饰）不能用private、static、synchronized、native访问修饰符修饰。
接口
1.在接口中只有方法的声明，没有方法体。
2.在接口中只有常量，因为定义的变量，在编译的时候都会默认加上public static final
3.在接口中的方法，永远都被public来修饰。
4.接口中没有构造方法，也不能实例化接口的对象。（所以接口不能继承类）
5.接口可以实现多继承
6.接口中定义的方法都需要有实现类来实现，如果实现类不能实现接口中的所有方法则实现类定义为抽象类。
7，接口可以继承接口，用extends

下面哪个Set类是排序的？
正确答案: B 你的答案: D (错误)
LinkedHashSet
TreeSet
HashSet
AbstractSet

LinkedHashSet
继承于HashSet、又基于 LinkedHashMap 来实现
TreeSet
使用二叉树的原理对新 add()的对象按照指定的顺序排序（升序、降序），每增加一个对象都会进行排序，将对象插入的二叉树指定的位置。
HashSet
存储元素的顺序并不是按照存入时的顺序（和 List 显然不同）而是按照哈希值来存的所以取数据也是按照哈希值取得

下面代码运行结果是（）
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));
}
}
正确答案: C 你的答案: C (正确)
A.catch语句块
和是：43
B.编译异常
C.finally语句块
和是：43
D.和是：43
finally语句块

先来看一段代码：public abstract class Test {public static void main(String[] args) {System.out.println(beforeFinally());}public static int beforeFinally(){int a = 0;try{a = 1;return a;}finally{a = 2;}}
}/**output:
1
*/
从结果上看，貌似`finally` 里的语句是在`return` 之后执行的，其实不然，实际上`finally` 里的语句是在在`return` 之前执行的。那么问题来了，既然是在之前执行，那为什么`a` 的值没有被覆盖了？
实际过程是这样的：当程序执行到try{}语句中的return方法时，它会干这么一件事，将要返回的结果存储到一个临时栈中，然后程序不会立即返回，而是去执行finally{}中的程序， 在执行`a = 2`时，程序仅仅是覆盖了a的值，但不会去更新临时栈中的那个要返回的值 。执行完之后，就会通知主程序“finally的程序执行完毕，可以请求返回了”，这时，就会将临时栈中的值取出来返回。这下应该清楚了，要返回的值是保存至临时栈中的。
再来看一个例子,稍微改下上面的程序：public abstract class Test {public static void main(String[] args) {System.out.println(beforeFinally());}public static int beforeFinally(){int a = 0;try{a = 1;return a;}finally{a = 2;return a;}}
}
/**output:
2
*/
在这里，finally{}里也有一个return，那么在执行这个return时，就会更新临时栈中的值。同样，在执行完finally之后，就会通知主程序请求返回了，即将临时栈中的值取出来返回。故返回值是2.

当你编译和运行下面的代码时，会出现下面选项中的哪种情况？
public class Pvf{
static boolean Paddy;
public static void main(String args[]){
System.out.println(Paddy);
}
}

正确答案: B 你的答案: D (错误)
编译时错误
编译通过并输出结果false
编译通过并输出结果true
编译通过并输出结果null

类中声明的变量有默认初始值；方法中声明的变量没有默认初始值，必须在定义时初始化，否则在访问该变量时会出错。
boolean类型默认值是false

以下 _____ 不是 Object 类的方法
正确答案: D 你的答案: A (错误)
clone（）
finalize()
toString()
hasNext()

下面有关SPRING的事务传播特性，说法错误的是？
正确答案: B 你的答案: B (正确)
PROPAGATION_SUPPORTS：支持当前事务，如果当前没有事务，就以非事务方式执行
PROPAGATION_REQUIRED：支持当前事务，如果当前没有事务，就抛出异常
PROPAGATION_REQUIRES_NEW：新建事务，如果当前存在事务，把当前事务挂起
PROPAGATION_NESTED：支持当前事务，新增Savepoint点，与当前事务同步提交或回滚

PROPAGATION_REQUIRED–支持当前事务，如果当前没有事务，就新建一个事务。这是最常见的选择。
PROPAGATION_SUPPORTS–支持当前事务，如果当前没有事务，就以非事务方式执行。
PROPAGATION_MANDATORY–支持当前事务，如果当前没有事务，就抛出异常。
PROPAGATION_REQUIRES_NEW–新建事务，如果当前存在事务，把当前事务挂起。
PROPAGATION_NOT_SUPPORTED–以非事务方式执行操作，如果当前存在事务，就把当前事务挂起。
PROPAGATION_NEVER–以非事务方式执行，如果当前存在事务，则抛出异常。

在Java图形用户界面编程中，如果需要显示信息，一般是使用__________类的对象来实现。
正确答案: A 你的答案: C (错误)
JLabel
JButton
JTextArea
JtextField

JTextField单行文本
JTextArea多行文本
JButton按键显示
JLable显示标签信息

下列代码执行结果为（）
public static void main(String args[])throws InterruptedException{
Thread t=new Thread(new Runnable() {
public void run() {
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
System.out.print(“2”);
}
});
t.start();
t.join();
System.out.print(“1”);
}
正确答案: A 你的答案: C (错误)
21
12
可能为12，也可能为21
以上答案都不对

选A
thread.Join把指定的线程加入到当前线程，可以将两个交替执行的线程合并为顺序执行的线程。比如在线程B中调用了线程A的Join()方法，直到线程A执行完毕后，才会继续执行线程B。
t.join(); //使调用线程 t 在此之前执行完毕。
t.join(1000); //等待 t 线程，等待时间是1000毫秒

String str =
“”;
System.out.print(str.split(",").length);
输出结果为：
正确答案: B 你的答案: B (正确)
0
1
出现异常

/** * String split 这个方法默认返回一个数组， * 如果没有找到分隔符， * 会把整个字符串当成一个长度为1的字符串数组 * 返回到结果，所以此处结果就是1 */

private static void testSpringSpilte(){String str = "12,3";String str2 = "123";System.out.print(str.split(",").length);System.out.print(str2.split(",").length);}
}
//结果  2  1

下列关于Java并发的说法中正确的是（）
正确答案: B 你的答案: A (错误)
CopyOnWriteArrayList适用于写多读少的并发场景
ReadWriteLock适用于读多写少的并发场景
ConcurrentHashMap的写操作不需要加锁，读操作需要加锁
只要在定义int类型的成员变量i的时候加上volatile关键字，那么多线程并发执行i++这样的操作的时候就是线程安全的了

A，CopyOnWriteArrayList适用于写少读多的并发场景
B，ReadWriteLock即为读写锁，他要求写与写之间互斥，读与写之间互斥，
读与读之间可以并发执行。在读多写少的情况下可以提高效率
C，ConcurrentHashMap是同步的HashMap，读写都加锁
D，volatile只保证多线程操作的可见性，不保证原子性

下面哪个描述正确? （）
正确答案: A 你的答案: B (错误)
A.echo KaTeX parse error: Can't use function '$' in math mode at position 20: …shell的PID和echo $̲？返回上一个命令的状态 B.…返回上一个命令和echo $的状态？返回登录shell的PID
C.echo $$和echo $？返回一些无意义的整数值
D.所有陈述都是错误的

shell中的特殊变量：
变量名
含义
$0
shell或shell脚本的名字
$*
以一对双引号给出参数列表
$@
将各个参数分别加双引号返回
$#
参数的个数
$_
代表上一个命令的最后一个参数
$$
代表所在命令的PID
$!
代表最后执行的后台命令的PID
$?
代表上一个命令执行后的退出状态 echo $? 如果返回值是0，就是执行成功；如果是返回值是0以外的值，就是失败。

6
Test.main()函数执行后的输出是（）
复制代码class Test {
public static void main(String[] args) {
System.out.println(new B().getValue());
}
static class A {
protected int value;
public A (int v) {
setValue(v);
}
public void setValue(int value) {
this.value= value;
}
public int getValue() {
try {
value ++;
return value;
} finally {
this.setValue(value);
System.out.println(value);
}
}
}
static class B extends A {
public B () {
super(5);
setValue(getValue()- 3);
}
public void setValue(int value) {
super.setValue(2 * value);
}
}
}
正确答案: B 你的答案: C (错误)
6 7 7
22 34 17
22 74 74
11 17 34

思考和解决这个题的主要核心在于对java多态的理解。个人理解时，执行对象实例化过程中遵循多态特性 ==> 调用的方法都是将要实例化的子类中的重写方法，只有明确调用了super.xxx关键词或者是子类中没有该方法时，才会去调用父类相同的同名方法。
Step 1: new B()构造一个B类的实例
此时super(5)语句调用显示调用父类A带参的构造函数，该构造函数调用setValue(v)，这里有两个注意点一是虽然构造函数是A类的构造函数，但此刻正在初始化的对象是B的一个实例，因此这里调用的实际是B类的setValue方法，于是调用B类中的setValue方法 ==> 而B类中setValue方法显示调用父类的setValue方法，将B实例的value值设置为2 x 5 = 10。
紧接着，B类的构造函数还没执行完成，继续执行setValue(getValue()- 3) // 备注1语句。
先执行getValue方法，B类中没有重写getValue方法，因此调用父类A的getValue方法。这个方法比较复杂，需要分步说清楚：
调用getValue方法之前，B的成员变量value值为10。
value++ 执行后， B的成员变量value值为11，此时开始执行到return语句，将11这个值作为getValue方法的返回值返回出去
但是由于getValue块被try finally块包围，因此finally中的语句无论如何都将被执行，所以步骤2中11这个返回值会先暂存起来，到finally语句块执行完毕后再真正返回出去。
这里有很重要的一点：finally语句块中 this.setValue(value)方法调用的是B类的setValue方法。为什么？因为此刻正在初始化的是B类的一个对象（运行时多态），就像最开始第一步提到的一样(而且这里用了使用了this关键词显式指明了调用当前对象的方法)。因此，此处会再次调用B类的setValue方法，同上，super.关键词显式调用A的setValue方法，将B的value值设置成为了2 * 11 = 22。
因此第一个打印项为22。
finally语句执行完毕会把刚刚暂存起来的11 返回出去，也就是说这么经历了这么一长串的处理，getValue方法最终的返回值是11。
回到前面标注了 //备注1 的代码语句，其最终结果为setValue(11-3)=>setValue(8)
而大家肯定也知道，这里执行的setValue方法，将会是B的setValue方法。之后B的value值再次变成了2*8 = 16;
Step2: new B().getValue()
B类中没有独有的getValue方法，此处调用A的getValue方法。同Step 1，
调用getValue方法之前，B的成员变量value值为16。
value++ 执行后， B的成员变量value值为17，此时执行到return语句，会将17这个值作为getValue方法的返回值返回出去
但是由于getValue块被try finally块包围而finally中的语句无论如何都一定会被执行，所以步骤2中17这个返回值会先暂存起来，到finally语句块执行完毕后再真正返回出去。
finally语句块中继续和上面说的一样: this.setValue(value)方法调用的是B类的setValue()方法将B的value值设置成为了2 * 17 = 34。
因此第二个打印项为34。
finally语句执行完毕会把刚刚暂存起来的17返回出去。
因此new B().getValue()最终的返回值是17.
Step3: main函数中的System.out.println
将刚刚返回的值打印出来，也就是第三个打印项：17
最终结果为 22 34 17。 如果朋友们在看的过程中仍然有疑问，可以亲自把代码复制进去ide，在关键语句打下断点，查看调用方法的对象以及运行时的对象值，可以有更深刻的理解。

本地运行结果如下：

（）面向对象程序设计语言不同于其他语言的主要特点。
正确答案: A C D 你的答案: A B C (错误)
继承性
消息传递
多态性
封装性

面向对象的三个基本特征：封装、继承、多态

正确答案: A D 你的答案: C D (错误)
A class can implement more than one interfaces
A class can extend more than one class
An interface has at least one method declared.
An abstract class which has no abstract methods declared is legal

1、一个类可以有多个接口；
2、一个类只能继承一个父类；
3、接口中可以不声明任何方法，和成员变量
interface testinterface{
}
4、抽象类可以不包含抽象方法，但有抽象方法的类一定要声明为抽象类
abstract class abstclass{
abstract void meth();
}

Model-View-Controller(MVC) is an architectural pattern that frequently used in web applications. Which of the following statement(s) is(are) correct?
正确答案: A B C 你的答案: B C (错误)
Models often represent data and the business logics needed to manipulate the data in the application
A view is a (visual) representation of its model. It renders the model into a form suitable for interaction, typically a user interface element
A controller is the link between a user and the system. It accepts input from the user and instructs the model and a view to perform actions based on that input
The common practice of MVC in web applications is, the model receives GET or POST input from user and decides what to do with it, handing over to controller and which hand control to views(HTML-generating components)
None of the above

翻译：
MVC是一种在web应用中常用的架构，下列说法正确的是（）
A. 模型通常代表应用程序中的数据以及用于操纵数据的业务逻辑；
B. 视图是其对应的模型的可视化呈现，视图将模型渲染成适合于交互的形式（通常为用户界面元素）；
C. 控制器是用户与系统之间的纽带，它接受用户输入，并指示模型和视图基于用户输入执行操作（处理数据、展示数据）；
D. MVC模式在web应用中的常见实践是：模型接受来自于用户的GET或POST请求数据并决定如何处理，模型将用户数据转交给控制器，控制器将控制权转交给视图（视图由HTML生成）；
E. 以上全不是。

以下哪些方法可以取到http请求中的cookie值（）?
正确答案: B D 你的答案: B D (正确)
request.getAttribute
request.getHeader
request.getParameter
request.getCookies

下面的方法可用在 Servlet 程序中读取 HTTP 头。这些方法通过 HttpServletRequest 对象可用：
1）Cookie[] getCookies()
返回一个数组，包含客户端发送该请求的所有的 Cookie 对象。
2）Object getAttribute(String name)
以对象形式返回已命名属性的值，如果没有给定名称的属性存在，则返回 null。
3）String getHeader(String name)
以字符串形式返回指定的请求头的值。Cookie也是头的一种；
4）String getParameter(String name)
以字符串形式返回请求参数的值，或者如果参数不存在则返回 null。
发表于 2018-06-24 20:06:24

给定以下方法声明，调用执行mystery（1234）的输出结果？
//precondition: x >=0
public void mystery (int x)
{
System.out.print(x % 10);
if ((x / 10) != 0)
{
mystery(x / 10);
}
System.out.print(x % 10);
}
正确答案: B 你的答案: B (正确)
1441
43211234
3443
12344321

这个题目是考递归，总共调用了4次mystery方法，注意：程序是从上往下执行的，所以当一个方法，调用另一个或本方法时，程序会等调用完毕以后在接着执行
1.第一次调用mystery方法，此时参数（x）为1234,进入第四行，x不变为x=1234，1234%10=4,输出 4.

2.接着进入if语句，1234/10=123 !=0,进入if语句，此时x还是1234,接着第二次调用mystery方法（此时第一次调用的方法不会继续执行，会等第二次（本次）调用的方法执行完毕后继续执行），mystery(x/10),**传入的参数(x)为123,**然后第四行123%10=3,参数还是不变为123，输出 3

3.接着进入if语句，第三次调用mystery()方法（此时第二次调用的方法不会继续执行，会等第三次（本次）调用的方法执行完毕后继续执行），传入参数为123/10=12, x=12,接着第四行12%10=2，传入的参数值不会变，输出 2

4.然后进入if语句12/10!=0,第四次调用mystery()方法（此时第三次调用的方法不会继续执行，会等第四次调用的方法（本次）执行完毕后继续执行），传入的参数（x=1）为1，进入第四行1%10，输出 1

5.然后进入if语句1/10=0不满足if语句x/10 != 0,所以本次不会继续调用mystery方法，然后程序继续执行调用下面的输出参数为1，1%10，输出 1

6.然后第四次调用的方法执行结束然后返回第三次调用的方法继续执行，调用下面的输出，参数为12,x%10=2，输出 2

7.然后第三次调用的方法执行结束然后返回第二次调用的方法继续执行，此时调用下面的输出，参数为123,x%10=3,输出 3

8.最后第二次调用的方法执行结束然后回第一次调用的方法继续执行，此时调用下面的输出，参数为1234,x%10=4,输出 4

9.第一次调用方法结束

一个类可以有多个不同名的构造函数。（）
正确答案: B 你的答案: B (正确)
正确
错误

只有与类名相同的方法可以叫构造函数

下列外部类定义中，不正确的是：（）
正确答案: C 你的答案: C (正确)
class x { … }
class x extends y { … }
static class x implements y1,y2 { … }
public class x extends Applet { … }

内部类可以是静态static的，也可用public，default，protected和private修饰，
外部类的修饰符只能是public，abstract，final
static可以用来修饰内部类,但是不可以用来修饰外部类

以下哪项是错误的（）。
正确答案: A 你的答案: B (错误)
JPanel中不能包含按钮。
Frame 中可以设置Panel。
Applet 中可以包含按钮。
Dialog 中不可以设置菜单条。
以下哪项是错误的（）。
正确答案: A 你的答案: B (错误)
JPanel中不能包含按钮。
Frame 中可以设置Panel。
Applet 中可以包含按钮。
Dialog 中不可以设置菜单条。

JPanel 是 Java图形用户界面(GUI)工具包swing中的面板容器类，包含在javax.swing 包中，是一种轻量级容器，可以加入到JFrame窗体中。JPanel默认的布局管理器是FlowLayout，其自身可以嵌套组合，在不同子容器中可包含其他组件(component),如JButton、JTextArea、JTextField 等，功能是对对窗体上的这些控件进行组合,所以说A是错误的。

下列有关Servlet的生命周期，说法不正确的是？
正确答案: A 你的答案: B (错误)
在创建自己的Servlet时候，应该在初始化方法init()方法中创建Servlet实例
在Servlet生命周期的服务阶段，执行service()方法，根据用户请求的方法，执行相应的doGet()或是doPost()方法
在销毁阶段，执行destroy()方法后会释放Servlet 占用的资源
destroy()方法仅执行一次，即在服务器停止且卸载Servlet时执行该方法
下列不属于算法结构的是（）
正确答案: C 你的答案: A (错误)
输入数据
处理数据
存储数据
输出结果

算法包括0个或多个输入，1个或多个输出，中间有穷个处理过程。
存储结构不属于算法结构

下面有关JAVA swing的描述，说法错误的是？
正确答案: C 你的答案: A (错误)
Swing是一个基于Java的跨平台MVC框架。使用单线程模式。
Swing 是为了解决 AWT 存在的问题而新开发的包，它以 AWT 为基础的
Swing优化了AWT，运行速度比AWT快
Swing是一个基于组件的框架，所有的组件都是从javax.swing.JComponent类继承来的

Swing 是在AWT的基础上构建的一套新的图形界面系统，它提供了AWT 所能够提供的所有功能，并且用纯粹的Java代码对AWT 的功能进行了大幅度的扩充。AWT 是基于本地方法的C/C++程序，其运行速度比较快；Swing是基于AWT 的Java程序，其运行速度比较慢。
编辑于 2015-02-02 16:27:17

以下代码将打印出
public static void main (String[] args) {
String classFile = “com.jd.”. replaceAll(".", “/”) + “MyClass.class”;
System.out.println(classFile);
}
正确答案: C 你的答案: B (错误)
com. jd
com/jd/MyClass.class
///MyClass.class
com.jd.MyClass

C。由于replaceAll方法的第一个参数是一个正则表达式，而".“在正则表达式中表示任何字符，所以会把前面字符串的所有字符都替换成”/"。如果想替换的只是"."，那么久要写成"\.".

已知String a=“a”,String b=“b”,String c=a+b,String d=new String(“ab”) 以下操作结果为true的是
正确答案: A D 你的答案: B (错误)
(a+b).equals©
a+b== c
c==d
c.equals(d)

== 和 equals():
(1) “ == ” 用于比较基本数据类型时比较的是值，用于比较引用类型时比较的是引用指向的地址。
(2)Object 中的equals() 与 “==” 的作用相同，但String类重写了equals()方法，比较的是对象中的内容。
40. 在使用super和this关键字时，以下描述错误的是（）
正确答案: B C D 你的答案: A C (错误)
在子类构造方法中使用super()显示调用父类的构造方法，super()必须写在子类构造方法的第一行，否则编译不通过
super()和this()不一定要放在构造方法内第一行
this()和super()可以同时出现在一个构造函数中
this()和super()可以在static环境中使用，包括static方法和static语句块
在使用super和this关键字时，以下描述错误的是（）
正确答案: B C D 你的答案: A C (错误)

在子类构造方法中使用super()显示调用父类的构造方法，super()必须写在子类构造方法的第一行，否则编译不通过
super()和this()不一定要放在构造方法内第一行
this()和super()可以同时出现在一个构造函数中
this()和super()可以在static环境中使用，包括static方法和static语句块

1、super()表示调用父类构造函数、this()调用自己的构造函数，而自己的构造函数第一行要使用super()调用父类的构造函数，所以这俩不能在一个构造函数中会出现重复引用的情况
2、super()和this()必须在构造函数第一行，所以这一点也表明他俩不能在一个构造函数中
3、this()和super()都指的是对象，所以，均不可以在static环境中使用。包括：static变量,static方法，static语句块(里面不能使用非static类型的)。

如果类的方法没有返回值，该方法的返回类型应是：( )
正确答案: A 你的答案: A (正确)
void
null
abstract
default

返回值一般都是说构造函数，void叫返回值为空

关于抽象类叙述正确的是？ ( )
正确答案: B 你的答案: A (错误)
抽象类不能实现接口
抽象类必须有“abstract class”修饰
抽象类必须包含抽象方法
抽象类也有类的特性，可以被实例化

A.抽象类是可以实现接口的，而且抽象类也可以继承自抽象类
B.对
C.抽象类指有abstract修饰的class，其可以包含抽象方法，也可以不包含
D.抽象类和接口都是不能被实例化的，只有具体的类才可以被实例化

下列代码中的错误是（）

(1) public class Test

(2) {

(3) public static void main(String [] args)

(4) {

(5) int i;

(6) i+=1;

(7) }
(8) }

正确答案: D 你的答案: D (正确)
非法的表达式 i+=1
找不到符号i
类不应为public
尚未初始化变量i

类变量（静态变量）在类加载过程的准备阶段会进行一次赋值，一般是空值或constantValue属性值，同时在初始化阶段会调用类构造器再进行一次赋值。而实例变量在创建对象时会调用实例构造器进行一次赋值。因此无论是类变量还是实例变量，在使用前都是非空的。而局部变量没有初始化过程，在使用前必须赋值。

以下哪个方法用于定义线程的执行体？（）
正确答案: C 你的答案: D (错误)
start()
join()
run()
synchronized()

start（）方法时执行线程
join（）方法是停止当前正在运行的线程，运行该线程，知道结束
run（）方法是线程所执行的方法体
synchronized是同步代码块加锁解锁用的

instanceof运算符能够用来判断一个对象是否为:
正确答案: C 你的答案: B (错误)
一个类的实例
一个实现指定接口的类的实例
全部正确
一个子类的实例

instance是java的二元运算符，用来判断他左边的对象是否为右面类（接口，抽象类，父类）的实例

关于Java语言中的final关键字的使用，下列说法正确的是（）
正确答案: C 你的答案: B (错误)
在使用final关键字定义的方法里面使用final关键字定义变量。
使用final关键字定义变量，必须在变量定义的同时给定变量的具体数值，完成变量初始化。
final关键字可以用来修饰方法，表明此方法不可以被子类重写。
使用final关键字定义变量，必须同时使用static关键字。

A 选项在 final 定义的方法里，不是必须要用 final 定义变量。
B final 定义的变量，可以在不是必须要在定义的同时完成初始化，也可以在构造方法中完成初始化。
C 正确，final修饰方法，不能被子类重写，但是可以被重载。
D final 定义变量，可以用 static 也可以不用。

下面有关JSP内置对象的描述，说法错误的是？
正确答案: C 你的答案: C (正确)
session对象：session对象指的是客户端与服务器的一次会话，从客户连到服务器的一个WebApplication开始，直到客户端与服务器断开连接为止
request对象：客户端的请求信息被封装在request对象中，通过它才能了解到客户的需求，然后做出响应
application对象：多个application对象实现了用户间数据的共享，可存放全局变量
response对象：response对象包含了响应客户请求的有关信息

application对象是共享的，多个用户共享一个，以此实现数据共享和通信
JSP内置对象和属性列举如下：
1.request对象
客户端的请求信息被封装在request对象中，通过它才能了解到客户的需求，然后做出响应。它是HttpServletRequest类的实例。
2.response对象
response对象包含了响应客户请求的有关信息，但在JSP中很少直接用到它。它是HttpServletResponse类的实例。
3.session对象
session对象指的是客户端与服务器的一次会话，从客户连到服务器的一个WebApplication开始，直到客户端与服务器断开连接为止。它是HttpSession类的实例.
4.out对象
out对象是JspWriter类的实例,是向客户端输出内容常用的对象
5.page对象
page对象就是指向当前JSP页面本身，有点象类中的this指针，它是java.lang.Object类的实例
6.application对象
application对象实现了用户间数据的共享，可存放全局变量。它开始于服务器的启动，直到服务器的关闭，在此期间，此对象将一直存在；这样在用户的前后连接或不同用户之间的连接中，可以对此对象的同一属性进行操作；在任何地方对此对象属性的操作，都将影响到其他用户对此的访问。服务器的启动和关闭决定了application对象的生命。它是ServletContext类的实例。
7.exception对象
exception对象是一个例外对象，当一个页面在运行过程中发生了例外，就产生这个对象。如果一个JSP页面要应用此对象，就必须把isErrorPage设为true，否则无法编译。他实际上是java.lang.Throwable的对象
8.pageContext对象
pageContext对象提供了对JSP页面内所有的对象及名字空间的访问，也就是说他可以访问到本页所在的SESSION，也可以取本页面所在的application的某一属性值，他相当于页面中所有功能的集大成者，它的本类名也叫pageContext。
9.config对象
config对象是在一个Servlet初始化时，JSP引擎向它传递信息用的，此信息包括Servlet初始化时所要用到的参数（通过属性名和属性值构成）以及服务器的有关信息（通过传递一个ServletContext对象）

选项中哪一行代码可以替换 //add code here 而不产生编译错误
public abstract class MyClass {
public int constInt = 5;
//add code here
public void method() {
}
}
正确答案: A 你的答案: A (正确)
public abstract void method(int a);
consInt=constInt+5;
public int method();
public abstract void anotherMethod(){}

A是抽象方法，抽象类可以包含抽象方法，也可以不包含，实现重载。（√）
B 在类中不能constInt = constInt + 5（×）
C 返回值不能作为重载的依据（×）
D 有方法体的不能作为抽象函数（×）

AccessViolationException异常触发后，下列程序的输出结果为（）
static void Main(string[] args)
{
try
{
throw new AccessViolationException();
Console.WriteLine(“error1”);
}
catch (Exception e)
{
Console.WriteLine(“error2”);
}
Console.WriteLine(“error3”);
}
正确答案: A 你的答案: D (错误)
error2
error3
error3
error2
error1

1.若catch(){}块中，如果有throw 语句，则，try{}catch(){} finally{}块之外的代码不执行；否则，执行。 2.try{}中有异常，则异常下面代码不执行。 3.finally{}中代码必执行。

下列哪项不属于jdk1.6垃圾收集器？
正确答案: D 你的答案: C (错误)
Serial收集器
parNew收集器
CMS收集器
G1收集器

1.Serial收集器
单线程收集器，收集时会暂停所有工作线程（我们将这件事情称之为Stop The World，下称STW），使用复制收集算法，虚拟机运行在Client模式时的默认新生代收集器。
2.ParNew收集器
ParNew 收集器就是Serial的多线程版本，除了使用多条收集线程外，其余行为包括算法、STW、对象分配规则、回收策略等都与Serial收集器一摸一样。对应的这种收集器是虚拟机运行在Server模式的默认新生代收集器，在单CPU的环境中，ParNew收集器并不会比Serial收集器有更好的效果。
3.Parallel Scavenge收集器
Parallel Scavenge收集器（下称PS收集器）也是一个多线程收集器，也是使用复制算法，但它的对象分配规则与回收策略都与ParNew收集器有所不同，它是以吞吐量最大化（即GC时间占总运行时间最小）为目标的收集器实现，它允许较长时间的STW换取总吞吐量最大化。
4.Serial Old收集器
Serial Old是单线程收集器，使用标记－整理算法，是老年代的收集器，上面三种都是使用在新生代收集器。
5.Parallel Old收集器
老年代版本吞吐量优先收集器，使用多线程和标记－整理算法，JVM 1.6提供，在此之前，新生代使用了PS收集器的话，老年代除Serial Old外别无选择，因为PS无法与CMS收集器配合工作。
6.CMS（Concurrent Mark Sweep）收集器
CMS 是一种以最短停顿时间为目标的收集器，使用CMS并不能达到GC效率最高（总体GC时间最小），但它能尽可能降低GC时服务的停顿时间，这一点对于实时或者高交互性应用（譬如证券交易）来说至关重要，这类应用对于长时间STW一般是不可容忍的。CMS收集器使用的是标记－清除算法，也就是说它在运行期间会产生空间碎片，所以虚拟机提供了参数开启CMS收集结束后再进行一次内存压缩。

下面程序的运行结果（）
Object obj=new Object();
List aList=new ArrayList();
List bList=new LinkedList();
long t1=System.currentTimeMillis();
for(int i=0;i<50000;i++){
aList.add(0,obj);
}
long t2=System.currentTimeMillis()-t1;
t1=System.currentTimeMillis();
for(int i=0;i<50000;i++){
bList.add(0,obj);
}
long t3=System.currentTimeMillis()-t1;
正确答案: D 你的答案: D (正确)
t2
t2=t3
不确定
t2>t3

ArrayList内部是动态数组实现，在增加空间时会复制全部数据到新的容量大一些的数组中。而LinkedList内部为双向链表，可以按需分配空间，扩展容量简单，因此LinkedList用时少

下面代码的输出是什么？
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();
}
}

正确答案: A 你的答案: C (错误)
null
sub
base

new Sub();在创造派生类的过程中首先创建基类对象，然后才能创建派生类。
创建基类即默认调用Base()方法，在方法中调用callName()方法，由于派生类中存在此方法，则被调用的callName（）方法是派生类中的方法，此时派生类还未构造，所以变量baseName的值为null

What will happen when you attempt to compile and run the following code?
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;
}
}

正确答案: D 你的答案: D (正确)
compiletime error
prints:1
prints:2
prints:3
prints:7
prints:8

D
1.静态语句块中x为局部变量，不影响静态变量x的值
2.x和y为静态变量，默认初始值为0，属于当前类，其值得改变会影响整个类运行。
3.java中自增操作非原子性的
main方法中：
执行x–后 x=-1
调用myMethod方法，x执行x++结果为-1(后++)，但x=0，++x结果1，x=1 ，则y=0
x+y+ ++x,先执行x+y，结果为1，执行++x结果为2，得到最终结果为3

在Java中，对于不再使用的内存资源，如调用完成的方法，“垃圾回收器”会自动将其释放。（）
正确答案: B 你的答案: A (错误)
正确
错误

方法调用时，会创建栈帧在栈中，调用完是程序自动出栈释放，而不是gc释放

关于AWT和Swing说法正确的是？
正确答案: D 你的答案: D (正确)
Swing是AWT的子类
AWT在不同操作系统中显示相同的风格
AWT不支持事件类型，Swing支持事件模型
Swing在不同的操作系统中显示相同的风格

AWT，抽象窗口工具包，是Java提供的建立图形用户界面的工具集，可用于生成现代的、鼠标控制的图形应用接口，且无需修改，就可以在各种软硬件平台上运行。
而swing是Java语言在编写图形用户界面方面的新技术，Swing采用模型-视图-控制设计范式，Swing可以使Java程序在同一个平台上运行时能够有不同外观以供用户选择。
两者不同在于一个是初代工具集，一个是进化版的工具集，用户不会再满足于初始的功能，而是更加注重于附加价值，明显从这点上，Swing是比AWT要好很多。
写法上，Swing的头文件引用包需要用到Javax，组件调用时也需要在AWT的基础上加上“J”。

已知 boolean result = false，则下面哪个选项是合法的：
正确答案: B D 你的答案: B D (正确)
result=1
result=true;
if(result!=0) {//so something…}
if(result) {//do something…}

1、boolean类型只有两个直接量值:true和false.
2、除成员变量会有默认初始值外，其他变量必须在第一次使用之前初始化

面向对象的程序设计语言具有（）等共同特性。
正确答案: A B E 你的答案: A B E (正确)
封装性
多态性
简单性
复杂性
继承性

如java中的import java.util.*; 就很好地体现了其中一个特性：封装性，隐藏内部功能的具体实现，只保留和外部交流数据的借口。然后就是多态性，即同一个动作作用不同的对象产生不同的具体行为，具体来说，可以用"一个对外接口，多个内在实现方法"表示。最后还有一个继承性，子类可以继承父类的方法和变量，然后调用。

A,B,C,D 中哪些是 setvar的重载？
public class methodover
{
public void setVar(int a, int b, float c) {}
}

正确答案: A C D 你的答案: B C (错误)
private void setVar(int a， float c， int b){}
protected void setVar(int a， int b， float c){}
public int setVar(int a， float c， int b){return a;}
public int setVar(int a， float c){return a;}
重载是在同一个类中，有多个方法名相同，参数列表不同(参数个数不同，参数类型不同),与方法的返回值无关，与权限修饰符无关，B中的参数列表和题目的方法完全一样了。
59. 执行如下程序代码
char chr = 127;
int sum = 200;
chr += 1;
sum += chr;
后，sum的值是 ; （）
备注：同时考虑c/c++和Java的情况的话
正确答案: A C 你的答案: C (错误)
72
99
328
327

java中只有byte, boolean是一个字节, char是两个字节, 所以对于java来说127不会发生溢出, 输出328
但是对于c/c++语言来说, char是一个字节, 会发生溢出, 对127加一发生溢出, 0111 1111 --> 1000 0000, 1000 0000为补码-128, 所以结果为200-128=72

java中 String str = "hello world"下列语句错误的是？
正确答案: A B C 你的答案: A B (错误)
str+=’ a’
int strlen = str.length
str=100
str=str+100

ABC在java中会报错，D可以正常运行, 所以答案是ABC.
A. ‘a’是字符,’ a’这个是空格和a，必须要用" a"才可以;
B.String有length()方法
C.int 无法直接转成String类型
D.尾部添加字符串”100“

StringBuffer类对象创建之后可以再修改和变动.
正确答案: A 你的答案: B (错误)
正确
错误

1.String对象不可变、StringBuffer对象可变的含义：举个例子：String str = “aa”; str = “aa”+“bb”; 此时str的值为"aabb"，但是"aabb"不是在开始的字符串"aa"后面直接连接的"bb"，而是又新生成了字符串"aabb"，字符串"aa"一旦被初始化，那么它的值不可能再改变了。 StringBuffer strb = StringBuffer(“aa”); strb.append(“bb”); 此时的strb的值也为"aabb"，但是"aabb"是直接在开始的字符串"aa"后面连接的“bb”，并没有生成新的字符串。

关键字()表明一个对象或变量的引用在初始化后不能被修改。
正确答案: B 你的答案: B (正确)
private
final
static
没有这种关键字

final修饰变量的本质就是：修饰的变量值(地址或内容)无法改变。

在java中，无论在何处调用，使用静态属性必须以类名做前缀。
正确答案: B 你的答案: B (正确)
正确
错误

在静态类里面调用类成员变量，不需要类名前缀

下面有关java的一些细节问题，描述错误的是？
正确答案: B 你的答案: B (正确)
构造方法不需要同步化
一个子类不可以覆盖掉父类的同步方法
定义在接口中的方法默认是public的
容器保存的是对象的引用

C选项，接口中的方法默认都是public static final，这是JAVA8的规定。
D选项不用更多解释了，当然是正确的

以下程序段执行后将有（）个字节被写入到文件afile.txt中。
try {
FileOutputStream fos = new FileOutputStream(“afile.txt”);
DataOutputStream dos = new DataOutputStream(fos);
dos.writeInt(3);
dos.writeChar(1);
dos.close();
fos.close();
} catch (IOException e) {}

正确答案: C 你的答案: B (错误)
3
5
6
不确定，与软硬件环境相关

这题的关键是DataOutputStream,这个是直接把字节码写入文件的输出流，和编码没有关系，因为根本没有转成字符。所以直接4+2就行了

面向对象方法的多态性是指（）
正确答案: C 你的答案: A (错误)
一个类可以派生出多个特殊类
一个对象在不同的运行环境中可以有不同的变体
针对一消息，不同的对象可以以适合自身的方式加以响应
一个对象可以是由多个其他对象组合而成的

相同类型的变量、调用同一个方法时呈现出多种不同的行为特征，这就是多态。

下面有关servlet service描述错误的是？
正确答案: B 你的答案: C (错误)
不管是post还是get方法提交过来的连接，都会在service中处理
doGet/doPost 则是在 javax.servlet.GenericServlet 中实现的
service()是在javax.servlet.Servlet接口中定义的
service判断请求类型，决定是调用doGet还是doPost方法

doGet/doPost 则是在 javax.servlet.http.HttpServlet 中实现的

对文件名为Test.java的java代码描述正确的是()
class Person {
String name = “No name”;
public Person(String nm) {
name = nm;
}
}
class Employee extends Person {
String empID = “0000”;
public Employee(String id) {
empID = id;
}
}
public class Test {
public static void main(String args[]) {
Employee e = new Employee(“123”);
System.out.println(e.empID);
}
}
正确答案: C 你的答案: D (错误)
输出：0000
输出：123
编译报错
输出：No name

子类的构造方法总是先调用父类的构造方法，如果子类的构造方法没有明显地指明使用父类的哪个构造方法，子类就调用父类不带参数的构造方法。
而父类没有无参的构造函数，所以子类需要在自己的构造函数中显示的调用父类的构造函数。

下面哪个方法与Applet的显示无关？
正确答案: A 你的答案: D (错误)
draw
paint
repaint
update

Applet显示相关的方法主要有3个。

paint(Graphicsg)方法，具体执行Applet的绘制。
update(Graphicsg)()方法，主要用于更新Applet的显示。
repaint()方法，主要用于Applet的重新显示，它调用update()方法实现对Applet的更新。
而draw()方法与显示无关，故选A draw
下列代码输出结果为（）
class Animal{
public void move(){
System.out.println(“动物可以移动”);
}
}
class Dog extends Animal{
public void move(){
System.out.println(“狗可以跑和走”);
}
public void bark(){
System.out.println(“狗可以吠叫”);
}
}
public class TestDog{
public static void main(String args[]){
Animal a = new Animal();
Animal b = new Dog();
a.move();
b.move();
b.bark();
}
}
正确答案: D 你的答案: A (错误)
动物可以移动
狗可以跑和走
狗可以吠叫
动物可以移动
动物可以移动
狗可以吠叫
运行错误
编译错误

当用Dog对象初始化Animal类对象时，完成了对Animal对象中方法与变量的覆盖与隐藏，也就是b.move()调用的是Dog中move()方法。而Animal中本身并没有bark()方法，不存在被覆盖的情况，亦无法访问，也就是b.bark()会报错。

在Java中，main()方法的返回值的类型是：
确答案: C 你的答案: C (正确)
public
static
void
String

main方法的格式讲解：
public static void main(String[] args) {…}
public:公共的，访问权限是最大的。由于main方法是被jvm调用，所以权限要够大。
static:静态的，不需要创建对象，通过类名就可以。方便jvm的调用。
void:方法的返回值是返回给调用者，而main方法是被jvm调用。你返回内容给jvm没有意义。
main:是一个常见的方法入口。我见过的语言都是以main作为入口。
String[] args:这是一个字符串数组。这个东西早期是为了接收键盘录入的数据的。

以下代码的循环次数是
public class Test {
public static void main(String args[]) {
int i = 7;
do {
System.out.println(–i);
–i;
} while (i != 0);
System.out.println(i);
}
}
正确答案: D 你的答案: D (正确)
0
1
7
无限次

执行1次，输出是6，然后再减1为5进行while判定不为o再进入do
执行2次，输出是4，然后再减1为3进行while判定不为o再进入do
执行3次，输出是2，然后再减1为1进行while判定不为o再进入do
执行4次，输出是0，然后再减1为-1进行while判定不为o再进入do
永远执行不到0

下面关于垃圾收集的说法正确的是
正确答案: D 你的答案: D (正确)
一旦一个对象成为垃圾，就立刻被收集掉。
对象空间被收集掉之后，会执行该对象的finalize方法
finalize方法和C++的析构函数是完全一回事情
一个对象成为垃圾是因为不再有引用指着它，但是线程并非如此

1、在java中，对象的内存在哪个时刻回收，取决于垃圾回收器何时运行。
2、一旦垃圾回收器准备好释放对象占用的存储空间，将首先调用其finalize()方法，并且在下一次垃圾回收动作发生时，才会真正的回收对象占用的内存（《java 编程思想》）
3、在C++中，对象的内存在哪个时刻被回收，是可以确定的，在C++中，析构函数和资源的释放息息相关，能不能正确处理析构函数，关乎能否正确回收对象内存资源。
在java中，对象的内存在哪个时刻回收，取决于垃圾回收器何时运行，在java中，所有的对象，包括对象中包含的其他对象，它们所占的内存的回收都依靠垃圾回收器，因此不需要一个函数如C++析构函数那样来做必要的垃圾回收工作。当然存在本地方法时需要finalize()方法来清理本地对象。在《java编程思想》中提及，finalize()方法的一个作用是用来回收“本地方法”中的本地对象

以下代码的输出的正确结果是
public class Test {
public static void main(String args[]) {
String s = “祝你考出好成绩！”;
System.out.println(s.length());
}
}
正确答案: D 你的答案: D (正确)
24
16
15
8
JVM内存不包含如下哪个部分( )
正确答案: D 你的答案: A (错误)
Stacks
PC寄存器
Heap
Heap Frame

Stacks: JVM中有虚拟机栈和本地方法栈，都属于栈
PC寄存器: 即程序计数器，用来记录程序执行过程中的将要执行的下一条指令的行号
Heap：堆，这个不用说
Heap Frame：翻译过来堆帧？对不起我只听说过栈帧（Stack Frame）

下面有个hibernate延迟加载，说法错误的是？
正确答案: C 你的答案: B (错误)
Hibernate2延迟加载实现：a)实体对象 b)集合（Collection）
Hibernate3 提供了属性的延迟加载功能
get支持延迟加载，load不支持延迟加
hibernate使用Java反射机制，而不是字节码增强程序来实现透明性

Hibernate 中 get()和load() 的区别：
1.get()采用立即加载方式,而load()采用延迟加载 ; get()方法执行的时候,会立即向数据库发出查询语句, 而load()方法返回的是一个***(此***中只有一个id属性),只有等真正使用该对象属性的时候,才会发出 sql语句 2.如果数据库中没有对应的记录,get()方法返回的是null.而load()方法出现异常ObjectNotFoundException

下面关于Java package的描述，哪个是正确的:（）
I. 包不提供将所有类名分区为更易管理的块的机制.
II. 包提供可见性控制机制.
III. 包的一个重要属性是包内定义的所有类都可以通过该包外的代码访问.
IV. 声明为包的一部分的类的.class文件可以存储在多个目录中.
正确答案: B 你的答案: D (错误)
只有I
只有II
只有III
只有IV

为了更好地组织类，Java 提供了包机制，用于区别类名的命名空间。
包的作用
1、把功能相似或相关的类或接口组织在同一个包中，方便类的查找和使用。
2、如同文件夹一样，包也采用了树形目录的存储方式。同一个包中的类名字是不同的，不同的包中的类的名字是可以相同的，当同时调用两个不同包中相同类名的类时，应该加上包名加以区别。因此，包可以避免名字冲突。
3、包也限定了访问权限，拥有包访问权限的类才能访问某个包中的类。
Java 使用包（package）这种机制是为了防止命名冲突，访问控制，提供搜索和定位类（class）、接口、枚举（enumerations）和注释（annotation）等。

对下面Spring声明式事务的配置含义的说明错误的是（）

<bean id="txProxyTemplate" abstract="true"
class=
"org.springframework.transaction.interceptor.TransactionProxyFactoryBean"><property name="transactionManager" ref="myTransactionManager" />
<property name="transactionAttributes">      <props><prop key="get*">PROPAGATION_REQUIRED,readOnly</prop><prop key="*">PROPAGATION_REQUIRED</prop></props>
</property>
</bean>

正确答案: C 你的答案: C (正确)
定义了声明式事务的配置模板
对get方法采用只读事务
缺少sessionFactory属性的注入
配置需要事务管理的bean的代理时，通过parent引用这个配置模板，代码如下：
<bean id="petBiz" parent="txProxyTemplate">
<property name="target" ref="petTarget"/>
</bean>

sessionFactory只有使用Hibernate才需要注入，并且是注入到事务管理器的，所以c错

由3 个“1”和 5 个“0”组成的 8 位二进制补码，能表示的最小整数（）
正确答案: B 你的答案: D (错误)
-126
-125
-32
-3

既然求最小整数，那肯定先想到负数，则最高位（符号位）一定为1，原码中肯定是1所在的位数越高，值越小，而补码是由原码取反加1得到的，则在补码中1所在的位数一定要越低，即补码为1000 0011；由补码求得原码：1111 1101=-(64+32+16+8+4+1)=-125;

关于Java语言描述正确的是？ ( )
正确答案: B 你的答案: B (正确)
java和C++都保留了指针
java和C++都有三个特征：封装、继承和多态
java的垃圾回收机制是指程序结束时系统自动回收内存
以上说法都不正确

java丢弃了指针。
java的立即回收不是程序结束后回收垃圾，在程序过程中就会，如对象呗赋值NULL，该对象就成为可回收对象。

在java7中,下列哪个说法是正确的:
正确答案: D 你的答案: B (错误)
ConcurrentHashMap使用synchronized关键字保证线程安全
HashMap实现了Collection接口
Arrays.asList方法返回java.util.ArrayList对象
SimpleDateFormat对象是线程不安全的

hashMap在单线程中使用大大提高效率，在多线程的情况下使用hashTable来确保安全。hashTable中使用synchronized关键字来实现安全机制，但是synchronized是对整张hash表进行锁定即让线程独享整张hash表，在安全同时造成了浪费。concurrentHashMap采用分段加锁的机制来确保安全

Which method you define as the starting point of new thread in a class from which n thread can be execution?
正确答案: B 你的答案: B (正确)
public void start()
public void run()
public void int()
public static void main(String args[])
public void runnable()

要写一个线程类，可以继承Thread方法，然后override他的run（）方法
另一种方法是实现Runable接口，即为实现run（）方法。
A，start（）是启动一个线程的方法

如何获取ServletContext设置的参数值？
正确答案: B 你的答案: D (错误)
context.getParameter()
context.getInitParameter()
context.getAttribute()
context.getRequestDispatcher()

getParameter()是获取POST/GET传递的参数值；
getInitParameter获取Tomcat的server.xml中设置Context的初始化参数
getAttribute()是获取对象容器中的数据值；
getRequestDispatcher是请求转发。

检查程序，是否存在问题，如果存在指出问题所在，如果不存在，说明输出结果。
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++;
}
}
正确答案: A 你的答案: B (错误)
0
1
2
3
以下哪几种是java的基本数据类型。
正确答案: B C 你的答案: A B C (错误)
String
int
boolean
Double

java 8中基本数据类型：byte，short，int，long，double，float，boolean，char

16
servlet周期包含哪些：
正确答案: A B C 你的答案: A B (错误)
初始化
销毁
请求处理
开始

init() --> 初始化
service() --> 处理请求
destory () --> 销毁（停止）

以下关于对象序列化描述正确的是
正确答案: C D 你的答案: A D (错误)
使用FileOutputStream可以将对象进行传输
使用PrintWriter可以将对象进行传输
使用transient修饰的变量不会被序列化
对象序列化的所属类需要实现Serializable接口

使用ObjectOutputStream和ObjectInputStream可以将对象进行传输.
声明为static和transient类型的成员数据不能被串行化。因为static代表类的状态， transient代表对象的临时数据。

JavaWEB中有一个类，当会话种邦定了属性或者删除了属性时，他会得到通知，这个类是：( )
正确答案: A 你的答案: A B (错误)
HttpSessionAttributeListener
HttpSessionBindingListener
HttpSessionObjectListener
HttpSessionListener;
HttpSession
HttpSessionActivationListener

HttpSessionAttributeListener：可以实现此侦听器接口获取此web应用程序中会话属性列表更改的通知；
HttpSessionBindingListener：当该对象从一个会话中被绑定或者解绑时通知该对象，这个对象由HttpSessionBindingEvent对象通知。这可能是servlet程序显式地从会话中解绑定属性的结果，可能是由于会话无效，也可能是由于会话超时；
HttpSessionObjectListener：没有该接口API；
HttpSessionListener：当web应用程序中的活动会话列表发生更改时通知该接口的实现类，为了接收该通知事件，必须在web应用程序的部署描述符中配置实现类；
HttpSessionActivationListener：绑定到会话的对象可以侦听容器事件，通知它们会话将被钝化，会话将被激活。需要一个在虚拟机之间迁移会话或持久会话的容器来通知所有绑定到实现该接口会话的属性。

下列有关JAVA异常处理的叙述中正确的是（）
正确答案: A B D 你的答案: C (错误)
finally是为确保一段代码不管是否捕获异常都会被执行的一段代码
throws是用来声明一个成员方法可能抛出的各种非运行异常情况
final用于可以声明属性和方法，分别表示属性的不可变及方法的不可继承
throw是用来明确地抛出一个异常情况

A：明显正确，不懂的可以去看看网上博客
B：throws是用来声明一个成员方法可能抛出的各种异常情况，错误！因为很多运行时异常，不会显示的抛出（当然你愿意的话，也可以，只不过你的代码会乱成翔）
C：final用于可以声明属性和方法，分别表示属性的不可变及方法的不可覆盖。不是方法的不可继承
D：throw是用来明确地抛出一个异常情况。错误，throw不仅仅可以抛出异常，还可以抛出Error以及Throwable.
感觉正确可以点赞，谢谢大家~

判断一块内存空间是否符合垃圾收集器收集的标准有哪些？
正确答案: A B D 你的答案: A C (错误)
给对象赋予了空值null,以下再没有调用过
对象重新分配了内存空间
给对象赋予了空值null
给对象赋予了新值

在java语言中，判断一块内存空间是否符合垃圾收集器收集标准的标准只有两个：
1.给对象赋值为null，以下没有调用过。
2.给对象赋了新的值，重新分配了内存空间。

牛客网_java选择题相关推荐

牛客网Java选择题练习
牛客网Java选择题练习 2021/1/12 2021/1/13 2021/1/14 2021/1/16 2021/1/17 2021/1/18 2021/1/20 2021/1/21 2021/1/ ...
2022-05-18 牛客网每日选择题--前端
写文章还是得坚持呀,养成习惯不容易.我决定从今天开始,保持每周都更新4-5次,你们给大家分享一些选择题的知识点.如果我没做到,你们骂我,随便骂哈哈哈在3月开始,博主进行了前端面试相关知识的复习,对前 ...
牛客网_Go语言相关练习_选择题（2）
注:题目来源均出自牛客网. 一.选择题 Map(集合)属于Go的内置类型,不需要引入其它库即可使用. Go-Map_菜鸟教程在函数声明中,返回的参数要么都有变量名,要么都没有. C选项函数声明语法有 ...
【牛客网】---多态经典选择题
[牛客网] 多态经典选择题引言:今天在牛客网刷题时遇到了三个很经典的关于继承和多态的选择题,想在这里和大家一起分享一下思路和心得体会. 注:在这里我们注意到virtual函数是动态绑定,而C++编译 ...
【百日冲大厂】第十篇,牛客网选择题+编程题井字棋+密码强度等级
前言: 大家好,我是良辰丫,刷题的第十篇,牛客网选择题+编程题井字棋+密码强度等级.
【百日冲大厂】第二篇,牛客网选择题+排序子序列+倒置字符串
前言: 大家好,我是良辰丫,今天是刷题的第二篇,牛客网选择题+排序子序列+倒置字符串,每天都去努力,每天都庆幸今天的自己比昨天的自己更优秀,加油,为理想而努力吧!!!
运维校招面经汇总（来源牛客网）
shopee SRE 作者:Stackingrule 链接:https://www.nowcoder.com/discuss/626107?source_id=discuss_experience_n ...
【牛客网】树根与星际密码
目录一.编程题 1.树根 2.星际密码二.选择题一.编程题 1.树根链接:数根__牛客网 (nowcoder.com) 数根可以通过把一个数的各个位上的数字加起来得到.如果得到的数是一位数,那 ...
牛客网-数量关系练习
牛客网-练习 1.16 ,17 ,36 ,111 ,448 ,( ) 正确答案: C 你的答案: C (正确) 639 758 2245 3465 解: 161+1=17 172+2=36 363+3 ...

牛客网_java选择题

牛客网_java选择题相关推荐

最新文章

热门文章