JAVA经典笔试题目及答案（精选7套）
编程语言可以简单的理解为一种计算机和人都能识别的语言。一种计算机语言让程序员能够准确地定义计算机所需要使用的数据，并精确地定义在不同情况下所应当采取的行动，下面是小编收集的JAVA经典笔试题目及答案，欢迎大家阅读和参考。
![图片[1]-JAVA笔试题目及答案大全分享，找工作必看-小师评](https://img01.xiaoshiping.cn/xsp-bucket/2024/03/20240323131703444.jpg)
JAVA笔试题目及答案1
一、选择题(共50题，每题1.5分，共75分。多选题选不全或选错都不得分。)
1. 以下属于面向对象的特征的是(C,D)。(两项)
A) 重载
B) 重写
C) 封装
D) 继承
2. 以下代码运行输出是(C)
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);
}
}
A) 输出：Person
B) 没有输出
C) 编译出错
D) 运行出错
3. 在使用super 和this关键字时，以下描述正确的是(A)
A) 在子类构造方法中使用super()显示调用父类的构造方法，super()必须写在子类构造方法的第一行，否则编译不通过
B) super()和this()不一定要放在构造方法内第一行
C) this()和super()可以同时出现在一个构造函数中
D) this()和super()可以在static环境中使用，包括static方法和static语句块
4. 以下对封装的描述正确的是(D)
A) 只能对一个类中的方法进行封装，不能对属性进行封装
C) 封装的意义不大，因此在编码时尽量不要使用
D) 封装的主要作用在于对外隐藏内部实现细节，增强程序的安全性
5. 以下对继承的描述错误的是(A)
A) Java中的继承允许一个子类继承多个父类
B) 父类更具有通用性，子类更具体
C) Java中的继承存在着传递性
D) 当实例化子类时会递归调用父类中的构造方法
6. 以下程序的运行结果是(D)
class Person{
public Person(){
System.out.println(“this is a Person”);
}
}
public class Teacher extends Person{
private String name=”tom”;
public Teacher(){
System.out.println(“this is a teacher”);
super();
}
public static void main(String[] args){
Teacher teacher = new Teacher();
System.out.println(this.name);
}
}
A) this is a Person
this is a teacher
tom
B) this is a teacher
this is a Person
tom
C) 运行出错
D) 编译有两处错误
7. 以下说法错误的是()
A) super.方法()可以调用父类的所有非私有方法
B) super()可以调用父类的所有非私有构造函数
C) super.属性可以调用父类的所有非私有属性
D) this和super关键字可以出现在同一个构造函数中
8. 以下关于final关键字说法错误的是(A,C)(两项)
A) final是java中的修饰符，可以修饰类、接口、抽象类、方法和属性
B) final修饰的类肯定不能被继承
C) final修饰的方法不能被重载
D) final修饰的变量不允许被再次赋值
9. 访问修饰符作用范围由大到小是(D)
A) private-default-protected-public
B) public-default-protected-private
C) private-protected-default-public
D) public-protected-default-private
10. 以下(D)不是Object类的方法
A) clone()
B) finalize()
C) toString()
D) hasNext()
11. 多态的表现形式有(A)
A) 重写
B) 抽象
C) 继承
D) 封装
12. 以下对重载描述错误的是()
A) 方法重载只能发生在一个类的内部
B) 构造方法不能重载
C) 重载要求方法名相同，参数列表不同
D) 方法的返回值类型不是区分方法重载的条件
13. 以下(D)添加到ComputerBook中不会出错
class Book{
protected int getPrice(){
return 30;
}
}
public class ComputerBook extends Book{
}
A) protected float getPrice(){}
B) protected int getPrice(int page){}
C) int getPrice(){}
D) public int getPrice(){return 10;}
14. 以下对抽象类的描述正确的是(C)
A) 抽象类没有构造方法
B) 抽象类必须提供抽象方法
C) 有抽象方法的类一定是抽象类
D) 抽象类可以通过new关键字直接实例化
15. 以下对接口描述错误的有(D)
A) 接口没有提供构造方法
B) 接口中的方法默认使用public、abstract修饰
C) 接口中的属性默认使用public、static、final修饰
D) 接口不允许多继承
16. 以下代码，描述正确的有(A)
interface IDemo{
public static final String name;1
void print();2
public void getInfo();3
}
abstract class Person implements IDemo{4
public void print(){
}
}
A) 第1行错误，没有给变量赋值
B) 第2行错误，方法没有修饰符
C) 第4行错误，没有实现接口的全部方法
D) 第3行错误，没有方法的实现
17. 接口和抽象类描述正确的有(B,C)(两项)
A) 抽象类没有构造函数
B) 接口没有构造函数
C) 抽象类不允许多继承
D) 接口中的方法可以有方法体
18. 以下描述错误的有(C)
A) abstract 可以修饰类、接口、方法
B) abstract修饰的类主要用于被继承
C) abstract 可以修饰变量
D) abstract修饰的类，其子类也可以是abstract修饰的
19. 以下描述正确的有(B)
A) 方法的重写应用在一个类的内部
B) 方法的重载与返回值类型无关
C) 构造方法不能重载
D) 构造方法可以重写
20. 以下程序运行结果是(A)
public class Test extends Father{
private String name=”test”;
public static void main(String[] args){
Test test = new Test();
System.out.println(test.getName());
}
}
class Father{
private String name=”father”;
public String getName() {
return name;
}
}
A) father
B) test
C) 编译出错
D) 运行出错，无输出
21. 以下对异常的描述不正确的有(C)
A) 异常分为Error和Exception
B) Throwable是所有异常类的父类
C) Exception是所有异常类父类
D) Exception包括RuntimeException和RuntimeException之外的异常
22. 在try-catch-finally语句块中，以下可以单独与finally一起使用的是(B)
A) catch
B) try
C) throws
D) throw
23. 下面代码运行结果是(B)
public class Demo{
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[] args){
Demo demo = new Demo();
System.out.println(“和是：”+demo.add(9,34));
}
}
A) 编译异常
B) finally语句块 和是：43
C) 和是：43 finally语句块
D) catch语句块 和是：43
24. 以下描述不正确的有(D)
A) try块不可以省略
B) 可以使用多重catch块
C) finally块可以省略
D) catch块和finally块可以同时省略
25. 以下对自定义异常描述正确的是(C)
A) 自定义异常必须继承Exception
B) 自定义异常可以继承自Error
C) 自定义异常可以更加明确定位异常出错的位置和给出详细出错信息
D) 程序中已经提供了丰富的异常类，使用自定义异常没有意义
26. 以下程序运行结果是(D)
public class Test {
public int div(int a, int b) {
try {
return a / b;
}catch(Exception e){
System.out.println(“Exception”);
}catch(NullPointerException e){
System.out.println(“ArithmeticException”);
}
catch (ArithmeticException e) {
System.out.println(“ArithmeticException”);
} finally {
System.out.println(“finally”);
}
return 0;
}
public static void main(String[] args) {
Test demo = new Test();
System.out.println(“商是：” + demo.div(9, 0));
}
}
A) Exception finally 商是：0
B) ArithmeticException finally 商是：0
C) finally商是：0
D) 编译报错
27. 以下对TCP和UDP描述正确的是(D)
A) TCP不能提供数据的可靠性
B) UDP能够保证数据库的可靠性
C) TCP数据传输效率高于UDP
D) UDP数据传输效率高于TCP
28. 在Java中，下面对于构造函数的描述正确的是(D)。(选择一项)
A) 类必须显示定义构造函数
B) 构造函数的返回类型是void
C) 构造函数和类有相同的名称，并且不能带任何参数
D) 一个类可以定义多个构造函数
29. 根据下面的代码，
String s = null;
会抛出NullPointerException异常的有(A,C)。[两项]
A) if( (s!=null) & (s.length()>0) )
B) if( (s!=null) & & (s.length()>0) )
C) if( (s==null) | (s.length()==0) )
D) if( (s==null) || (s.length()==0) )
30. .在Java中，关于HashMap类的描述，以下廉洁错误的是( B )。
A) HashMap使用键/值得形式保存数据
B) HashMap 能够保证其中元素的顺序
C) HashMap允许将null用作键
D) HashMap允许将null用作值
31. 下列选项中关于java中super关键字的说法错误的是( B )
A) super关键字是在子类对象内部指代其父类对象的引用
B) super关键字不仅可以指代子类的直接父类，还可以指代父类的父类
C) 子类可以通过super关键字调用父类的方法
D) 子类可以通过super关键字调用父类的属性
32. 在Java中，以下代码( A )正确地创建了一个InputStreamReader对象。
A) InuptStreamReader(new FileInputStream(“1.dat”));
B) InuptStreamReader(new FileReader(“1.dat”));
C) InuptStreamReader(new BufferReader(“1.dat”));
D) InuptStreamReader (“1.dat”);
33. 在Java中，( D )类提供定位本地文件系统，对文件或目录及其属性进行基本操作。
A) FileInputStream
B) FileReader
C) FileWriter
D) File
34. Java中的集合类包括ArrayList、LinkedList、HashMap等类，下列关于集合类描述错误的是(C)(选择一项)
A) ArrayList和LinkedList均实现了List接口
B) ArrayList的访问速度比LinkedList快
C) 添加和删除元素时，ArrayList的表现更佳
D) HashMap实现Map接口，它允许任何类型的键和值对象，并允许将null用作键或值
35. 在Java中开发JDBC应用程序时，使用DriverManager类的getConnection()方法
建立与数据源的连接语句为：
Connection con = DriverManager.getConnection(“jdbc:odbc:news”);
URL连接中的”n ews”表示的是(C)(选择一项)
A) 数据库中表的名称
B) 数据库服务器的机器名
C) 数据源的名称
D) 用户名
36. 在Java中,JDBCAPI定义了一组用于与数据库进行通信的接口和类，它们包括在(B)包中。
A) java.lang
B) java.sql
C) java.util
D) java.math
37. Java中，以下( B )接口以键_值对的方式存储对象。
A) java.util.Collection
B) java.util.Map
C) java.util.List
D) java.util.Set
38. 以下关于对象序列化描述正确的是( C,D )[两项]
A) 使用FileOutputStream可以将对象进行传输
B) 使用PrintWriter可以将对象进行传输
C) 使用ObjectOutputStream类完成对象存储，使用ObjectInputStream类完成对象读取
D) 对象序列化的所属类需要实现Serializable接口
39. 在Java中，( A )类可用于创建链表数据结构的对象。
A) LinkedList
B) ArrayList
C) Collection
D) HashMap
40. 分析下面这段Java代码，它的运行结果是( C )。
Import java.io.*;
Public class B{
Public static void main(string [] args){
int i=12;
System.out.println(i+=i-=i*=i);}}
A) 100
B) 0
C) -120
D) 程序无法编译
41. 使用JDBC事务的步骤是(C,A,B,D)(多选)
A) 取消Connection的事务自动提交方式
B) 发生异常回滚事务
C) 获取Connection对象
D) 操作完毕提交事务
42. 以下对JDBC事务描述错误的是( B )
A) JDBC事务属于JAVA事务的一种
B) JDBC事务属于容器事务类型
C) JDBC事务可以保证操作的完整性和一致性
D) JDBC事务是由Connection发起的，并由Connection控制
43. 要通过可滚动的结果集更新数据，以下正确的是(A
A) pst=con.prepareStatement(sql, ResultSet.TYPE_SCROLL_SENSITIVE,ResultSet.CONCUR_UPDATABLE)
B) pst=con.prepareStatement(sql, ResultSet.TYPE_SCROLL_SENSITIVE,ResultSet.CONCUR_READ_ONLY)
C) pst=con.prepareStatement(sql, Resu ltSet.TYPE_SCROLL_SENSITIVE)
D) pst=con.prepareStatement(sql, ResultSet.CONCUR_UPDATABLE)
44. 存储过程pro有两个参数，第一个为输入参数，第二个为输出参数，以下代码正确的是(C)
A) CallableStatement cst=con.prepareCall(“(call pro(?,?))”);
B) CallableStatement cst=con.prepareCall(“(call pro(?))”);
C) CallableStatement cst=con.prepareCall(“{call pro(?,?)}”);
D) CallableStatement cst=con.prepareCall(“{call pro(?,?,?)}”);
45. 以下描述正确的是(B)
A) CallableStatement是PreparedStatement的父接口
B) PreparedStatement是CallableStatement的父接口
C) CallableStatement是Statement的子接口
D) PreparedStatement是Statement的父接口
46. 要删除book表中书籍(bookName)是”java”的记录，以下代码正确的是(A
String sql=” from book where bookName=?”;
PreparedStatement pst=con.preparedStatement(sql);
______________________________
pst.execute();
A) pst.setString(1,”java”);
B) pst.setString(0,”java”);
C) pst.setInt(0,”java”);
D) 以上选项都不正确
47. 获取ResutlSet对象rst的第一行数据，以下正确的是(B)
A) rst.hashNext();
B) rst.next();
C) rst.first();
D) rst.nextRow();
48. 以下可以正确获取结果集的有(AD)(多选)
A) Statement sta=con.createStatement();
ResultSet rst=sta.executeQuery(“select * from book”);
B) Statement sta=con.createStatement(“select * from book”);
ResultSet rst=sta.executeQuery();
C) PreparedStatement pst=con.preparedStatement();
ResultSet rst=pst.executeQuery(“select * from book”);
D) PreparedStatement pst=con.preparedStatement(“select * from book”);
ResultSet rst=pst.executeQuery();
49. 以下负责建立与数据库连接的是(D)
A) Statement
B) PreparedStatement
C) ResultSet
D) DriverManager
50. 使用JDBC连接数据库的顺序是(B,A,D,C,E)(多选)
A) 加载驱动
B) 导入驱动包
C) 发送并处理SQL语句
D) 建立于数据库的连接
E 关闭连接
二、简答题(各5分，共25分)
1、在java中如果声明一个类为final，表示什么意思? (不计分)
答：final是最终的意思，final可用于定义变量、方法和类但含义不同，声明为final的类不能被继承。
1、父类的构造方法是否可以被子类覆盖(重写)?
答：父类的构造方法不可以被子类覆盖，因为父类和子类的类名是不可能一样的。
2、请讲述String 和StringBuffer的区别。
答：String 类所定义的对象是用于存放”长度固定”的字符串。
StringBuffer类所定义的对象是用于存放”长度可变动”的字符串。
3、如果有两个类A、B(注意不是接口)，你想同时使用这两个类的功能，那么你会如何编写这个C类呢?
答：因为类A、B不是接口，所以是不可以直接继承的，但可以将A、B类定义成父子类，那么C类就能实现A、B类的功能了。假如A为B的父类，B为C的父类，此时C就能实现A、B的功能。
4、结合Java视频Lesson5(多线程)，分析sleep()和wait()方法的区别。
答： Sleeping睡眠的意思 : sleep() 方法用来暂时中止执行的线程。在睡眠后，线程将进入就绪状态。
waiting等待的意思: 如果调用了 wait() 方法，线程将处于等待状态。用于在两个或多个线程并发运行时。
5、谈谈你对抽象类和接口的理解。
答：定义抽象类的目的是提供可由其子类共享的一般形式、子类可以根据自身需要扩展抽象类、抽象类不能实例化、抽象方法没有函数体、抽象方法必须在子类中给出具体实现。他使用extends来继承。
接口：一个接口允许一个类从几个接口继承而来，Java 程序一次只能继承一个类但可以实现几个接口，接口不能有任何具体的方法，接口也可用来定义可由类使用的一组常量。其实现方式是interface来实现。
JAVA笔试题目及答案2
1. 下面哪些是Thread类的方法（）
A start() B run() C exit() D getPriority()
答案：ABD
解析：看Java API docs吧：http://docs.oracle.com/javase/7/docs/api/，exit()是System类的方法，如System.exit(0)。
2. 下面关于java.lang.Exception类的说法正确的是（）
A 继承自Throwable B Serialable CD 不记得，反正不正确
答案：A
解析：Java异常的基类为java.lang.Throwable，java.lang.Error和java.lang.Exception继承 Throwable，RuntimeException和其它的Exception等继承Exception，具体的RuntimeException继承RuntimeException。
扩展：错误和异常的区别(Error vs Exception)
1)java.lang.Error: Throwable的子类，用于标记严重错误。合理的应用程序不应该去try/catch这种错误。绝大多数的错误都是非正常的，就根本不该出现的。
java.lang.Exception: Throwable的子类，用于指示一种合理的程序想去catch的条件。即它仅仅是一种程序运行条件，而非严重错误，并且鼓励用户程序去catch它。
2) Error和RuntimeException 及其子类都是未检查的异常（unchecked exceptions），而所有其他的Exception类都是检查了的异常（checked exceptions）.
checked exceptions:通常是从一个可以恢复的程序中抛出来的，并且最好能够从这种异常中使用程序恢复。比如FileNotFoundException, ParseException等。检查了的异常发生在编译阶段，必须要使用try…catch（或者throws）否则编译不通过。
unchecked exceptions:通常是如果一切正常的话本不该发生的异常，但是的确发生了。发生在运行期，具有不确定性，主要是由于程序的逻辑问题所引起的。比如ArrayIndexOutOfBoundException, ClassCastException等。从语言本身的角度讲，程序不该去catch这类异常，虽然能够从诸如RuntimeException这样的异常中catch并恢复，但是并不鼓励终端程序员这么做，因为完全没要必要。因为这类错误本身就是bug，应该被修复，出现此类错误时程序就应该立即停止执行。因此，面对Errors和unchecked exceptions应该让程序自动终止执行，程序员不该做诸如try/catch这样的事情，而是应该查明原因，修改代码逻辑。
RuntimeException：RuntimeException体系包括错误的类型转换、数组越界访问和试图访问空指针等等。
处理RuntimeException的原则是：如果出现 RuntimeException，那么一定是程序员的错误。例如，可以通过检查数组下标和数组边界来避免数组越界访问异常。其他（IOException等等）checked异常一般是外部错误，例如试图从文件尾后读取数据等，这并不是程序本身的错误，而是在应用环境中出现的外部错误。
3. 下面程序的运行结果是（）
String str1 = “hello”;
String str2 = “he” + new String(“llo”);
System.err.println(str1 == str2);
答案：false
解析：因为str2中的llo是新申请的内存块，而==判断的是对象的地址而非值，所以不一样。如果是String str2 = str1，那么就是true了。
4.下列说法正确的有（）
A． class中的constructor不可省略
B． constructor必须与class同名，但方法不能与class同名
C．一个class只能定义一个constructor
D． constructor在一个对象被new时执行
答案：D
解析：这里可能会有误区，其实普通的类方法是可以和类名同名的，和构造方法唯一的区分就是，构造方法没有返回值。
5. 具体选项不记得，但用到的知识如下：
String []a = new String[10];
则：a[0]~a[9] = null
a.length = 10
如果是int []a = new int[10];
则：a[0]~a[9] = 0
a.length = 10
6. 下面程序的运行结果：（）
public static void main(String args[]) {
Thread t = new Thread() {
public void run() {
pong();
}
};
t.run();
System.out.print(“ping”);
}
static void pong() {
System.out.print(“pong”);
}
A pingpong B pongping C pingpong和pongping都有可能 D 都不输出
答案：B
解析：这里考的是Thread类中start()和run()方法的区别了。start()用来启动一个线程，当调用start方法后，系统才会开启一个新的线程，进而调用run()方法来执行任务，而单独的调用run()就跟调用普通方法是一样的，已经失去线程的特性了。因此在启动一个线程的时候一定要使用start()而不是run()。
7. 下列属于关系型数据库的是（）
A. Oracle B MySql C IMS D MongoDB
答案：AB
解答：IMS（Information Management System）数据库是IBM公司开发的两种数据库类型之一;
一种是关系数据库，典型代表产品：DB2；
另一种则是层次数据库，代表产品：IMS层次数据库。
非关系型数据库有MongoDB、memcachedb、Redis等。
8. GC线程是否为守护线程？（）
答案：是
解析：线程分为守护线程和非守护线程（即用户线程）。
只要当前JVM实例中尚存在任何一个非守护线程没有结束，守护线程就全部工作；只有当最后一个非守护线程结束时，守护线程随着JVM一同结束工作。
守护线程最典型的应用就是 GC (垃圾回收器)
9. volatile关键字是否能保证线程安全？（）
答案：不能
解析：volatile关键字用在多线程同步中，可保证读取的可见性，JVM只是保证从主内存加载到线程工作内存的值是最新的读取值，而非cache中。但多个线程对
volatile的写操作，无法保证线程安全。例如假如线程1，线程2 在进行read,load 操作中，发现主内存中count的值都是5，那么都会加载这个最新的值，在线程1堆count进行修改之后，会write到主内存中，主内存中的count变量就会变为6；线程2由于已经进行read,load操作，在进行运算之后，也会更新主内存count的变量值为6；导致两个线程及时用volatile关键字修改之后，还是会存在并发的情况。
10. 下列说法正确的是（）
A LinkedList继承自List
B AbstractSet继承自Set
C HashSet继承自AbstractSet
D WeakMap继承自HashMap
答案：AC
解析：下面是一张下载的Java中的集合类型的继承关系图，一目了然。
11. 存在使i + 1 < i的数吗（）
答案：存在
解析：如果i为int型，那么当i为int能表示的最大整数时，i+1就溢出变成负数了，此时不就<i了吗。< p=””></i了吗。<>
扩展：存在使i > j || i <= j不成立的数吗（）
答案：存在
解析：比如Double.NaN或Float.NaN，感谢@BuilderQiu网友指出。
12. 0.6332的数据类型是（）
A float B double C Float D Double
答案：B
解析：默认为double型，如果为float型需要加上f显示说明，即0.6332f
13. 下面哪个流类属于面向字符的输入流( )
ABufferedWriter BFileInputStream CObjectInputStream D InputStreamReader
答案：D
解析：Java的IO操作中有面向字节(Byte)和面向字符(Character)两种方式。
面向字节的操作为以8位为单位对二进制的数据进行操作，对数据不进行转换，这些类都是InputStream和OutputStream的子类。
面向字符的操作为以字符为单位对数据进行操作，在读的时候将二进制数据转为字符，在写的时候将字符转为二进制数据，这些类都是Reader和Writer的子类。
总结：以InputStream（输入）/OutputStream（输出）为后缀的是字节流；
以Reader（输入）/Writer（输出）为后缀的是字符流。
扩展：Java流类图结构，一目了然，解决大部分选择题：
14. Java接口的修饰符可以为（）
A private B protected C final D abstract
答案：CD
解析：接口很重要，为了说明情况，这里稍微啰嗦点：
（1）接口用于描述系统对外提供的所有服务,因此接口中的成员常量和方法都必须是公开(public)类型的,确保外部使用者能访问它们；
（2）接口仅仅描述系统能做什么,但不指明如何去做,所以接口中的方法都是抽象(abstract)方法；
（3）接口不涉及和任何具体实例相关的细节,因此接口没有构造方法,不能被实例化,没有实例变量，只有静态（static）变量；
（4）接口的中的变量是所有实现类共有的，既然共有，肯定是不变的东西，因为变化的东西也不能够算共有。所以变量是不可变(final)类型，也就是常量了。
（5）接口中不可以定义变量？如果接口可以定义变量，但是接口中的方法又都是抽象的，在接口中无法通过行为来修改属性。有的人会说了，没有关系，可以通过 实现接口的对象的行为来修改接口中的属性。这当然没有问题，但是考虑这样的情况。如果接口 A 中有一个public 访问权限的静态变量 a。按照 Java 的语义，我们可以不通过实现接口的对象来访问变量 a，通过 A.a = xxx; 就可以改变接口中的变量 a 的值了。正如抽象类中是可以这样做的，那么实现接口 A 的所有对象也都会自动拥有这一改变后的 a 的值了，也就是说一个地方改变了 a，所有这些对象中 a 的值也都跟着变了。这和抽象类有什么区别呢，怎么体现接口更高的抽象级别呢，怎么体现接口提供的统一的协议呢，那还要接口这种抽象来做什么呢？所以接口中 不能出现变量，如果有变量，就和接口提供的统一的抽象这种思想是抵触的。所以接口中的属性必然是常量，只能读不能改，这样才能为实现接口的对象提供一个统 一的属性。
通俗的讲，你认为是要变化的东西，就放在你自己的实现中，不能放在接口中去，接口只是对一类事物的属性和行为更高层次的抽象。对修改关闭，对扩展（不同的实现 implements）开放，接口是对开闭原则的一种体现。
所以：
接口的方法默认是public abstract；
接口中不可以定义变量即只能定义常量(加上final修饰就会变成常量)。所以接口的属性默认是public static final 常量，且必须赋初值。
注意：final和abstract不能同时出现。
15. 不通过构造函数也能创建对象吗（）
A 是 B 否
答案：A
解析：Java创建对象的几种方式（重要）：
(1) 用new语句创建对象，这是最常见的创建对象的方法。
(2) 运用反射手段,调用java.lang.Class或者java.lang.reflect.Constructor类的newInstance()实例方法。
(3) 调用对象的clone()方法。
(4) 运用反序列化手段，调用java.io.ObjectInputStream对象的 readObject()方法。
(1)和(2)都会明确的显式的调用构造函数 ；(3)是在内存上对已有对象的影印，所以不会调用构造函数 ；(4)是从文件中还原类的对象，也不会调用构造函数。
16. ArrayList list = new ArrayList(20);中的list扩充几次（）
A 0 B 1 C 2 D 3
答案：A
解析：这里有点迷惑人，大家都知道默认ArrayList的长度是10个，所以如果你要往list里添加20个元素肯定要扩充一次（扩充为原来的1.5倍），但是这里显示指明了需要多少空间，所以就一次性为你分配这么多空间，也就是不需要扩充了。
17. 下面哪些是对称加密算法（）
A DES B AES C DSA D RSA
答案：AB
解析：常用的对称加密算法有：DES、3DES、RC2、RC4、AES
常用的非对称加密算法有：RSA、DSA、ECC
使用单向散列函数的加密算法：MD5、SHA
18.新建一个流对象，下面哪个选项的代码是错误的？（）
A）new BufferedWriter(new FileWriter(“a.txt”));
B）new BufferedReader(new FileInputStream(“a.dat”));
C）new GZIPOutputStream(new FileOutputStream(“a.zip”));
D）new ObjectInputStream(new FileInputStream(“a.dat”));
答案：B
解析：请记得13题的那个图吗？Reader只能用FileReader进行实例化。
19. 下面程序能正常运行吗（）
public class NULL {
public static void haha(){
System.out.println(“haha”);
}
public static void main(String[] args) {
((NULL)null).haha();
}
}
答案：能正常运行
解析：输出为haha，因为null值可以强制转换为任何java类类型,(String)null也是合法的。但null强制转换后是无效对象，其返回值还是为null，而static方法的调用是和类名绑定的，不借助对象进行访问所以能正确输出。反过来，没有static修饰就只能用对象进行访问，使用null调用对象肯定会报空指针错了。这里和C++很类似。这里感谢@Florian网友解答。
20. 下面程序的运行结果是什么（）
class HelloA {
public HelloA() {
System.out.println(“HelloA”);
}
{ System.out.println(“Im A class”); }
static { System.out.println(“static A”); }
}
public class HelloB extends HelloA {
public HelloB() {
System.out.println(“HelloB”);
}
{ System.out.println(“Im B class”); }
static { System.out.println(“static B”); }
public static void main(String[] args) {
new HelloB();
}
}
答案：
static A
static B
Im A class
HelloA
Im B class
HelloB
解析：说实话我觉得这题很好，考查静态语句块、构造语句块（就是只有大括号的那块）以及构造函数的执行顺序。
对象的初始化顺序：（1）类加载之后，按从上到下（从父类到子类）执行被static修饰的语句；（2）当static语句执行完之后,再执行main方法；（3）如果有语句new了自身的对象，将从上到下执行构造代码块、构造器（两者可以说绑定在一起）。
下面稍微修改下上面的代码，以便更清晰的说明情况：
View Code
此时输出结果为：
static A
static B
——-main start——-
Im A class
HelloA
Im B class
HelloB
Im A class
HelloA
Im B class
HelloB
——-main end——-
21.getCustomerInfo()方法如下，try中可以捕获三种类型的异常，如果在该方法运行中产生了一个IOException，将会输出什么结果（）
public void getCustomerInfo() {
try {
// do something that may cause an Exception
} catch (java.io.FileNotFoundException ex) {
System.out.print(“FileNotFoundException!”);
} catch (java.io.IOException ex) {
System.out.print(“IOException!”);
} catch (java.lang.Exception ex) {
System.out.print(“Exception!”);
}
}
AIOException!
BIOException!Exception!
CFileNotFoundException!IOException!
DFileNotFoundException!IOException!Exception!
答案：A
解析：考察多个catch语句块的执行顺序。当用多个catch语句时，catch语句块在次序上有先后之分。从最前面的catch语句块依次先后进行异常类型匹配，这样如果父异常在子异常类之前，那么首先匹配的将是父异常类，子异常类将不会获得匹配的机会，也即子异常类型所在的catch语句块将是不可到达的语句。所以，一般将父类异常类即Exception老大放在catch语句块的最后一个。
22. 下面代码的运行结果为：（）
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异常
答案：C
解析：开始以为会输出null什么的，运行后才发现Java中所有定义的基本类型或对象都必须初始化才能输出值。
23. System.out.println(“5” + 2);的输出结果应该是（）。
A52 B7 C2 D5
答案：A
解析：没啥好说的，Java会自动将2转换为字符串。
24.指出下列程序运行的结果（）
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;
}
}
A、good and abc
B、good and gbc
C、test ok and abc
D、test ok and gbc
答案：B
解析：大家可能以为Java中String和数组都是对象所以肯定是对象引用，然后就会选D，其实这是个很大的误区：因为在java里没有引用传递，只有值传递
这个值指的是实参的地址的拷贝，得到这个拷贝地址后，你可以通过它修改这个地址的内容（引用不变），因为此时这个内容的地址和原地址是同一地址，
但是你不能改变这个地址本身使其重新引用其它的对象，也就是值传递，可能说的不是很清楚，下面给出一个完整的能说明情况的例子吧：
View Code
程序有些啰嗦，但能反映问题，该程序运行结果为：
对象交换前：p1 = Alexia female
对象交换前：p2 = Edward male
对象交换后：p1 = Alexia female
对象交换后：p2 = Edward male
对象数组交换前：arraya[0] = Alexia female, arraya[1] = Edward male
对象数组交换前：arrayb[0] = jmwang female, arrayb[1] = hwu male
对象数组交换后：arraya[0] = Alexia female, arraya[1] = Edward male
对象数组交换后：arrayb[0] = jmwang female, arrayb[1] = hwu male
基本类型数组交换前：a[0] = 0, a[1] = 1
基本类型数组交换前：b[0] = 1, b[1] = 2
基本类型数组交换后：a[0] = 0, a[1] = 1
基本类型数组交换后：b[0] = 1, b[1] = 2
对象数组内容交换并改变后：arraya[1] = wjl male
对象数组内容交换并改变后：arrayb[1] = Edward male
基本类型数组内容交换并改变后：a[1] = 5
基本类型数组内容交换并改变后：b[1] = 1
说明：不管是对象、基本类型还是对象数组、基本类型数组，在函数中都不能改变其实际地址但能改变其中的内容。
25.要从文件”file.dat”中读出第10个字节到变量c中,下列哪个方法适合?（）
AFileInputStream in=new FileInputStream(“file.dat”); in.skip(9); int c=in.read();
BFileInputStream in=new FileInputStream(“file.dat”); in.skip(10); int c=in.read();
CFileInputStream in=new FileInputStream(“file.dat”); int c=in.read();
DRandomAccessFile in=new RandomAccessFile(“file.dat”); in.skip(9); int c=in.readByte();
答案：A?D?
解析：long skip(long n)作用是跳过n个字节不读，主要用在包装流中的，因为一般流（如FileInputStream）只能顺序一个一个的读不能跳跃读，但是包装流可以用skip方法跳跃读取。那么什么是包装流呢？各种字节节点流类，它们都只具有读写字节内容的方法，以FileInputStream与FileOutputStream为例，它们只能在文件中读取或者向文件中写入字节，在实际应用中我们往往需要在文件中读取或者写入各种类型的数据，就必须先将其他类型的数据转换成字节数组后写入文件，或者从文件中读取到的字节数组转换成其他数据类型，想想都很麻烦！！因此想通过FileOutputStream将一个浮点小数写入到文件中或将一个整数写入到文件时是非常困难的。这时就需要包装类DataInputStream/DataOutputStream，它提供了往各种输入输出流对象中读入或写入各种类型的数据的方法。
DataInputStream/DataOutputStream并没有对应到任何具体的流设备，一定要给它传递一个对应具体流设备的输入或输出流对象，完成类似DataInputStream/DataOutputStream功能的类就是一个包装类，也叫过滤流类或处理流类。它对InputOutStream/OutputStream流类进行了包装，使编程人员使用起来更方便。其中DataInputStream包装类的构造函数语法：public DataInputStream(InputStream in)。包装类也可以包装另外一个包装类。
首先BC肯定 是错的，那A正确吗？按上面的解析应该也不对，但我试了下，发现A也是正确的，与网上解析的资料有些出入，下面是我的code：
View Code
那么D呢，RandomAccessFile是IO包的类，但是其自成一派，从Object直接继承而来。可以对文件进行读取和写入。支持文件的随机访问，即可以随机读取文件中的某个位置内容，这么说RandomAccessFile肯定可以达到题目的要求，但是选项有些错误，比如RandomAccessFile的初始化是两个参数而非一个参数，采用的跳跃读取方法是skipBytes()而非skip()，即正确的写法是：
RandomAccessFile in = new RandomAccessFile(“file.dat”, “r”);
in.skipBytes(9);
int c = in.readByte();
这样也能读到第十个字节，也就是A和D都能读到第十个字节，那么到底该选哪个呢？A和D有啥不同吗？求大神解答~~~
26.下列哪种异 常是检查型异常，需要在编写程序时声明（）
ANullPointerException BClassCastException CFileNotFoundException D IndexOutOfBoundsException
答案：C
解析：看第2题的解析。
27. 下面的方法，当输入为2的时候返回值是多少?（）
public static int getValue(int i) {
int result = 0;
switch (i) {
case 1:
result = result + i;
case 2:
result = result + i * 2;
case 3:
result = result + i * 3;
}
return result;
}
A0 B2 C4 D10
答案：D
解析：注意这里case后面没有加break，所以从case 2开始一直往下运行。
28.选项中哪一行代码可以替换题目中//add code here而不产生编译错误？（）
public abstract class MyClass {
public int constInt = 5;
//add code here
public void method() {
}
}
Apublic abstract void method(int a);
B constInt = constInt + 5;
Cpublic int method();
Dpublic abstract void anotherMethod() {}
答案：A
解析：考察抽象类的使用。
抽象类遵循的原则：
（1）abstract关键字只能修饰类和方法，不能修饰字段。
（2）抽象类不能被实例化（无法使用new关键字创建对象实例），只能被继承。
（3）抽象类可以包含属性，方法，构造方法，初始化块，内部类，枚举类，和普通类一样，普通方法一定要实现，变量可以初始化或不初始化但不能初始化后在抽象类中重新赋值或操作该变量（只能在子类中改变该变量）。
（4）抽象类中的抽象方法（加了abstract关键字的方法）不能实现。
（5）含有抽象方法的类必须定义成抽象类。
扩展：抽象类和接口的区别，做个总结吧：
（1）接口是公开的，里面不能有私有的方法或变量，是用于让别人使用的，而抽象类是可以有私有方法或私有变量的。
（2）abstract class 在 Java 语言中表示的是一种继承关系，一个类只能使用一次继承关系。但是，一个类却可以实现多个interface，实现多重继承。接口还有标识（里面没有任何方法，如Remote接口）和数据共享（里面的变量全是常量）的作用。
（3）在abstract class 中可以有自己的数据成员，也可以有非abstarct的成员方法，而在interface中，只能够有静态的不能被修改的数据成员（也就是必须是 static final的，不过在 interface中一般不定义数据成员），所有的成员方法默认都是 public abstract 类型的。
（4）abstract class和interface所反映出的设计理念不同。其实abstract class表示的是”is-a”关系，interface表示的是”has-a”关系。
（5）实现接口的一定要实现接口里定义的所有方法，而实现抽象类可以有选择地重写需要用到的方法，一般的应用里，最顶级的是接口，然后是抽象类实现接口，最后才到具体类实现。抽象类中可以有非抽象方法。接口中则不能有实现方法。
（6）接口中定义的变量默认是public static final 型，且必须给其初值，所以实现类中不能重新定义，也不能改变其值。抽象类中的变量默认是 friendly 型，其值可以在子类中重新定义，也可以在子类中重新赋值。
29. 阅读Shape和Circle两个类的定义。在序列化一个Circle的对象circle到文件时，下面哪个字段会被保存到文件中？( )
class Shape {
public String name;
}
class Circle extends Shape implements Serializable{
private float radius;
transient int color;
public static String type = “Circle”;
}
Aname
Bradius
Ccolor
Dtype
答案：B
解析：这里有详细的解释：http://www.cnblogs.com/lanxuezaipiao/p/3369962.html
30.下面是People和Child类的定义和构造方法，每个构造方法都输出编号。在执行new Child(“mike”)的时候都有哪些构造方法被顺序调用？请选择输出结果( )
class People {
String name;
public People() {
System.out.print(1);
}
public People(String name) {
System.out.print(2);
this.name = name;
}
}
class Child extends People {
People father;
public Child(String name) {
System.out.print(3);
this.name = name;
father = new People(name + “:F”);
}
public Child() {
System.out.print(4);
}
}
A312 B 32 C 432 D 132
答案：D
解析：考察的又是父类与子类的构造函数调用次序。在Java中，子类的构造过程中必须调用其父类的构造函数，是因为有继承关系存在时，子类要把父类的内容继承下来。但如果父类有多个构造函数时，该如何选择调用呢？
第一个规则：子类的构造过程中，必须调用其父类的构造方法。一个类，如果我们不写构造方法，那么编译器会帮我们加上一个默认的构造方法（就是没有参数的构造方法），但是如果你自己写了构造方法，那么编译器就不会给你添加了，所以有时候当你new一个子类对象的时候，肯定调用了子类的构造方法，但是如果在子类构造方法中我们并没有显示的调用基类的构造方法，如：super();这样就会调用父类没有参数的构造方法。
第二个规则：如果子类的构造方法中既没有显示的调用基类构造方法，而基类中又没有无参的构造方法，则编译出错，所以，通常我们需要显示的：super(参数列表)，来调用父类有参数的构造函数，此时无参的构造函数就不会被调用。
JAVA笔试题目及答案3
一、单选题
1.下列哪一种叙述是正确的（D）
A．abstract修饰符可修饰字段、方法和类
B． 抽象方法的body部分必须用一对大括号{ }包住
C． 声明抽象方法，大括号可有可无
D．声明抽象方法不可写出大括号
2.如下代码
public class Test {
public int aMethod() {
static int i = 0;
i++;
return i;
}
public static void main (String args[]) {
Test test = new Test();
test.aMethod();
int j = test.aMethod();
System.out.println(j);
}
}
输出结果是什么？D
A. 0 B. 1 C. 2 D.编译失败
附：static用来修饰全局变量，不能修饰局部变量
3.下列哪种说法是正确的（D）
A． 实例方法可直接调用超类的实例方法
B． 实例方法可直接调用超类的类方法
C． 实例方法可直接调用其他类的实例方法
D．实例方法可直接调用本类的类方法
4.如下代码：
class Super {
publicIntegergetLenght() { return new Integer(4); }
}
public class Sub extends Super {
publicLonggetLenght() { return new Long(5); }
public static void main(String[] args) {
Super sooper = new Super();
Sub sub = new Sub();
System.out.println(sooper.getLenght().toString() + “,” +
sub.getLenght().toString() );
}
}
输出是什么E
A. 4,4 B. 4,5 C. 5,4 D. 5,5 E.编译失败.
附：方法重写不能改变返回值类型
5.在Servlet处理请求的方式为:C
A.以进程的方式 B.以程序的方式 C.以线程的方式 D.以响应的方式
6.JDBC中，用于表示数据库连接的对象是:B
A.Statement B.Connection C.DriverManager D.PreparedStatement
7.用于调用存储过程的对象是:C
A.ResultSet B.DriverManager C.CallableStatemet D.PreparedStatement
8.按照MVC设计模式，JSP用于实现:B
A.Model B.View C.Controller D.容器
9.如下代码
10. public Object m() {
11. Object o = new Float(3.14F);
12. Object [] oa = new Object[1];
13. oa[0] = o;
14. o = null;
15. oa[0] = null;
16. print ‘return 0’;
17. }
当Float对象在第11行被创建后, 什么时候能够被垃圾回收C
A. 13行以后. B. 14行以后. C. 15行以后. D. 16行以后.
附：当引用变量置为null时，它将变得无法访问，因此符合垃圾回收条件
10.如下代码：
class Base {
Base() { System.out.print(“Base”); }
}
public class Alpha extends Base {
public static void main( String[] args ) {
new Alpha();—–调用父类无参的构造方法
new Base();
}
}
结果是什么B
A. Base B. BaseBase C. 编译失败. D. 代码运行但没有输出. E. 运行时抛出异常
附：对象初始化会先走父类构造方法，在走自己的构造方法
11.在J2EE中属于Web层的组件有:A
A.Servlet B.EJB C.Applet D.HTML
12.在Servlet的生命周期中，容器只调用一次的方法是:C
A.service B.getServletConfig C.init D.destroy
13.以下关于异常的说法正确的是：D
Ａ.一旦出现异常，程序运行就终止了
Ｂ.如果一个方法申明将抛出某个异常，它就必须真的抛出那个异常
Ｃ.在catch子句中匹配特别是一种精确匹配
Ｄ.可能抛出系统异常的方法是不需要申明异常的
14.如下代码：
public class Foo {
public static void main(String[] args) {
try {
return;
} finally {
System.out.println( “Finally” );
}
}
}
输出结果是什么A
A. Finally B.编译失败 C. 代码正常运行但没有任何输出. D. 运行时抛出异常
附：无论是否抛出异常，finally代码块总是会被执行，主要用于java一些后续处理
15.jsp指令中isELIgnored=”boolean”的意思是（C）
A．决定是否实现Servler的单线程模式，
B．决定改页面是否是一个错误处理页面，
C．决定是否支持EL表示，
D．没有具体的含义。
附：在isELIgnored＝”true”时输出为${2000 % 20}，而isELIgnored＝”false”时输出为100。Web容器默认isELIgnored＝”false”。
16.下面关于Java的引用，说法正确的是：B
Ａ.应用实际上就是指针
Ｂ.应用本身是Primitive
Ｃ.引用就是对象本身
Ｄ.一个对象只能被一个引用所指引
附：primitive主数据类型，也称之其为基本数据类型，
还有一种为引用数据类型：引用数据类型，顾名思义就是：“引用”，当一个对象赋值给一个引用变量时，那么，则表明这个引用变量是指向这个对象的；一个对象可以有多个引用；一个引用同一时刻，则只能指向一个对象；
17.对于import java.util包，以下那种说法是错误的**？C**
Ａ. Vector类属于java.util包
Ｂ. Vector类放在…／java/util/目录下
Ｃ. Vector类放在java.util文件中
Ｄ. Vector类是Sun公司的产品
18.在一个线程中Sleep（1000）方法，将使得该线程在多少时间后获得对CPU的控制（假设睡眠过程中不会有其他事件唤醒该线程）？C
Ａ.正好1000毫秒 Ｂ. 1000毫秒不到 Ｃ. >=1000毫秒 Ｄ.不一定
附：在程序sleep之后线程进入就绪态，在这种状态下，需要检查现在是否有资源允许现在的线程继续运行，如果条件不满足，则需要等待。如果是现在有资源则立即执行。
19.在WEB-INF目录下，必须存放的文件为:B
A.class文件 B.web.xml C.jar文件 D.html文件
20.下面关于垃圾收集的说法正确的是：D
Ａ.一旦一个对象成为垃圾，就立刻被收集掉。
Ｂ.对象空间被收集掉之后，会执行该对象的finalize方法
Ｃ. finalize方法和C++的析构函数是完全一回事情
Ｄ.一个对象成为垃圾是因为不再有引用指着它，但是线程并非如此。
21.下面的语句会产生什么样的输出A
System.out.println(4&7);
A.4 B.5 C.6 D.7 E.0
附：& 既是位运算符又是逻辑运算符，&的两侧可以是int，也可以是boolean表达式，当&两侧是int时，要先把运算符两侧的数转化为二进制数再进行运算，4的二进制为100（前面的0省略），7的二进制为111，即100 & 111 = 100，在计算机中1表示真，0表示假，最左边一位1&1=1，最右边一位0&1=0，所以输出4
22.下面的程序中，temp的最终值是什么？B
long temp=(int)3.9;
temp%=2;
A .0 B .1 C .2 D .3 E .4
附：浮点型强转int会丢失精度，所以前面的(int)3.9 会等于3，后面的temp%=2后temp=1；
23.下面哪个不是JAVA关键字A
Ainteger B double C float D default
24.Which method is used by aServletto place its session ID in a URL that is written to the servlet’s response output streamB
A. The encodeURL method of the HttpServletRequest interface.
B. The encodeURL method of the HttpServletResponse interface.
C. The rewriteURL method of the HttpServletRequest interface.
D. The rewriteURL method of the HttpServletResponse interface.
25.每个使用Swing构件的程序必须有一个**( ). D**
A.按钮 B.标签 C.菜单 D.容器
26.下列标识符（名字）命名原则中，正确的是**( ) D**
A.类名的首字母小写 B.变量和方法名的首写字母大写 C.接口名的首写字母小写 D.常量完全大写
27.类Test1定义如下：
1．public class Test1{
2．public float aMethod（float a，float b）{return 0;}
3．
4．}
将以下哪种方法插入行3是不合法的。（B）
A、public float aMethod（float a，float b，float c）{return 0;}
B、public float aMethod（float c，float d）{return 0;}
C、public int aMethod（int a，int b）{return 0;}
D、private float aMethod（int a，int b，int c）{return 0;}
28.哪个语句创建了一个数组实例**？A**
A. int[] ia = new int [15];
B. float fa = new float [20];
C. char[] ca = “Some String”;
D. int ia [][] = {4, 5, 6} {1, 2, 3};
附：B不是一个数租，应该返回float[] ,C中是字符串应该返回String，D是二维数租，正确写法int[][] ia = {{4, 5, 6}, {1, 2, 3}};
29.以public修饰的类如：public class Car{…}则Car() A
A、可被其它程序包中的类使用
B、仅能被本程序包中的类使用
C、不能被任意其它类使用
D、不能被其它类继承
30.下列哪个属于容器型构件() C
A .JEditB.JButton C.JPanel D.JTextField
31.Java程序的执行过程中用到一套JDK工具，其中java.exe是指( )B
A.Java文档生成器 B.Java解释器 C.Java编译器 D.Java类分解器
32.下列关于构造方法的叙述中，错误的是**( ) C**
A. Java语言规定构造方法名与类名必须相同
B. Java语言规定构造方法没有返回值，但不用vold声明
C. Java语言规定构造方法不可以重载
D. Java语言规定构造方法只能通过new自动调用
33.构造函数何时被调用() B
A.类定义时 B.创建对象时 C.调用对象方法时 D.使用对象的变量时
34.break语句**( ) D**
A、只中断最内层的循环B、只中断最外层的循环
C、借助于标号，可以实现任何外层循环中断D、只中断某一层的循环
35.Java语言中下面哪个可以用作正确的变量名称**（）B**
A、3DB、nameC、extendsD、implements
附：Java 中的变量名不能以数字开头。不能是关键字
36.在JavaScript中如何验证一个数据是否是数字（D）
A.如果用Integer.parseInt(value)有误就不是数字
B.int I = value若报错就不是数字，
C.没有方法验证
D.利用isNaN(value)返回的boolean进行判断
附：返回一个Boolean 值，指明提供的值是否是保留值NaN（不是数字）。
37.下面哪一个不能作JSP的服务器(D)
A. IBM WebSphereB. BEA WebLogic C. TomcatD. pws
38.下面哪项不是JSP操作指令(D)
A. getPropertyB. forward
C. includeD. import
39.如果希望控件在界面上按表格行分列排列，应使用下列那种布局管理器？( B)
A、BoxLayoutB、GridLayoutC、BorderLayoutD、FlowLouLayout
40.下面哪一项不是Java类访问控制关键字(C)
A. public B. protected C. this D. private
41.在配置tomcat虚拟目录时，需要打开哪个文件？(C )
A. index.jsp B. web.xml C.server.xml D.以上都不是
42.下面哪个不是表单标记(D)
A. INPUT B.RADIO C.CHECKBOX D. TR
43.下面哪项不是response对象的方法(C)
A. setContentType(String contentTypestr)
B. setHeader(String headername,String headervalue)
C. getParameter(String str)
D. sendError(int errorcode)
44.以下(B)是编写Servlet必须导入的包.
A.java.sql.* B.java.servlet.* C.java.util.* D.java.lang.*
45.下面哪项不属于SQL语句的子类(D)
A.数据定义语言(DDL)
B.数据查询语言(DQL)
C.事务控制语言(TCL)
D.数据插入语言(DIL)
46.选出所有正确的答案
public class Outer{
public void someOuterMethod() {
// Line 3
}
public class Inner{}
public static void main( String[]argv ) {
Outer o = new Outer();
// Line 8
}
}
Which instantiates an instance of InnerA
A. new Inner(); // At line 3
B. new Inner(); // At line 8
C. new o.Inner(); // At line 8
D. new Outer.Inner(); // At line 8
二、多选题
1.下列属于jsp中注释的有(AD)
A．＜%–与–%＞
B．/
C．/**与**/
D．
2.按照学生平均成绩(avg_grade) 将students表中的数据检索出来，下面SQL语句正确的是(ACD)
A) SELECT * FROM students ORDER BY avg_grade
B) SELECT * FROM students GROUP BY avg_grade ASC
C) SELECT * FROM students ORDER BY avg_grade DESC
D) SELECT * FROM students ORDER by avg_grade asc
3.下列是jsp作用域的通信对象的有(ABC)
A．Session
B.application
C.pageContext
D.cookie
4.在接口中以下哪条定义是正确的 (AB)
A. void methoda();
B. public double methoda();
C. public final double methoda();
D. static void methoda(double d1);
E. protected void methoda(double d1);
附：接口中的方法会被隐式的指定为public abstract（只能是 public abstract，其他修饰符都会报错）。
接口中的变量会被隐式的指定为public static final变量（并且只能是 public，用 private 修饰会报编译错误。）
5.下面哪个语句正确地声明一个整型的二维数组？CDE
A.int a[][] = new int[][]；
B.int a[10][10] = new int[][]；
C.int a[][] = new int[10][10]；
D.int [][]a = new int[10][10]；
E.int []a[] = new int[10][10]；
6.下面哪些不是java的简单数据类型BC
A. short B. Boolean C. Double D. float
7.下面哪些语句能够正确地生成5个空字符串？AB
A.String a[]=new String[5]；for(int i=0；i<5；a[i++]=“”)；
B.String a[]={“”，“”，“”，“”，“”}；
C.String a[5]；
D.String[5]a；
E.String []a=new String[5]；for(int i=0；i<5；a[i++]=null)；
8.下列说法错误的有（BCD）
A． 数组是一种对象
B． 数组属于一种原生类
C．int number=[]={31,23,33,43,35,63}
D． 数组的大小可以任意改变
9.不能用来修饰interface的有（ACD）
A．privateB．publicC．protectedD．static
10.下列说法错误的有（ACD）
A． 在类方法中可用this来调用本类的类方法
B． 在类方法中调用本类的类方法时可直接调用
C． 在类方法中只能调用本类中的类方法
D． 在类方法中绝对不能调用实例方法
11.如下代码
class A {
A() { }
}
class B extends A {
}
哪两个说明是正确的？BD
A. B类的构造器应该是public.
B. B类的构造器应该是没有参数
C. B类的构造器应该调用this().
D. B类的构造器应该调用super().
附：默认构造器的修饰符只跟当前类的修饰符有关
12.下列标识符不合法的有（ACD）
A．new B．$Usdollars C．1234 D．car.taxi
13.以下哪四个能使用throw抛出ADEF
A. Error
B. Event
C. Object
D. Throwable
E. Exception
F. RuntimeException
14.javax.Servlet的包中，属于类的是:BC
A.Servlet
B.GenericServlet
C.ServletException
D.ServletContext
15.如下代码:
public class X {
public X aMethod() { return this;}
}
public class Y extends X {
}
哪两个方法能加到Y类的定义中CE
A. public void aMethod() {}
B. private void aMethod() {}
C. public void aMethod(String s) {
D. private Y aMethod() { return null; }
E. public X aMethod() { return new Y(); }
16.对该段代码描述正确的有＜% int=”” i=”Integer.parseInt(request.getParemeter(“value”))”＞(BDC)
B. ＜%=＞
C. ＜%=＞
D.
E.
F.
G.
18.下面哪三个描述是正确的？BCE
A. 默认构造器初始化方法变量
B. 默认构造器有和它所在类相同的访问修饰词.
C. 默认构造器调用其父类的无参构造器.
D. 如果一个类没有无参构造器,编译器会它创建一个默认构造器.
E. 只有当一个类没有任何构造器时，编译器会为它创建一个默认构造器
19.哪二种声明防止方法覆盖？AD
A、final void methoda() {}
B、void final methoda() {}
C、static void methoda() {}
D、static final void methoda() {}
E、final abstract void methoda() {}
JAVA笔试题目及答案4
一、单选题
以下哪个不是SpringBoot默认支持自动装配的?(A)
A.spring-boot-starter-web
Bspring-boot-starter-data-redis
C spring-boot-starter-security
D mybatis spring-boot-starter
Spring中Bean的作用域不包括(D)
A、singleton
B、prototype
C、session
D. application
关系数据库中，实现表与表之间的联系是通过。(B)
A、实体完整性规
B、参照完整性规则
C.用户自定义的完整性
D、值域
当Redis作为数据库时，与Spring Boot整合使用的相关说明，正确的是(A)
A. @RedisHash(“persons )用于指定操作实体类对象在Redis数据库中的存储空间
B. @ld用于标识实体类主键，需要手动指定id生成策略
C.使用Redis数据库，必须为实体类属性添加@Indexed属性生成二级索引
D编写操作Redis数据库的Repostory接口文件时，需要继承JpaRepository 接口
哪个关键字可以对对象加互斥锁。(B)
A, serialize
B, synichronized
C, transient
D, static
算法的确定性特征，以下不符合算法确定性的是:(D)
A. D- (B*B-4*A*C)
B. S- (L*H)/ 10
C.输入:X
D.输出: L/正整数
下列SpringMVC中用到的注解错误的一项。(A)
A @RequestMapping来指定请求的url,只能写在方法上
B @GetMappgin表示只能接收GET方式提交的请求
C @PostMapping表示只能接收POST方式提交的请求
D @RestController是个组合注解， 包括@Controller和@ResponseBody
Spring支持的事务功能包括(C)
A,事务的传播行为
B，事务回滚
C,全部选项
D,事务的隔离级别
下列哪种操作，最容易产生MySQL数据库的锁等待(C)
A、.执行 fromtwhere id> n (删除数百万行)
B、执行alter table对一个1000万行记录的表删除索引
C、执行alter table对一个1000万行记录的表增加列
D、执行alter table对一个1000万行记录的表增加索引
下列( B) 不属于MyBatis全局配置文件中的标签
A. settings
B. select
C. plugins
D. properties
以下数据库事务的隔离级别中哪一个有不可重复读，幻读(D)
A,读取未提交内容(Read Uncommited)
B,读取提交内容(Read Committed)
C,可重复读(Repeatable Read)
D，可串行化(Serializable)
以下哪个不是SpringBoot默认支持自动装配的? (B )
A spring-boot starter-web
B spring -boot starter-data-redis
C spring-boot- starter-security
D mybatis spring boot starter
下列语句哪一个正确(B )
A. Java程序经编译后会产生machine code
B、Java程序经编译后会产生byte code
C. Java程序经编译后会产生DLL
D.以上都不正确
下面对Spring框架的持久化支持说法错误的是(C)
A Spring没有自己的持久化方案，它集合了现有的流行持久化框架
B Spring采用JDBC模板封装了JDBC的数据库操作
C Spring对各种持久化技术提供了统一的编程方式
D Spring将数据库访问的checked异常转换为运行时异常
标记关于Spring核心容器，说法错误的是?(A)
A: Spring框架的所有功能都是通过其核心容器来实现的。
B:创建BeanFactory实例时，需要提供Spring所管理容器的详细配置信息，这些信息通常采用XML文件形式来管理。
C: ApplicationContext不仅包含了BeanFactory的所有功能，还添加了对国际化、资源访问、事件传播等方面的支持。
D:通常在Java项目中，会采用通过ClassPathXmlApplicationContex类来实例化ApplicationContext容器的方式， 而在Web项目中，ApplicationContext容器的实例化工作会交由Web服务器来完成。
下列说话错误的一项是:(D)
A SpringBoot项目启动本质上就是Spring的初始化操作
B. SpringBoot项目启动会加载所有的在spring factories中配置的监 听器
C SpringBoot项目启动的时候会发布相关事件，从而会触发对应的监 听器来完成对应的操作
D. SpringBoot项目启动就会加载bootstrap properties文件
下列关于Spring Boot自动配置原理的说法，错误的是(D)
A @SpringBootApplication只包含@SpringBooConfiguration、@EnableAutoConfiguration、 @ComponentScan 3个注解
B. @SpringBootConfiguration注解表示当前类为-一一个配置类并可以被组件扫描器扫描
C. @EnableAutoConfiguration的作用是启动自动配置，向容器中导入所有选中的自动配置类
D. @ComponentScan注解的主要作用是扫描指定包及其子包下所有注解类文件作为Spring容器的组件使用
描述Spring MVC正确的选项。(D)
A,在Spring MVC中，可以配置多个DispatcherServlet
B, DispatcherServlet在 Spring MVC中是核心servlet，它负责接收请求并将请求分发给适合的控制器
C,要使Spring MVC可用，DispatcherServlet需要在web xml中配置
D，全部选项
看程序进行分析: Public UserselectUser(String name ,String area).
select”fromuser user t whereuser name = #{0} anduser _area #(1)
#{0)表示哪一个参数?（B）
A.程序报错
B. name
C. area
D. 0
二、多选题
在关于依赖注入，描述正确的是。(BC)
A.依赖注入可以增强系统各组件的依赖关系
B.所谓依赖注入，就是明确地定义组件接口，独立开发各个组件，然后根据组件件依赖关系组装运行的设计模式
C依赖注入能多降低系统各组件的依赖关系，提倡面向接口编程
D Spring的依赖注入和控制反转是完全不同的两个概念
下列哪种说法是错误的。(A，B )
A.实例方法可直接调用超类的实例方法
B.实例方法可直接调用超类的类方法
C.实例方法可直接调用其他类的实例方法
D.实例方法可直接调用本类的类方法
对mysql支持的复制类型描述正确的是? (ABC）
A,基于语句的复制
B,基于行的复制
C,混合类型的复制
D,单类型的复制
SpringMVC用什么对象从后台向前台传递数据的? (CB）
A将数据绑定到request
B返回ModelAndView
C通过ModelMap对象，可以在这个对象里面调用put方法，把对象加到里面，前端就可以通过el表达式拿到
D绑定数据到Session中
下列描述有误的是? (CD)
A MyBatis是一个可以自定义SQL、存储过程和高级映射的持久层框架
B. MyBatis的缓存分为级缓存和二级缓存，一级缓存放在 session里面
C. Mybatis是个全ORM (对象关系映射)框架，它内部封装了JDBC
D. MyBatis只可以使用XML来配置和映射原生信息
三、判断题
SpringMvc的控制器是单例模式。(对 )
在Java的方法中定义一个常量要用const关键字。（错）
在sq|语句比较复杂的时候，使用注解绑定比使用xml!绑定会更好。(错)
Spring是轻量的，基本的版本大约3MB。(对)
Spring Boot为整合MyBatis技术框架提供了版本管理。（对）
如果对象的引用被置为null,垃圾收集器会立即释放对象占用的内存?(错)
主键被强制定义成NOT NULL和UNIQUE。(对)
SpringMVC我们可以直接在Controller的相关的方法的形参中获取HttpServletResponse对象(对 )
JSP页面是一种包含 了静态数据和JSP元素两种类型的文本的文本文档。（对）
在Java中，程序员是不需要显示的去释放一个对象的内存的， 而是由虚拟机自行执行。(对)
四、填空题
#{}和${}的含义是什么? #{}是（表示一个占位符，防止sql注入） ${}是（sql的拼接，以字符串方式替换）
SpringMVC常用注解中获取URL中路径变量中的值是（RequestParam）注解。
（ENUM）是一个字符串对象，用于指定一组预定义的值，并可在创建表时使用。
让控件按相同大小排列用（GridLayout）布局管理器;一次只有一个控件可见的布局管理器是（CardLayout)
(@Repository)注解用于将数据访问层(DAO层)的类标识为Spring中的Bean，其功能与@Component相同。
在Spring Boot项目启动类上添加了注解，(@MapperScan(“xxx”))来替代@Mapper注解。
默认情况下，Spring Boot生成的全局配置文件是(application.properties)
JAVA笔试题目及答案5
1.什么是Java虚拟机？为什么Java被称作是“平台无关的编程语言”？
Java虚拟机是一个可以执行Java字节码的虚拟机进程。Java源文件被编译成能被Java虚拟机执行的字节码文件。
Java被设计成允许应用程序可以运行在任意的平台，而不需要程序员为每一个平台单独重写或者是重新编译。Java虚拟机让这个变为可能，因为它知道底层硬件平台的指令长度和其他特性。
2.JDK和JRE的区别是什么？
Java运行时环境(JRE)是将要执行Java程序的Java虚拟机。它同时也包含了执行applet需要的浏览器插件。Java开发工具包(JDK)是完整的Java软件开发包，包含了JRE，编译器和其他的工具(比如：JavaDoc，Java调试器)，可以让开发者开发、编译、执行Java应用程序。
3.”static”关键字是什么意思？Java中是否可以覆盖(override)一个private或者是static的方法？
“static”关键字表明一个成员变量或者是成员方法可以在没有所属的类的实例变量的情况下被访问。
Java中static方法不能被覆盖，因为方法覆盖是基于运行时动态绑定的，而static方法是编译时静态绑定的。static方法跟类的任何实例都不相关，所以概念上不适用。
4.是否可以在static环境中访问非static变量？
static变量在Java中是属于类的，它在所有的实例中的值是一样的。当类被Java虚拟机载入的时候，会对static变量进行初始化。如果你的代码尝试不用实例来访问非static的变量，编译器会报错，因为这些变量还没有被创建出来，还没有跟任何实例关联上。
5.Java支持的数据类型有哪些？什么是自动拆装箱？
Java语言支持的8中基本数据类型是：byte short int long float double boolean char
自动装箱是Java编译器在基本数据类型和对应的对象包装类型之间做的一个转化。比如：把int转化成Integer，double转化成double，等等。反之就是自动拆箱。
6.Java中的方法覆盖(Overriding)和方法重载(Overloading)是什么意思？
Java中的方法重载发生在同一个类里面两个或者是多个方法的方法名相同但是参数不同的情况。与此相对，方法覆盖是说子类重新定义了父类的方法。方法覆盖必须有相同的方法名，参数列表和返回类型。覆盖者可能不会限制它所覆盖的方法的访问。
7.Java中，什么是构造函数？什么是构造函数重载？什么是复制构造函数？
当新对象被创建的时候，构造函数会被调用。每一个类都有构造函数。在程序员没有给类提供构造函数的情况下，Java编译器会为这个类创建一个默认的构造函数。
Java中构造函数重载和方法重载很相似。可以为一个类创建多个构造函数。每一个构造函数必须有它自己唯一的参数列表。
Java不支持像C++中那样的复制构造函数，这个不同点是因为如果你不自己写构造函数的情况下，Java不会创建默认的复制构造函数。
8.Java支持多继承么？
不支持，Java不支持多继承。每个类都只能继承一个类，但是可以实现多个接口。
9.接口和抽象类的区别是什么？
Java提供和支持创建抽象类和接口。它们的实现有共同点，不同点在于：
接口中所有的方法隐含的都是抽象的。而抽象类则可以同时包含抽象和非抽象的方法。 类可以实现很多个接口，但是只能继承一个抽象类 类如果要实现一个接口，它必须要实现接口声明的所有方法。但是，类可以不实现抽象类声明的所有方法，当然，在这种情况下，类也必须得声明成是抽象的。 抽象类可以在不提供接口方法实现的情况下实现接口。 Java接口中声明的变量默认都是final的。抽象类可以包含非final的变量。 Java接口中的成员函数默认是public的。抽象类的成员函数可以是private，protected或者是public。 接口是绝对抽象的，不可以被实例化。抽象类也不可以被实例化，但是，如果它包含main方法的话是可以被调用的。也可以参考JDK8中抽象类和接口的区别
10.什么是值传递和引用传递？
对象被值传递，意味着传递了对象的一个副本。因此，就算是改变了对象副本，也不会影响源对象的值。
对象被引用传递，意味着传递的并不是实际的对象，而是对象的引用。因此，外部对引用对象所做的改变会反映到所有的对象上。
11.进程和线程的区别是什么？
进程是执行着的应用程序，而线程是进程内部的一个执行序列。一个进程可以有多个线程。线程又叫做轻量级进程。
12.创建线程有几种不同的方式？你喜欢哪一种？为什么？
有三种方式可以用来创建线程：
继承Thread类 实现Runnable接口 应用程序可以使用Executor框架来创建线程池。
实现Runnable接口这种方式更受欢迎，因为这不需要继承Thread类。在应用设计中已经继承了别的对象的情况下，这需要多继承（而Java不支持多继承），只能实现接口。同时，线程池也是非常高效的，很容易实现和使用。
13.概括的解释下线程的几种可用状态。
线程在执行过程中，可以处于下面几种状态：
就绪(Runnable):线程准备运行，不一定立马就能开始执行。 运行中(Running)：进程正在执行线程的代码。 等待中(Waiting):线程处于阻塞的状态，等待外部的处理结束。 睡眠中(Sleeping)：线程被强制睡眠。 I/O阻塞(Blocked on I/O)：等待I/O操作完成。 同步阻塞(Blocked on Synchronization)：等待获取锁。 死亡(Dead)：线程完成了执行。
14.同步方法和同步代码块的区别是什么？
在Java语言中，每一个对象有一把锁。线程可以使用synchronized关键字来获取对象上的锁。synchronized关键字可应用在方法级别(粗粒度锁)或者是代码块级别(细粒度锁)。
15.在监视器(Monitor)内部，是如何做线程同步的？程序应该做哪种级别的同步？
监视器和锁在Java虚拟机中是一块使用的。监视器监视一块同步代码块，确保一次只有一个线程执行同步代码块。每一个监视器都和一个对象引用相关联。线程在获取锁之前不允许执行同步代码。
16.什么是死锁(deadlock)？
两个进程都在等待对方执行完毕才能继续往下执行的时候就发生了死锁。结果就是两个进程都陷入了无限的等待中。
17.如何确保N个线程可以访问N个资源同时又不导致死锁？
使用多线程的时候，一种非常简单的避免死锁的方式就是：指定获取锁的顺序，并强制线程按照指定的顺序获取锁。因此，如果所有的线程都是以同样的顺序加锁和释放锁，就不会出现死锁了。
18.Java集合类框架的基本接口有哪些？
Java集合类提供了一套设计良好的支持对一组对象进行操作的接口和类。Java集合类里面最基本的接口有：
Collection：代表一组对象，每一个对象都是它的子元素。 Set：不包含重复元素的Collection。 List：有顺序的collection，并且可以包含重复元素。 Map：可以把键(key)映射到值(value)的对象，键不能重复。
19.为什么集合类没有实现Cloneable和Serializable接口？
集合类接口指定了一组叫做元素的对象。集合类接口的每一种具体的实现类都可以选择以它自己的方式对元素进行保存和排序。有的集合类允许重复的键，有些不允许。
20.什么是迭代器(Iterator)？
Iterator接口提供了很多对集合元素进行迭代的方法。每一个集合类都包含了可以返回迭代器实例的
迭代方法。迭代器可以在迭代的过程中删除底层集合的元素。
克隆(cloning)或者是序列化(serialization)的语义和含义是跟具体的实现相关的。因此，应该由集合类的具体实现来决定如何被克隆或者是序列化。
21.Iterator和ListIterator的区别是什么？
下面列出了他们的区别：
Iterator可用来遍历Set和List集合，但是ListIterator只能用来遍历List。 Iterator对集合只能是前向遍历，ListIterator既可以前向也可以后向。 ListIterator实现了Iterator接口，并包含其他的功能，比如：增加元素，替换元素，获取前一个和后一个元素的索引，等等。
22.快速失败(fail-fast)和安全失败(fail-safe)的区别是什么？
Iterator的安全失败是基于对底层集合做拷贝，因此，它不受源集合上修改的影响。java.util包下面的所有的集合类都是快速失败的，而java.util.concurrent包下面的所有的类都是安全失败的。快速失败的迭代器会抛出ConcurrentModificationException异常，而安全失败的迭代器永远不会抛出这样的异常。
23.Java中的HashMap的工作原理是什么？
Java中的HashMap是以键值对(key-value)的形式存储元素的。HashMap需要一个hash函数，它使用hashCode()和equals()方法来向集合/从集合添加和检索元素。当调用put()方法的时候，HashMap会计算key的hash值，然后把键值对存储在集合中合适的索引上。如果key已经存在了，value会被更新成新值。HashMap的一些重要的特性是它的容量(capacity)，负载因子(load factor)和扩容极限(threshold resizing)。
24.hashCode()和equals()方法的重要性体现在什么地方？
Java中的HashMap使用hashCode()和equals()方法来确定键值对的索引，当根据键获取值的时候也会用到这两个方法。如果没有正确的实现这两个方法，两个不同的键可能会有相同的hash值，因此，可能会被集合认为是相等的。而且，这两个方法也用来发现重复元素。所以这两个方法的实现对HashMap的精确性和正确性是至关重要的。
25.HashMap和Hashtable有什么区别？
HashMap和Hashtable都实现了Map接口，因此很多特性非常相似。但是，他们有以下不同点： HashMap允许键和值是null，而Hashtable不允许键或者值是null。 Hashtable是同步的，而HashMap不是。因此，HashMap更适合于单线程环境，而Hashtable适合于多线程环境。 HashMap提供了可供应用迭代的键的集合，因此，HashMap是快速失败的。另一方面，Hashtable提供了对键的列举(Enumeration)。 一般认为Hashtable是一个遗留的类。
26.数组(Array)和列表(ArrayList)有什么区别？什么时候应该使用Array而不是ArrayList？
下面列出了Array和ArrayList的不同点：
Array可以包含基本类型和对象类型，ArrayList只能包含对象类型。 Array大小是固定的，ArrayList的大小是动态变化的。 ArrayList提供了更多的方法和特性，比如：addAll()，removeAll()，iterator()等等。 对于基本类型数据，集合使用自动装箱来减少编码工作量。但是，当处理固定大小的基本数据类型的时候，这种方式相对比较慢。
27.ArrayList和LinkedList有什么区别？
ArrayList和LinkedList都实现了List接口，他们有以下的不同点：
ArrayList是基于索引的数据接口，它的底层是数组。它可以以O(1)时间复杂度对元素进行随机访问。与此对应，LinkedList是以元素列表的形式存储它的数据，每一个元素都和它的前一个和后一个元素链接在一起，在这种情况下，查找某个元素的时间复杂度是O(n)。
相对于ArrayList，LinkedList的插入，添加，删除操作速度更快，因为当元素被添加到集合任意位置的时候，不需要像数组那样重新计算大小或者是更新索引。
LinkedList比ArrayList更占内存，因为LinkedList为每一个节点存储了两个引用，一个指向前一个元素，一个指向下一个元素也可以参考ArrayList vs. LinkedList。
28.Comparable和Comparator接口是干什么的？列出它们的区别。
Java提供了只包含一个compareTo()方法的Comparable接口。这个方法可以个给两个对象排序。具体来说，它返回负数，0，正数来表明输入对象小于，等于，大于已经存在的对象。
Java提供了包含compare()和equals()两个方法的Comparator接口。compare()方法用来给两个输入参数排序，返回负数，0，正数表明第一个参数是小于，等于，大于第二个参数。equals()方法需要一个对象作为参数，它用来决定输入参数是否和comparator相等。只有当输入参数也是一个comparator并且输入参数和当前comparator的排序结果是相同的时候，这个方法才返回true。
29.什么是Java优先级队列(Priority Queue)？
PriorityQueue是一个基于优先级堆的无界队列，它的元素是按照自然顺序(natural order)排序的。在创建的时候，我们可以给它提供一个负责给元素排序的比较器。PriorityQueue不允许null值，因为他们没有自然顺序，或者说他们没有任何的相关联的比较器。最后，PriorityQueue不是线程安全的，入队和出队的时间复杂度是O(log(n))。
30.你了解大O符号(big-O notation)么？你能给出不同数据结构的例子么？
大O符号描述了当数据结构里面的元素增加的时候，算法的规模或者是性能在最坏的场景下有多么好。
大O符号也可用来描述其他的行为，比如：内存消耗。因为集合类实际上是数据结构，我们一般使用大O符号基于时间，内存和性能来选择最好的实现。大O符号可以对大量数据的性能给出一个很好的说明。
31.如何权衡是使用无序的数组还是有序的数组？
有序数组最大的好处在于查找的时间复杂度是O(log n)，而无序数组是O(n)。有序数组的缺点是插入操作的时间复杂度是O(n)，因为值大的元素需要往后移动来给新元素腾位置。相反，无序数组的插入时间复杂度是常量O(1)。
32.Java集合类框架的最佳实践有哪些？
根据应用的需要正确选择要使用的集合的类型对性能非常重要，比如：假如元素的大小是固定的，而且能事先知道，我们就应该用Array而不是ArrayList。
有些集合类允许指定初始容量。因此，如果我们能估计出存储的元素的数目，我们可以设置初始容量来避免重新计算hash值或者是扩容。
为了类型安全，可读性和健壮性的原因总是要使用泛型。同时，使用泛型还可以避免运行时的ClassCastException。
使用JDK提供的不变类(immutable class)作为Map的键可以避免为我们自己的类实现hashCode()和equals()方法。
编程的时候接口优于实现。
底层的集合实际上是空的情况下，返回长度是0的集合或者是数组，不要返回null。
33.Enumeration接口和Iterator接口的区别有哪些？
Enumeration速度是Iterator的2倍，同时占用更少的内存。但是，Iterator远远比Enumeration安全，因为其他线程不能够修改正在被iterator遍历的集合里面的对象。同时，Iterator允许调用者删除底层集合里面的元素，这对Enumeration来说是不可能的。
34.HashSet和TreeSet有什么区别？
HashSet是由一个hash表来实现的，因此，它的元素是无序的。add()，remove()，contains()方法的时间复杂度是O(1)。
另一方面，TreeSet是由一个树形的结构来实现的，它里面的元素是有序的。因此，add()，remove()，contains()方法的时间复杂度是O(logn)。
35.Java中垃圾回收有什么目的？什么时候进行垃圾回收？
垃圾回收的目的是识别并且丢弃应用不再使用的对象来释放和重用资源。
36.System.gc()和Runtime.gc()会做什么事情？
这两个方法用来提示JVM要进行垃圾回收。但是，立即开始还是延迟进行垃圾回收是取决于JVM的。
37.finalize()方法什么时候被调用？析构函数(finalization)的目的是什么？
在释放对象占用的内存之前，垃圾收集器会调用对象的finalize()方法。一般建议在该方法中释放对象持有的资源。
38.如果对象的引用被置为null，垃圾收集器是否会立即释放对象占用的内存？
不会，在下一个垃圾回收周期中，这个对象将是可被回收的。
39.Java堆的结构是什么样子的？什么是堆中的永久代(Perm Gen space)?
JVM的堆是运行时数据区，所有类的实例和数组都是在堆上分配内存。它在JVM启动的时候被创建。对象所占的堆内存是由自动内存管理系统也就是垃圾收集器回收。
堆内存是由存活和死亡的对象组成的。存活的对象是应用可以访问的，不会被垃圾回收。死亡的对象是应用不可访问尚且还没有被垃圾收集器回收掉的对象。一直到垃圾收集器把这些对象回收掉之前，他们会一直占据堆内存空间。
40.串行(serial)收集器和吞吐量(throughput)收集器的区别是什么？
吞吐量收集器使用并行版本的新生代垃圾收集器，它用于中等规模和大规模数据的应用程序。而串行收集器对大多数的小应用(在现代处理器上需要大概100M左右的内存)就足够了。
41.在Java中，对象什么时候可以被垃圾回收？
当对象对当前使用这个对象的应用程序变得不可触及的时候，这个对象就可以被回收了。
42.JVM的永久代中会发生垃圾回收么？
垃圾回收不会发生在永久代，如果永久代满了或者是超过了临界值，会触发完全垃圾回收(Full GC)。如果你仔细查看垃圾收集器的输出信息，就会发现永久代也是被回收的。这就是为什么正确的永久代大小对避免Full GC是非常重要的原因。
JAVA笔试题目及答案6
一、面向对象的特征有哪些方面
1.抽象：
抽象就是忽略一个主题中与当前目标无关的那些方面，以便更充分地注意与当前目标有关的方面。抽象并不打算了解全部问题，而只是选择其中的一部分，暂时不用部分细节。抽象包括两个方面，一是过程抽象，二是数据抽象。
2.继承：
继承是一种联结类的层次模型，并且允许和鼓励类的重用，它提供了一种明确表述共性的方法。对象的一个新类可以从现有的类中派生，这个过程称为类继承。新类继承了原始类的特性，新类称为原始类的派生类(子类)，而原始类称为新类的基类(父类)。派生类可以从它的基类那里继承方法和实例变量，并且类可以修改或增加新的方法使之更适合特殊的需要。
3.封装：
封装是把过程和数据包围起来，对数据的访问只能通过已定义的界面。面向对象计算始于这个基本概念，即现实世界可以被描绘成一系列完全自治、封装的对象，这些对象通过一个受保护的接口访问其他对象。
4.多态性：
多态性是指允许不同类的对象对同一消息作出响应。多态性包括参数化多态性和包含多态性。多态性语言具有灵活、抽象、行为共享、代码共享的优势，很好的解决了应用程序函数同名问题。
二、String是最基本的数据类型吗?
基本数据类型包括byte、int、char、long、float、double、boolean和short. java.lang.String类是final类型的，因此不可以继承这个类、不能修改这个类。为了提高效率节省空间，我们应该用 StringBuffer类。
三、int 和 Integer 有什么区别?
Java 提供两种不同的类型：引用类型和原始类型(或内置类型)。int是Java的原始数据类型，Integer是Java为int提供的封装类。Java为每个原始类型提供了封装类。
引用类型和原始类型的行为完全不同，并且它们具有不同的语义。引用类型和原始类型具有不同的特征和用法，它们包括：大小和速度问题，这种类型以哪种类型的数据结构存储，当引用类型和原始类型用作某个类的实例数据时所指定的缺省值。对象引用实例变量的缺省值为 null，而原始类型实例变量的缺省值与它们的类型有关。
四、String 和StringBuffer的区别?
Java平台提供了两个类：String和StringBuffer，它们可以储存和操作字符串，即包含多个字符的字符数据。这个String类提供了数值不可改变的字符串。而这个StringBuffer类提供的字符串进行修改。当你知道字符数据要改变的时候你就可以使用StringBuffer.典型地，你可以使用StringBuffer来动态构造字符数据。
五、运行时异常与一般异常有何异同?
异常表示程序运行过程中可能出现的非正常状态，运行时异常表示虚拟机的通常操作中可能遇到的异常，是一种常见运行错误。Java编译器要求方法必须声明抛出可能发生的非运行时异常，但是并不要求必须声明抛出未被捕获的运行时异常。
六、说出Servlet的生命周期，并说出Servlet和CGI的区别。
Servlet被服务器实例化后，容器运行其init方法，请求到达时运行其service方法，service方法自动派遣运行与请求对应的doXXX方法(doGet，doPost)等，当服务器决定将实例销毁的时候调用其destroy方法。
与CGI的区别在于Servlet处于服务器进程中，它通过多线程方式运行其service方法，一个实例可以服务于多个请求，并且其实例一般不会销毁，而CGI对每个请求都产生新的进程，服务完成后就销毁，所以效率上低于CGI.
七、说出ArrayList，Vector， LinkedList的存储性能和特性
ArrayList和Vector都是使用数组方式存储数据，此数组元素数大于实际存储的数据以便增加和插入元素，它们都允许直接按序号索引元素，但是插入元素要涉及数组元素移动等内存操作，所以索引数据快而插入数据慢，Vector由于使用了synchronized方法(线程安全)，通常性能上较ArrayList差，而LinkedList使用双向链表实现存储，按序号索引数据需要进行前向或后向遍历，但是插入数据时只需要记录本项的前后项即可，所以插入速度较快。
八、EJB是基于哪些技术实现的?并说出SessionBean和EntityBean的区别，StatefulBean和StatelessBean的区别。
EJB包括Session Bean、Entity Bean、Message Driven Bean，基于JNDI、RMI、JAT等技术实现。
SessionBean在J2EE应用程序中被用来完成一些服务器端的业务操作，例如访问数据库、调用其他EJB组件。EntityBean被用来代表应用系统中用到的数据。
对于客户机，SessionBean是一种非持久性对象，它实现某些在服务器上运行的业务逻辑。
对于客户机，EntityBean是一种持久性对象，它代表一个存储在持久性存储器中的实体的对象视图，或是一个由现有企业应用程序实现的实体。
九、Collection 和 Collections的区别。
Collection是集合类的上级接口，继承与他的接口主要有Set 和List.
Collections是针对集合类的一个帮助类，他提供一系列静态方法实现对各种集合的搜索、排序、线程安全化等操作。
十、&和&&的区别。
&是位运算符，表示按位与运算，&&是逻辑运算符，表示逻辑与(and)。
JAVA笔试题目及答案7
一、单项选择题(共10题，每题2分，共20分)
1. 下列说法哪一个是正确的。( B )
A.Java程序经编译后会产生machine code
B.Java程序经编译后会产生byte code
C.Java程序经编译后会产生DLL
D.以上都不正确
2. 提供Java存取数据库能力的包是。( A )
A.java.sql B.java.awt C.java.lang D.java.swing
3. 执行如下程序代码后，C的值是。( C )
a=0;c=0;
do{
–c;
a=a-1;
}while(a>0);
A.0 B.1 C.-1 D.死循环
4. 下面的语句中正确的表达式为。( C )
A.byte b = 128;
B.boolean n = null;
C.double d = 0.9239d;
D.float f = 0.9239;
5. 将一个十六进制值赋给一个long型变量的正确写法为。( D )
A.long number = 345L;
B.long number = 0345;
C.long number = 0345L;
D.long number = 0x345L;
6. 以下程序代码的输出是。( B )
public class test (
public static void main (String args[]) (
System.out.printIn (6 ^ 3);
)
)
A.3 B.5 C.6 D.11
7. 以下程序代码的输出是。(E )
public class test (
private static int j = 0;
private static boolean methodB(int k) (
j += k;
return true;
)
public static void methodA(int i) {
boolean b:
b = i < 10 | methodB (4);
b = i < 10 || methodB (8);
)
public static void main (String args[] } (
methodA (0);
system.out.printIn(j);
)
)
A.0 B.4 C.8 D.12 E.不能编译通过
8. 以下程序代码的输出是。( A)
public class test {
public static void add3 (Integer i) }
int val = i.intValue ( );
val += 3;
i = new Integer (val);
}
public static void main (String args [ ] ) {
Integer i = new Integer (0);
add3 (i);
system.out.printIn (i.intValue ( ) );
}
)
A.编译失败 B.编译成功但在第三行会出现异常 C.0 D.3
9. 以下程序代码执行后，哪个说法正确?( B )
int index = 1;
boolean[] test = new Boolean[3];
boolean foo= test [index];
A.有异常抛出。
B.无法编译。
C.foo的值是0。
D.foo的值是null。
E.foo的值是true。
F.foo的值是false。
10. 以下哪个类是swt包中的。( D )
A.MessageBox B.MessageDialog C.JDialog D.DisplayMode
二、多项选择题(共5题，每题4分，共20分)
1. 在下面的选项中合法的标识符有。( ADEF )
A._ok
B.*point
C.this
D.$byte
E.const
F.ILikeJLCSS
2. 下面的选项中哪些不是java的关键字。( AB D )
A.TRUE
B.sizeof
C.goto
D.const
E.super
F.void
3. 下面的叙述中正确的有。( AC )
A. 环境变量可在编译source code时指定。
B. 在编译程序时，所能指定的环境变量不包括class path。
C. javac一次可同时编译数个Java源文件。
D. javac.exe能指定编译结果要置于哪个目录(directory)。
4. 下面的叙述中正确的有。( C )
A.equals()方法判定引用值是否指向同一对象。
B.= = 操作符判定两个分立的对象的内容和类型是否一致。
C.equals()方法只有在两个对象的内容一致时返回true。
D.类File重写方法equals()在两个分立的对象的内容和类型一致时返回true。
5. 下面有关变量及其作用域的陈述哪些是对的。( A C )
A. 在方法里面定义的局部变量在方法退出的时候被撤销。
B. 局部变量也叫自动变量。
C. 在方法外面定义的变量(译注：即实例变量)在对象被构造时创建。
D. 在方法中定义的方法的参变量只要该对象被需要就一直存在。
三、简答题(共7题，共40分)
1. 请写出一个输出“Hello World!” 的程序。(3分)
答：public Class Hello World
{
Public static void main(String[]args)
{
System.out.println(“HELLO WOTLD”);
}
}
2. char型变量中能不能存贮一个中文汉字? 为什么? (3分)
答：能存储一个汉字;因为它能存储四个字节而每个汉字只占两个字节。
3. 常见的两种xml解析技术是什么? 区别是什么? (4分)
答：常见的两种有：SAX和DOM。
区别：SAX 是一种事件驱动的xml解析方式。每次访问一个xml文件中的某个节点的时候，sax就会搜索一遍xml文件，在找到相应的节点后就会触发一个事件来处理请求。只读
DOM是一种基于树状的查找方式。DOM会将xml解析成一棵树，存在内存中。开发者可以通过查找树的节点来取得文件的内容或者修改内容。可读写
4. MVC是什么，如何实现? (5分)
答：MVC是一个是一个设计模式，它强制性的使应用程序的输入，处理和输出分开。使用MVC应用程序被分为三个核心部件：M———-MODO模型，V ———-VIEW 试图，C ——— Contral控制
实现：首先有页面(jsp)发送请求给控制器(servlet)，然后由控制器接收用户的请求，并决定应该调用哪个模型(javabean)来进行处理，然后模型用业务逻辑来处理用户的请求并返回数据，最后控制器用相应的视图格式化模型返回的数据，并通过表示层显示给用户。
5. .J2EE是什么?(6分)
答：J2EE 是Sun公司提出的多层(multi-diered),分布式(distributed),基于组件(component-base)的企业级应用模型 (enterpriese application model).在这样的一个应用系统中，可按照功能划分为不同的组件，这些组件又可在不同计算机上，并且处于相应的层次(tier)中。所属层次包括客户层(clietn tier)组件,web层和组件,Business层和组件,企业信息系统(EIS)层。
6. jsp有哪些内置对象?作用分别是什么? (9分)
答：1.request 用户端请求，此请求会包含来自GET/POST请求的参数;2.response 网页传回用户端的回应;3.pageContext 网页的属性是在这里管理;4.session 与请求有关的会话期;5.application servlet 正在执行的内容;6.out 用来传送回应的输出;7.config servlet的构架部件;8.page JSP网页本身;9.exception 针对错误网页，未捕捉的例外
7. 作用域public,private,protected,以及不写时的区别 ?(10分)
答：作用域 当前类 同一package 子孙类 其他package
public √ √ √ √
protected √ √ √ ×
friendly √ √ × ×
private √ × × ×
不写时默认为friendly
四、编码及论述题(共2题，每题10分，共20分)
1. 什么是Singleton，它的作用是什么，它有几种形式?请用代码写出一个Singleton类。
答：Java Singleton 模式用来保证在运行的应用程序中，一个Class只是实例化一次，也就是只有一个相应的对象存在。
它有三种形式
public class Singleton
{
private static Singleton instance = null;
public static synchronized Singleton getInstance()
{
if (instance==null)
instance=new Singleton();
return instance;
}
}
2. 在Struts + Spring + Hibernate的组合框架模式中，三者各自的特点都是什么?
答：Strtus WEB层 Spring是业务层 Hiebenate是持久化层。
