Java选择题

题目均来自与牛客网

第一期Java选择题

1.把表示范围大的数转换为表示范围小的数，需要强制类型转换
、

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


5.web.xml文件是用来初始化配置信息，web.xml是放置在WEB-INF目录中

A.由于y的值不确定，所以要加锁；
B,C 两个在多线程情况下是必须要加锁的，因为他们是先被读入寄存器，然后再进行+1操作，如果没有加锁，那么可能会出现数据异常；
D 原子操作，所以不需要加锁
原子性：指该操作不能再继续划分为更小的操作。
Java中的原子操作包括：
1、除long和double之外的基本类型的赋值操作
2、所有引用reference的赋值操作
3、java.concurrent.Atomic.* 包中所有类的一切操作

第二期Java选择题

1.解析：javadoc 用来识别注释
javac 用来识别代码
二者互不影响
2.解析：private修饰的东西，只是不能在别的类中访问，但是本类中还是可以的。同时利用反射也可以做到。
3.解析：根据定义
4.



![在这里插入图片描述](https://img-blog.csdnimg.cn/20210119124639374.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MTE3ODEyOQ==,size_16,color_FFFFFF,t在这里插入图片描述

第三期Java选择练习题

1.解析:根据概念
2.解析：定义
3.

第四期Java选择题

1.解析：堆栈是具有先进后出的特点，队列具有先进先出的特点。字符串是一个存储数据的结构，没有严格的出入要求，迭代器的数据读取取决于迭代方式。
4.解析：

编译后的程序尺寸即class文件大小
过多注释影响编译效率，影响合作开发效率
注释不会影响class文件的执行效率 

5.解析：英文Mouse
8.解析： java.lang包包含

包装类
String 类
Math 类     ——    包含函数
Class 类
Object 类

10，解析：t.run是调用的Thead类中的run()方法，t.start才是执行线程，所以这题就是执行普通run()方法，先输出pong，在输出ping。
16.Thread. sleep()是否会抛出checked exception?
答案：会
解析：Thread.sleep() 和 Object.wait(),都可以抛出 InterruptedException。这个异常是不能忽略的,因为它是一个检查异常(checked exception)
17.以下叙述正确的是（D）
A.实例方法可直接调用超类的实例方法
B.实例方法可直接调用超类的类方法、
C.实例方法可直接调用子类的实例方法
D.实例方法可直接调用本类的实例方法
解析： A错误，类的实例方法是与该类的实例对象相关联的，不能直接调用，只能通过创建超类的一个实例对象，再进行调用
B错误，当父类的类方法定义为private时，对子类是不可见的，所以子类无法调用
C错误，子类具体的实例方法对父类是不可见的，所以无法直接调用， 只能通过创建子类的一个实例对象，再进行调用
D正确，实例方法可以调用自己类中的实例方法
18. 对于同一类中的两个方法 , 在判断它们是不是重载方法时 , 肯定不考虑（ 返回值类型）
解析： 方法的重载：
方法重载的定义：同一个类或与他的派生类中，方法名相同，而参数列表不同的方法。其中参数列表不同指的是参数的类型，数量，类型的顺序这三种至少有一种不同。
方法重载与下列无关：
与返回值类型无关；与访问修饰符无关
构造方法也可以重载

方法的重写：
方法的重写的定义：在继承关系的子类中，定义一个与父类相同的方法
判断是否重写的方式：在方法之前加上@ Overri de
方法重写的特点：
在继承关系的子类中重写父类的方法
重写的方法必须方法名相同，参数列表也相同
重写的方法的返回值类型应该与父类中被重写方法的返回值类型相同或是他的子类类型
重写的方法的访问权限应该与父类中被重写方法的访问权限相同或高于它的访问权限
重写的方法不能抛出比父类更加宽泛的异常
方法重写的注意事项：
构造方法不能被重写，不要问为什么？因为构造方法名必须和类名相同
private修饰的成员方法不能被重写
static修饰的方法不能被重写
final修饰的方法不能被重写
当子类重写了父类中的方法后，子类对象调用该方法时调用的是子类重写后的方法

19.下面有关JSP内置对象的描述，说法错误的是？

A.session对象：session对象指的是客户端与服务器的一次会话，从客户连到服务器的一个WebApplication开始，直到客户端与服务器断开连接为止

B.request对象：客户端的请求信息被封装在request对象中，通过它才能了解到客户的需求，然后做出响应

C.application对象：多个application对象实现了用户间数据的共享，可存放全局变量

D.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对象）
20. 关于访问权限说法正确 的是 ？ ( B)

A.外部类前面可以修饰public,protected和private

B.成员内部类前面可以修饰public,protected和private

C.局部内部类前面可以修饰public,protected和private

D.以上说法都不正确
解析：21.在一个基于分布式的游戏服务器系统中，不同的服务器之间，哪种通信方式是不可行的（A）？

A.管道

B.消息队列

C.高速缓存数据库

D.套接字
解析： 22.关于Java语言描述正确的是？ (B )

A.java和C++都保留了指针

B.java和C++都有三个特征：封装、继承和多态

C.java的垃圾回收机制是指程序结束时系统自动回收内存

D.以上说法都不正确
解析： A，Java没有指针，只有引用。
C，并不是程序结束的时候进行GC，GC的时间是不确定的，且GC的过程需要经过可达性分析，一个对象只有被标记两次才会被GC。
下图是一个对象被GC的全过程。
23.以下哪项不属于java类加载过程？B

A.生成java.lang.Class对象

B.int类型对象成员变量赋予默认值

C.执行static块代码

D.类方法解析

解析： 类的加载包括：加载，验证，准备，解析，初始化。
选项A：生成java.lang.Class对象是在加载时进行的。生成Class对象作为方法区这个类的各种数据的访问入口。
选项B：既然是对象成员，那么肯定在实例化对象后才有。在类加载的时候会赋予初值的是类变量，而非对象成员。
选项C：这个会调用。可以用反射试验。
选项D：类方法解析发生在解析过程。
24.下面有关servlet service描述错误的是？B

A.不管是post还是get方法提交过来的连接，都会在service中处理

B.doGet/doPost 则是在 javax.servlet.GenericServlet 中实现的

C.service()是在javax.servlet.Servlet接口中定义的

D.service判断请求类型，决定是调用doGet还是doPost方法
解析：25.下面属于java引用类型的有？AD

A.String

B.byte

C.char

D.Array
解析： java语言是强类型语言，支持的类型分为两类：基本类型和引用类型。
基本类型包括boolean类型和数值类型，数值类型有整数类型和浮点类型。整数类型包括：byte、short、int、long和char；浮点类型包括：float和double
引用类型包括类、接口和数组类型以及特殊的null类型。
26.下面代码的运行结果为：（C）

import java.io.;
import java.util.;
public class foo{
public static void main (String[] args){
String s;
System.out.println(“s=” + s);
}
}

A.代码得到编译，并输出“s=”

B.代码得到编译，并输出“s=null”

C.由于String s没有初始化，代码不能编译通过

D.代码得到编译，但捕获到 NullPointException异常
27.Why would a responsible Java programmer want to use a nested class?AB

A.To keep the code for a very specialized class in close association with the class it works with.

B.To support a new user interface that generates custom events.

C.To impress the boss with his/her knowledge of Java by using nested classes all over the place.
28.
jdk1.8中，下面有关java 抽象类和接口的区别，说法错误的是？BD

A.抽象类可以有构造方法，接口中不能有构造方法

B.抽象类中可以包含非抽象的普通方法，接口中的方法必须是抽象的，不能有非抽象的普通方法

C.一个类可以实现多个接口，但只能继承一个抽象类

D.接口中可以有普通成员变量，抽象类中没有普通成员变量
解析：
抽象类
特点:
1.抽象类中可以构造方法
2.抽象类中可以存在普通属性，方法，静态属性和方法。
3.抽象类中可以存在抽象方法。
4.如果一个类中有一个抽象方法，那么当前类一定是抽象类；抽象类中不一定有抽象方法。
5.抽象类中的抽象方法，需要有子类实现，如果子类不实现，则子类也需要定义为抽象的。
接口
1.在接口中只有方法的声明，没有方法体。
2.在接口中只有常量，因为定义的变量，在编译的时候都会默认加上
public static final
3.在接口中的方法，永远都被public来修饰。
4.接口中没有构造方法，也不能实例化接口的对象。
5.接口可以实现多继承
6.接口中定义的方法都需要有实现类来实现，如果实现类不能实现接口中的所有方法
7.则实现类定义为抽象类。

29.在Java中下面Class的声明哪些是错误的？ABC

A.public abstract final class Test {
abstract void method();
}

B.public abstract class Test {
abstract final void method();
}

C.public abstract class Test {
abstract void method() {
}
}

D.public class Test {
final void method() {

}
}
解析： A、final修饰的类为终态类，不能被继承，而 抽象类是必须被继承的才有其意义的，因此，final是不能用来修饰抽象类的。
B、 final修饰的方法为终态方法，不能被重写。而继承抽象类，必须重写其方法。
C、抽象方法是仅声明，并不做实现的方法。
30.JavaWEB中有一个类，当会话种邦定了属性或者删除了属性时，他会得到通知，这个类是：( A )

A.HttpSessionAttributeListener

B.HttpSessionBindingListener

C.HttpSessionObjectListener

D.HttpSessionListener;

E.HttpSession

F.HttpSessionActivationListener
解析： HttpSessionAttributeListener：可以实现此侦听器接口获取此web应用程序中会话属性列表更改的通知；

HttpSessionBindingListener：当该对象从一个会话中被绑定或者解绑时通知该对象，这个对象由HttpSessionBindingEvent对象通知。这可能是servlet程序显式地从会话中解绑定属性的结果，可能是由于会话无效，也可能是由于会话超时；

HttpSessionObjectListener：没有该接口API；

HttpSessionListener：当web应用程序中的活动会话列表发生更改时通知该接口的实现类，为了接收该通知事件，必须在web应用程序的部署描述符中配置实现类；

HttpSessionActivationListener：绑定到会话的对象可以侦听容器事件，通知它们会话将被钝化，会话将被激活。需要一个在虚拟机之间迁移会话或持久会话的容器来通知所有绑定到实现该接口会话的属性。

第五期

1.下面程序段执行完成后，则变量sum的值是( B )。

int b[][]={{1}, {2,2}, {2,2,2}};

int sum=0;

for(int i=0;i<b.length;i++) {

for(int j=0;j<b[i].length;j++) {

    sum+=b[i][j];

}

}
A.32
B.11
C.2
D.3
解析：B 把每个数组的数加在一块
2.类Car里面有个方法run()，如果直接用Car.run()，则方法run前面必须用的关键词是？ ( D)
A.class
B.final
C.public
D.static
解析：被sataic声明的为静态方法，可以直接通过类名调用而不需要通过对象调用。
3.如果定义一种表达式结构：(+ 6 3)的值为9，(- 6 3)的值为3，(* 6 3)的值为18，(/ 6 3)的值为2；那么对于表达式(* (- 16 (* 3 2 2 )) (+ 5 (/ 6 (- 5 3))))输出的结果为__D__。
A.44
B.40
C.40
D.32
E.24
F.21
解析：(* (- 16 (* 3 2 2 )) (+ 5 (/ 6 (- 5 3))))
(* (- 16 (* 3 2 2 )) (+ 5 (/ 6 2)))
(* (- 16 (* 3 2 2 )) (+ 5 3))
(* (- 16 (* 3 2 2 )) 8)
(* (- 16 12) 8)
(* 4 8)
32
4.Java 源程序文件的扩展名为（A）
A…java
B…class
C…exe
D…jar
解析：无
5.分析以下代码，说法正确的是（D）
public static void main(String[] args) {
System.out.println(val());
}

public static int val() {
int num = 5;
try {
num = num / 0;
} catch (Exception e) {
num = 10;
} finally {
num = 15;
}
return num;
}
A. 运行时报错
B.程序正常运行，输出值为5
C.程序正常运行，输出值为10
D.程序正常运行，输出值为15
解析：执行代码块的时候，finally语句一定执行且最后执行
6.Java 语言用以下哪个类来把基本类型数据封装为对象（A）
A.包装类
B.Class
C.Math
D.Object
解析：java的数据类型分为两大类：基本类型和引用类型；
基本类型只能保存一些常量数据，引用类型除了可以保存数据，还能提供操作这些数据的功能；
为了操作基本类型的数据，java也对它们进行了封装， 得到八个类，就是java中的基本类型的封装类；他们分别是：
八种基本类型： byte short int long float double char boolean
对应的包装类 ： Byte Short Integer Long Float Double Character Boolean
7.下列说法正确的有（A）
A.数组是一种对象
B.数组属于一种原生类
C.int number=[]={31,23,33,43,35,63}
D.数组的大小可以任意改变
解析：原生类是指Java中，数据类型分为基本数据类型（或叫做原生类、内置类型）和引用数据类型。
8.程序文件名必须与公共外部类的名称完全一致（包括大小写）.(A)
A.正确
B.错误
解析：无
9.下列叙述错误的是（D ）
A.在接口中定义的方法除了default和static关键字修饰的方法拥有方法体，其他方法都应是没有方法体的抽象方法（JDK1.8以后）
B.一个java类只能有一个父类,但可以实现多个接口
C.在类声明中,用implements关键字声明该类实现的接口
D.定义接口时使用implements关键字。
解析：选D
A、JDK8开始，接口中可以定义有方法体的方法，方法必须被default和static修饰。除此之外，其他方法都是抽象方法。
B、Java的语法是单继承，但是继承可以传递。其实B更准确一点是只能有一个直接父类。
C、继承用extends，实现用implements。先继承后实现。
D、类是class，接口是interface。
10.执行如下代码后输出结果为（C ）
public class Test {
public static void main(String[] args) {
System.out.println("return value of getValue(): " + getValue());
}
public static int getValue() {
int i = 1;
try {
i = 4;
} finally{
i++;
return i;
}
}
}
A.return value of getValue(): 1
B.return value of getValue(): 4
C.return value of getValue(): 5
D.其他几项都不对
11.下列关于Java中类的构造方法的描述，正确的是（B）
A.构造方法的返回类型为void
B.可以定义一个类而在代码中不写构造方法。
C.在同一个类中定义的重载构造方法不可以相互调用。
D.子类不允许调用父类的构造方法。
解析：选B
A、构造器没有返回值，这个没有返回值和返回值为void可部一样。
B、每个类在没有自己显式声明构造器的时候，都会有一个默认的无参构造。
C、构造器可以重载，而且可以使用super()、this()相互调用
D、每个构造器的默认第一行都是super()，但是一旦父类中没有无参构造，必须在子类的第一行显式的声明调用哪一个构造。
12.下列属于容器的组件有（B）
A.JButton
B.JPanel
C.Thread
D.JTextArea
解析：JPanel是Java图形用户界面（GUI）工具包中的面板容器类，包含在javax.swing包中，是一种轻量级容器，可以加入到JFrame窗体中。 JPanel默认的布局管理器是FlowLayout，其自身可以嵌套组合，在不同子容器中可包含其他组件(component),如JButton、JTextArea、JTextField 等，功能是对对窗体上的这些控件进行组合，相当于C++和C#中的Panel类。
13.下面属于java合法变量定义的是？（C）
A.final
B.1var1
C._var2
D.var3&
解析：A.final 是关键字
B.不能以数字做首写
C.首写字母可以为下划线
D.不能与&相组合来命名
14.This调用语句必须是构造函数中的第一个可执行语句。（B）
A.正确
B.错误
解析：this()才必须是构造函数中的第一个可执行语句，用this调用语句并不需要。
15.执行语句“int a= ’ 2 ’ ”后，a的值是（B ）
A.2
B.50
C.49
D.0
解析：常用ASCII码值：空格为32；数字0为48；“A”为65；“a”值为97。
16.如果一个list初始化为{5，3，1}，执行以下代码后，其结果为（B ）？
nums.add(6);
nums.add(0,4);
nums.remove(1);
A.[5, 3, 1, 6]
B.[4, 3, 1, 6]
C.[4, 3, 6]
D.[5, 3, 6]
解析：初始化为{5,3,1}
nums.add(6)后list为{5,3,1,6}
nums.add(0,4)是在0号索引上添加数字4得到list为{4,5,3,1,6}
nums.remove(1)是将1号索引上的5进行remove得到list为{4,3,1,6}
17.请问所有的异常类皆直接继承于哪一个类？（C）
A.java.applet.Applet
B.java.lang.Throwable
C.java.lang.Exception
D.java.lang.Error
解析:
18.ArrayList和Vector主要区别是什么？(A)
A.Vector与ArrayList一样，也是通过数组实现的，不同的是Vector支持线程的同步
B.Vector与ArrayList一样，也是通过数组实现的，不同的是ArrayList支持线程的同步
C.Vector是通过链表结构存储数据，ArrayList是通过数组存储数据
D.上述说法都不正确
解析：答案：A
Vector支持线程的同步，也就是内部加锁的
但是效率低，因此在新版jdk中加入线程不安全的Arraylist
19.设int x=1,float y=2,则表达式x/y的值是：（ D ）
A.0
B.1
C.2
D.以上都不是
解析：正解：0.5
x/y= （float）1.0/（float）2.0=0.5 （float类型的）
20.Java1.8之后，Java接口的修饰符可以为（D）
A.private
B.protected
C.final
D.abstract
解析：接口是一种特殊的抽象类，先说明抽象类中的抽象方法，再说明接口

抽象类中的抽象方法(其前有 abstract1修饰)不能用 private、 static、 synchronized、na
tive访回修饰符修饰。原因如下:

1. private
   抽象方法没有方法体,是用来被继承的,所以不能用 private修饰;
   2.static
   static修饰的方法可以通过类名来访间该方法(即该方法的方法体),抽象方法用sttic修饰没有意义;
2. synchronized
   该关键字是为该方法加一个锁。而如果该关键字修饰的方法是 static方法。则使用的锁就是class变量的锁。如果是修饰类方法。则用this变量锁。
   但是抽象类不能实例化对象,因为该方法不是在该抽象类中实现的。是在其子类实现的。所以，锁应该归其子类所有。所以，抽象方法也就不能用 synchronized关键字修饰了;
3. native
   native这个东西本身就和 abstract冲突,他们都是方法的声明,只是一个把方法实现移交给子类,另一个是移交给本地操作系统。如果同时出现,就相当于即把实现移交给子类,又把实现移交给本地操作系统,那到底谁来实现具体方法呢

终于说到了接口！
接口是一种特殊的抽象类,接口中的方法全部是抽象方法(但其前的 abstract可以省略),所以抽象类中的抽象方法不能用的访间修饰符这里也不能用。同时额外说明一下protect关键词
4. protect
protected访同修饰符也不能使用,因为接口可以让所有的类去实现(非继承),不只是其子类,但是要用public去修饰。接口可以去继承一个已有的接口。
21.下面有关JVM内存，说法错误的是？（C）
A.程序计数器是一个比较小的内存区域，用于指示当前线程所执行的字节码执行到了第几行，是线程隔离的
B.虚拟机栈描述的是Java方法执行的内存模型，用于存储局部变量，操作数栈，动态链接，方法出口等信息，是线程隔离的
C.方法区用于存储JVM加载的类信息、常量、静态变量、以及编译器编译后的代码等数据，是线程隔离的
D.原则上讲，所有的对象都在堆区上分配内存，是线程之间共享的
解析：方法区在JVM中也是一个非常重要的区域，它与堆一样，是被 线程共享 的区域。 在方法区中，存储了每个类的信息（包括类的名称、方法信息、字段信息）、静态变量、常量以及编译器编译后的代码等。
22.关于 访问权限说法正确 的是 ？ ( D )
A.外部类定义前面可以修饰public,protected和private
B.局部内部类前面可以修饰public,protected和private
C.匿名内部类前面可以修饰public,protected和private
D.以上说法都不正确
解析：在Java中，可以将一个类定义在另一个类里面或者一个方法里边，这样的类称为内部类，广泛意义上的内部类一般包括四种：成员内部类，局部内部类，匿名内部类，静态内部类 。
1.成员内部类
（1）该类像是外部类的一个成员，可以无条件的访问外部类的所有成员属性和成员方法（包括private成员和静态成员）；
（2）成员内部类拥有与外部类同名的成员变量时，会发生隐藏现象，即默认情况下访问的是成员内部类中的成员。如果要访问外部类中的成员，需要以下形式访问：【外部类.this.成员变量 或 外部类.this.成员方法】；
（3）在外部类中如果要访问成员内部类的成员，必须先创建一个成员内部类的对象，再通过指向这个对象的引用来访问；
（4）成员内部类是依附外部类而存在的，也就是说，如果要创建成员内部类的对象，前提是必须存在一个外部类的对象；
（5）内部类可以拥有private访问权限、protected访问权限、public访问权限及包访问权限。如果成员内部类用private修饰，则只能在外部类的内部访问；如果用public修饰，则任何地方都能访问；如果用protected修饰，则只能在同一个包下或者继承外部类的情况下访问；如果是默认访问权限，则只能在同一个包下访问。外部类只能被public和包访问两种权限修饰。
2.局部内部类
（1）局部内部类是定义在一个方法或者一个作用域里面的类，它和成员内部类的区别在于局部内部类的访问仅限于方法内或者该作用域内；（2）局部内部类就像是方法里面的一个局部变量一样，是不能有public、protected、private以及static修饰符的。
3.匿名内部类
（1）一般使用匿名内部类的方法来编写事件监听代码；
（2）匿名内部类是不能有访问修饰符和static修饰符的；
（3）匿名内部类是唯一一种没有构造器的类；
（4）匿名内部类用于继承其他类或是实现接口，并不需要增加额外的方法，只是对继承方法的实现或是重写。
4.内部静态类
（1）静态内部类是不需要依赖于外部类的，这点和类的静态成员属性有点类似；
（2）不能使用外部类的非static成员变量或者方法。
23.检查程序，是否存在问题，如果存在指出问题所在，如果不存在，说明输出结果。（A）
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.0
B.1
C.2
D.3
24.以下代码的输出结果是？（C）
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();
}
}
A.静态块 构造块 构造块 构造块
B.构造块 静态块 构造块 构造块
C.构造块 构造块 静态块 构造块
D.构造块 构造块 构造块 静态块
解析：开始时JVM加载B.class，对所有的静态成员进行声明，t1 t2被初始化为默认值，为null，又因为t1 t2需要被显式初始化，所以对t1进行显式初始化，初始化代码块→构造函数（没有就是调用默认的构造函数），咦！静态代码块咋不初始化？因为在开始时已经对static部分进行了初始化，虽然只对static变量进行了初始化，但在初始化t1时也不会再执行static块了，因为JVM认为这是第二次加载类B了，所以static会在t1初始化时被忽略掉，所以直接初始化非static部分，也就是构造块部分（输出’‘构造块’’）接着构造函数（无输出）。接着对t2进行初始化过程同t1相同（输出’构造块’），此时就对所有的static变量都完成了初始化，接着就执行static块部分（输出’静态块’），接着执行，main方法，同样也，new了对象，调用构造函数输出（‘构造块’）
25.对文件名为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);
}
}
A.输出：0000
B.输出：123
C.编译报错
D.输出：No name
解析：子类的构造方法总是先调用父类的构造方法，如果子类的构造方法没有明显地指明使用父类的哪个构造方法，子类就调用父类不带参数的构造方法。
而父类没有无参的构造函数，所以子类需要在自己的构造函数中显示的调用父类的构造函数。
26.下面哪几个语句正确的声明一个整型的二维数组（CD）
A.int a[][]=new int[][]
B.int b[10][10]=new int[][]
C.int c[][]=new int[10][10]
D.int []d[]=new int[10][10]
27.在JAVA中，下列哪些是Object类的方法（BCD）
A.synchronized()
B.wait()
C.notify()
D.notifyAll()
E.sleep()
解析：A synchronized Java语言的关键字，当它用来修饰一个方法或者一个代码块的时候，能够保证在同一时刻最多只有一个线程执行该段代码。
B C D 都是Object类中的方法
notify(): 是唤醒一个正在等待该对象的线程。
notifyAll(): 唤醒所有正在等待该对象的线程。
E sleep 是Thread类中的方法
wait 和 sleep的区别：
wait指线程处于进入等待状态，形象地说明为“等待使用CPU”，此时线程不占用任何资源，不增加时间限制。
sleep指线程被调用时，占着CPU不工作，形象地说明为“占着CPU睡觉”，此时，系统的CPU部分资源被占用，其他线程无法进入，会增加时间限制。
28.哪个正确（ ACD）
A.abstract类只能用来派生子类，不能用来创建abstract类的对象。
B.final类不但可以用来派生子类，也可以用来创建final类的对象。
C.abstract不能与final同时修饰一个类。
D.abstract类定义中可以没有abstract方法。
解析：选 ACD
A，抽象类和接口都不可以实例化。
B，final类不能被继承。
C，abstract不能和final共用修饰类。
D，抽象类中可以没有抽象方法，有抽象方法的类一定是抽象类。
注意：abstract是用来修饰类和方法的：
1. 修饰方法：abstract不能和private、final、static共用。
2. 修饰外部类：abstract不能和final、static共用。（外部类的访问修饰符只能是默认和public）
3. 修饰内部类：abstract不能和final共用。（内部类四种访问修饰符都可以修饰）
29.Java语言中，下面哪个语句是创建数组的正确语句？( ABDE )
A.float f[][] = new float[6][6];
B.float []f[] = new float[6][6];
C.float f[][] = new float[][6];
D.float [][]f = new float[6][6];
E.float [][]f = new float[6][];
解析：二维数组定义，一维长度必须定义，二维可以后续定义
30.Which two statements are true if this class is compiled and run?（EG）
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();
    }
}

}
A.An exception may be thrown at runtime.
B.The code may run with no output, without exiting.
C.The code may run with no output, exiting normally(正常地).
D.The code may rum with output “A B A B C C “, then exit.
E.The code may rum with output “A B C A B C A B C “, then exit.
F.The code may ruin with output “A A A B C A B C C “, then exit.
G.The code may ruin with output “A B C A A B C A B C “, then exit.