JavaSE试题一
一、填空题（共20个题目，总计20分）
1.安装JDK后，为了告诉计算机javac.exe和java.exe等执行文件的位置，需要配置的环境变量是____path。
2.Java提供了三种注释类型，分别是单行注释，多行注释和_____文档注释。
3.char 类型用来表示在Unicode编码表中的字符，长度是__2____个字节。
4._____ && ___ 是短路与运算符，如果左侧表达式的计算结果是false，右侧表达式将不再进行计算。
5 . ___ continue______语句用在循环语句体中，用于终止某次循环过程，即跳过循环体中尚未执行的语句，接着进行下一次是否执行循环的判定。
6.基本数据类型的类型转换中，要将double类型的常量3.14159赋给为整数类型变量n的语句是___int n=(int)3.14159_______。
7.执行Person p = new Person();语句后，将在____堆内存_______中给Person对象分配空间，并在栈内存中给引用变量p分配空间，存放Person对象的引用。
8.使用static修饰的变量称为静态变量，静态变量可以有两种访问方式，分别是类名.静态变量名和________对象名.静态变量名_______________。
9.在一个类文件中的关键字package，import，class出现的可能顺序是______package,import,class________________________。
10.异常是由Java应用程序抛出和处理的非严重错误，比如所需文件没有找到、零作除数，数组下标越界等，可分为两类：Checked异常和_______运行时异常___________。
11.数组在内存中分配连续的空间，数组的长度固定，一经分配无法改变，可以使用_______length_____属性获取数组的长度。
12.DateFormat类可以实现字符串和日期类型之间的格式转换，其中将日期类型转换为指定的字符串格式的方法名是__Format()_____。
13.JDK1.5后提供了____enum________关键字，用以定义枚举类。枚举类是一种特殊的类，可以有自己的属性、方法和构造方法。
14.如果希望将自定义类Student的多个对象放入集合TreeSet，实现所有元素按照某个属性的自然顺序排列，则需要Student类实现_____Comparable_____________接口。
15.迭代器Iterator为集合而生，专门实现集合遍历，该接口有三个方法，分别是hasNext() 、_____next()、remove()。
16.Java IO体系中，____DataInputStream______________是字节输入流，提供了可以存取所有Java基础类型数据（如：int，double 等）和String的方法,但没有提供存取对象的方法。
17.____序列化________是指将Java对象转换成字节序列，从而可以保存到磁盘上，也可以在网络上传输，使得不同的计算机可以共享对象。
18.Java反射技术中，每个Method对象对应一个方法，获得Method对象后，可以调用其____invoke_______来调用对应方法。
19.处于运行状态的线程在某些情况下，如执行了sleep（睡眠）方法，或等待I/O设备等资源，将让出CPU并暂时停止自己的运行，进入____阻塞_____状态。
20.统一资源定位符URL是指向互联网“资源”的指针,由4部分组成：协议、存放资源的主机域名、___端口______和资源路径和文件名。
二、选择题（共25个题目，总计25分）
-
以下选项中是对一个Java源文件进行正确编译的语句是（ A ）（选择一项）
A. javac Test.java
B. javac Test
C. java Test
D. java Test.class -
以下选项中属于合法的Java标识符的是（ CD ）。（选择两项）
A. public
B. 3num
C. name
D. _age -
以下代码的执行结果是（ B ）。（选择一项）
boolean m = true;
if(m = false){
System.out.println(“false”);
}else{
System.out.println(“true”);
}A. false
B. true
C. 编译错误
D. 无结果 -
以下do-while循环代码的执行结果是（ A ）。（选择一项）
int a=0;
int c=0;
do{
–c;
a=a-1;
}while(a>0);
System.out.println(a+" "+c);A. -1 -1
B. 死循环
C. -1 -2
D. -1 0 -
while循环和do-while循环的区别是（ D ）。（选择一项）
A. 没有区别，这两个结构在任何情况下效果一样
B. while循环比do-while循环执行效率高
C. while循环是先循环后判断，所以循环体至少被执行一次
D. do-while循环是先循环后判断，所以循环体至少被执行一次 -
分析下面的Java多重循环代码片段，编译运行后的输出结果是（ D ）。（选择一项）
for (int i = 0; i < 6; i++) {
int k = ++i;
while (k < 5) {
System.out.print(i);
break;
}
}A. 024
B. 02
C. 123
D. 13 -
以下关于方法调用的代码的执行结果是（ B ）。（选择一项）
public class Test {
public static void main(String args[]) {
int i = 99;
mb_operate(i);
System.out.print(i + 100);
}
static void mb_operate(int i) {
i += 100;
}
}A. 99
B. 199
C. 299
D. 99100 -
以下关于继承条件下构造方法执行过程的代码的执行结果是（ A ）。（选择一项）
class Person {
public Person() {
System.out.println(“execute Person()”);
}
}
class Student extends Person {
public Student() {
System.out.println("execute Student() ");
}
}
class PostGraduate extends Student {
public PostGraduate() {
System.out.println(“execute PostGraduate()”);
}
}
public class TestInherit {
public static void main(String[] args) {
new PostGraduate();
}
}A. execute Person()
execute Student()
execute PostGraduate()
B. execute PostGraduate()
C. execute PostGraduate()
execute Student()
execute Person()
D. 没有结果输出 -
以下语句中关于Java构造方法的说法错误的是（B ）。（选择一项）
A. 构造方法的作用是为创建对象进行初始化工作，比如给成员变量赋值
B. 一个Java类可以没有构造方法，也可以提供1个或多个构造方法
C. 构造方法与类同名，不能书写返回值类型
D. 构造方法的第一条语句如果是super()，则可以省略，该语句作用是调用父类无参数的构造方法 -
以下关于this和super关键字的说法错误的是（ BD ）。（选择二项）
A. this关键字指向当前对象自身，super关键字指向当前对象的直接父类
B. 在main方法中可以存在this或super关键字，但不能同时存在。
C. this和super关键字都可以访问成员属性，成员方法和构造方法
D. 在一个类的构造方法中可以同时使用this和super来调用其他构造方法 -
以下选项中可以使成员变量m 被函数fun()直接访问的是（ C ）。（选择一项）
class Test {
private int m;
public static void fun() {
System.out.println(m);
}
}A. 将private int m 改为protected int m
B. 将private int m 改为 public int m
C. 将private int m 改为 static int m
D. 将private int m 改为 int m -
Person类和Test类的代码如下所示，则代码中的错误语句是（ C ）。（选择一项）
public class Person {
public String name;
public Person(String name) {
this.name = name;
}
}
public class Test {
public static void main(String[] args) {
final Person person = new Person(“欧欧”);
person.name = “美美”;
person = new Person(“亚亚”);
}
}
A.
final Person person = new Person(“欧欧”);
B. person.name = “美美”;
C. person = new Person(“亚亚”);
D. 没有错误
13) 以下关于异常的代码的执行结果是（ C ）。（选择一项）
public class Test {
public static void main(String args[]) {
try {
System.out.println(“try”);
return;
} catch(Exception e){
System.out.println(“catch”);
}finally {
System.out.println(“finally”);
}
}
}
A. try
catch
finally
B. catch
finally
C. try
finally
D. try
-
以下关于String类的代码的执行结果是（ B ）。（选择一项）
public class Test2 {
public static void main(String args[]) {
String s1 = new String(“bjsxt”);
String s2 = new String(“bjsxt”);
if (s1 == s2)
System.out.println(“s1 == s2”);
if (s1.equals(s2))
System.out.println(“s1.equals(s2)”);
}
}A. s1 == s2
B. s1.equals(s2)
C. s1 == s2
s1.equals(s2)
D. 以上都不对 -
以下关于StringBuffer类的代码的执行结果是（ D ）。（选择一项）
public class TestStringBuffer {
public static void main(String args[]) {
StringBuffer a = new StringBuffer(“A”);
StringBuffer b = new StringBuffer(“B”);
mb_operate(a, b);
System.out.println(a + “.” + b);
}
static void mb_operate(StringBuffer x, StringBuffer y) {
x.append(y);
y = x;
}
}A. A.B
B. A.A
C. AB.AB
D. AB.B -
以下选项中能够正确创建一个数组的是（ AD ）。（选择二项）
A. float []f[] = new float[6][6];
B. float f[][] = new float[][];
C. float [6][]f = new float[6][6];
D. float [][]f = new float[6][]; -
以下选项中关于int和Integer的说法错误的是（ BD ）。（选择二项）
A. int是基本数据类型，Integer是int的包装类，是引用数据类型
B. int的默认值是0，Integer的默认值也是0
C. Integer可以封装了属性和方法提供更多的功能
D. Integer i=5;该语句在JDK1.5之后可以正确执行，使用了自动拆箱功能 -
以下选项中关于Java集合的说法错误的是（ AC ）。（选择二项）
A. List接口和Set接口是Collections接口有两个子接口
B. List接口中存放的元素具有有序，不唯一的特点
C. Set接口中存放的元素具有无序，不唯一的特点
D. Map接口存放的是映射信息，每个元素都是一个键值对 -
以下代码的执行结果是（B ）。（选择一项）
Set s=new HashSet();
s.add(“abc”);
s.add(“abc”);
s.add(“abc”);
s.add(“abcd”);
System.out.println(s.size());A. 1
B. 2
C. 3
D. 4 -
下面集合类中属于非线程安全，且结构采用了哈希表的是（ C ）。（选择一项）
A. Vector
B. ArrayList
C. HashMap
D. Hashtable -
以下选项中关于如下代码的说法正确的是（ AD ）。（选择二项）
public class TestBuffered {
public static void main(String[] args) throws IOException {
BufferedReader br =
new BufferedReader(new FileReader(“d:/bjsxt1.txt”));
BufferedWriter bw =
new BufferedWriter(new FileWriter(“d:/bjsxt2.txt”));
String str = br.readLine();
while(str !=null){
bw.write(str);
bw.newLine();
str = br.readLine();
}
br.close();
bw.close();
}
}A. 该类使用字符流实现了文件复制，将d:/bjsxt1.txt复制为d:/bjsxt2.txt
B. FileReader和FileWriter是处理流，直接从文件读写数据
C. BufferedReader和BufferedWriter是节点流，提供缓冲区功能，提高读写效率
D. readLine()可以读取一行数据，返回值是字符串类型，简化了操作 -
InputStreamReader是转换流，可以将字节流转换成字符流，是字符流与字节流之间的桥梁。它的实现使用的设计模式是（ C ）。（选择一项）
A. 工厂模式
B. 装饰模式
C. 适配器模式
D. 代理模式 -
以下选项中可以填写到横线处，让代码正确编译和运行的是（ A ）。（选择一项）
public class Test implements Runnable {
public static void main(String[] args) {
___________________________________
t.start();
System.out.println(“main”);
}
public void run() {
System.out.println(“thread1!”);
}
}A. Thread t = new Thread(new Test());
B. Test t = new Test();
C. Thread t = new Test();
D. Thread t = new Thread(); -
在多个线程访问同一个资源时，可以使用（ A ）关键字来实现线程同步，保证对资源安全访问。（选择一项）
A. synchronized
B. transient
C. static
D. yield -
以下说法中关于UDP协议的说法正确的是（ AD ）。（选择二项）
A. 发送不管对方是否准备好，接收方收到也不确认
B. 面向连接
C. 占用系统资源多、效率低
D. 非常简单的协议，可以广播发送
三、判断题（共20个题目，总计10分）
1.一个Java源文件中可以定义多个类，但是至多只能有一个public类。( T )
2.Java的字节码文件的扩展名是class，是一种平台独立的非二进制文件。( F )
3.^ 是异或位运算符，运算规则是如果两个操作数相同，结果是0，否则结果是1。( T )
4.赋值运算符优先级别低于条件运算符，条件运算符优先级别低于算术运算符。( T )
5.switch选择语句是多分支选择语句，只能处理等值条件判断的情况，表达式可以是int类型、char类型，但不能是double,float类型。(T )
6.在多重循环中，外层循环变量变化一遍，内层循环变量要变化一次 。( F )
7.程序调用自身的编程技巧称为递归。递归的特点是编程简单并且节省内存。(F )
8.类可以看成一类对象的模板，对象可以看成该类的一个具体实例。(T )
9.使用public修饰的成员属性和方法可以被当前项目中所有包的所有类访问。( T )
10.将子类对象赋给父类引用变量，称为向下转型，将无法访问子类特有的方法。( F )
11.继承是多态的基础，没有继承就没有多态。( T )
12.内部类作为外部类成员，权限修饰符和其他成员一样，可声明为private、默认、protected或public。( T )
13.对于物理连接，比如数据库连接、输入流输出流、Socket连接等，垃圾回收机制无能为力，必须手动关闭才可以。( T )
14.数组和集合中的元素可以是任何数据类型，包括基本类型和引用类型。( F )
15.增强的for循环可以遍历数组和集合，语法简单 不需要知道数组的长度，不能实现与下标相关的操作。( T )
16.LinkedHashMap是一种有序的HashMap，查询速度快，便于进行添加删除操作。( T )
17.Collection类是专门用来操作集合的工具类，提供一系列静态方法实现对各种集合的操作。( F )
18.一个File对象可以代表一个文件或目录，它可以获取文件和目录属性，也可以访问文件内容。( F )
19.进程是线程Thread内部的一个执行单元，它是程序中一个单一顺序控制流程。(F )
20.Socket是传输层供给应用层的编程接口，是应用层与传输层之间的桥梁 。( T )
四、简答题（共5个题目，总计25分）
1.方法重载和方法重写（覆盖）的区别。（4分）
英文 位置不同 修饰符 返回值 方法名 参数 抛出异常 方法体
重载 overload 同一个类中 – 无关— 无关----- 相同---- 不同 ------无关 不同
重写 override子类和父类间 --大于等于-小于等于-相同 相同- 小于等于 不同
2.写出java.lang.Object类的六个常用方法的声明并说明其作用。（6分）
1)public boolean equals(java.lang.Object) 比较内容---------
2)public native int hashCode() 哈希码---------
3)public java.lang.String toString() 变成字符串---------
4)public final native java.lang.Class getClass() 获取类结构信息
5)protected void finalize() throws java.lang.Throwable 垃圾回收前执行的方法
6)protected native Object clone() throws java.lang.CloneNotSupportedException 克隆
7)public final void wait() throws java.lang.InterruptedException 多线程中等待功能
8)public final native void notify() 多线程中唤醒功能----------
9)public final native void notifyAll() 多线程中唤醒所有等待线程的功能----------
3.接口和抽象类的联系和区别。（5分）
第一点． 接口是抽象类的变体，接口中所有的方法都是抽象的。而抽象类是声明方法的存在而不去实现它的类。
第二点． 接口可以多继承，抽象类不行
第三点． 接口定义方法，不能实现，而抽象类可以实现部分方法。
第四点． 接口中基本数据类型为static 而抽类象不是的。
4.Vector和ArrayList、ArrayList和LinkedList的区别和联系。（6分）
实现原理相同，功能相同，都是长度可变的数组结构，很多情况下可以互用（1分）
两者的主要区别如下
1.Vector是早期JDK接口，ArrayList是替代Vector的新接口（0.5分）
2.Vector线程安全，ArrayList重速度轻安全，线程非安全（1分）
3.长度需增长时，Vector默认增长一倍，ArrayList增长50%（0.5分）
ArrayList和LinkedList的区别和联系
ArrayList和LinkedList都是List的实现类，元素具有有序，不唯一特点。（1分）
ArrayList实现了长度可变的数组，在内存中分配连续空间。遍历元素和随机访问元素的效率比较高；（1分）
LinkedList采用链表存储方式。插入、删除元素时效率比较高（1分）
5.面向对象设计原则有哪些。（4分）
面向对象设计原则是面向对象设计的基石，面向对象设计质量的依据和保障，设计模式是面向对象设计原则的经典应用
1.单一职责原则SRP
2.开闭原则OCP
3.里氏替代原则LSP
4.依赖注入原则DIP
5.接口分离原则ISP
6.迪米特原则LOD
7.组合/聚合复用原则CARP
开闭原则具有理想主义的色彩，它是面向对象设计的终极目标。其他设计原则都可以看作是开闭原则的实现手段或方法。
五、编码题（共3个题目，总计20分）
1.写出饿汉式单例模式、懒汉式单例模式、多线程情况下懒汉式双重判断单例模式的示例代码。（7分）
// 饿汉式的单例模式，在类加载时创建单例实例，而不是等到第一次请求实例时创建
// 1、私有 的无参数构造方法Singleton()，避免外部创建实例
// 2、私有静态属性instance * 3、公有静态方法getInstance()
public class Singleton {
private static Singleton instance = new Singleton();
private Singleton(){ }
public static Singleton getInstance(){
return instance;
}
}
/**
//懒汉式的单例模式，类加载时不创建单例实例，在第一次请求实例的时候创建
*/
public class Singleton {
private static Singleton instance;
private Singleton(){ }
public static Singleton getInstance(){
if(instance==null){ //只创建一次对象
instance = new Singleton();
}
return instance;
}
}
//多线程情况下懒汉式的单例模式，避免创建多个对象
// 需要使用synchronized关键字和进行两次null判断
public class Singleton {
private static Singleton instance;
private Singleton(){ }
public static Singleton getInstance(){
if(instance ==null){//避免每次加锁，只有第一次没有创建对象时才加锁
synchronized(Singleton.class){//加锁，只允许一个线程进入
if(instance==null){ //只创建一次对象
instance = new Singleton();
}
}
}
return instance;
}
}
2.写出使用JDBC访问数据库表t_student中所有数据，并将结果集内容封装成List返回的代码。（6分）
1)数据库表已经创建，表名称及字段信息如下
表名 t_student 中文表名称 学生信息表
序号 字段名称 字段说明 类型 长度 备注
1 id 学生编号 number 6 主键
2 name 学生姓名 varchar2 8 非空
3 age 学生年龄 number 3 非空
4 score 学生分数 number 5,1 非空
5 enterdate 入学时间 date 非空
2)实体类Student已经提供，和数据库表字段对应，有id,name,age,score,enterDate五个属性及相应的getter和setter方法，提供了各种参数的构造方法。
3)使用JDBC访问数据库四个连接参数分别为
a)driver:oracle.jdbc.driver.OracleDriver
b)url:jdbc:oracle:thin:@localhost:1521:orcl
c)username:bjsxt
d)password:bjsxt
4)方法的声明为public List findAll(){ }，在方法体中书写JDBC代码完成功能即可。
public List findAll() {
String driver="oracle.jdbc.driver.OracleDriver";
String url="jdbc:oracle:thin:@localhost:1521:orcl";
String uname="bjsxt";
String password="bjsxt";
Connection conn = null;
Statement stmt = null;
ResultSet rs = null;
List stuList = new ArrayList();
try {
//加载驱动（1分）
Class.forName(driver);
//获取连接（1分）
conn = DriverManager.getConnection(url, uname,password);
//建立会话//(0.5分)
stmt = conn.createStatement();
//发送SQL命令得到结果(0.5分)
rs = stmt.executeQuery("select * from t_student");
//处理结果
while(rs.next()){
//取出结果集中各列数据（1分）
int id = rs.getInt("id");
String name = rs.getString("name");
int age = rs.getInt("age");
double score = rs.getDouble("score");
Date enterDate = rs.getDate("enterDate");
//封装成Student对象（0.5分）
Student stu=new Student(id name age, score,enterDate);
//加入集合（0.5分
stuList.add(stu);
}
} catch (SQLException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
}finally{
//关闭资源(依次关闭rs，stmt，conn)（1分）
super.closeAll(rs,stmt,conn);
}
return stuList;//（1分）
}
3.使用TCP网络编程完成用户登录功能：客户端输入用户名和密码，向服务器发出登录请求；服务器接收数据并进行判断，如果用户名和密码均是bjsxt，则登录成功，否则登录失败，返回相应响应信息；客户端接收响应信息并输出登录结果。（7分）
1)用户User类已提供构造方法 public User(String username,String password)。
2)客户端采用ObjectOutputStream发送封装了用户名和密码的User对象。
3)服务器端和客户端的类名和方法声明如下所示。
public class User implements Serializable {
private String username;
private String password;
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
public User(String username, String password) {
super();
this.username = username;
this.password = password;
}
public User() {
super();
// TODO Auto-generated constructor stub
}
@Override
public String toString() {
return "User [username=" + username + ", password=" + password + "]";
}
}
public class LoginServer { //服务器
public static void main(String[] args) throws Exception {
// 1.创建一个ServerSocket，指定等待端口（1分）
ServerSocket serverSocket = new ServerSocket(8888);
// 2.使用ServerSocket接收用户请求（处于监听状态）（1分）
Socket socket = serverSocket.accept();
// 3.创建输入流和输出流（0.5分）
ObjectInputStream ois =
new ObjectInputStream(socket.getInputStream());
DataOutputStream dos =
new DataOutputStream(socket.getOutputStream());
// 4.接收用户数据并输出（0.5分）
User user = (User) ois.readObject();
System.out.println("我是服务器，收到的信息是：" + user);
// 5.发送反馈信息（0.5分）
boolean flag = false;
if ("bjsxt".equals(user.getUsername())
&& "bjsxt".equals(user.getPassword())) {
flag = true;
}
dos.writeBoolean(flag);
// 6.关闭流和socket（0.5分）
ois.close(); dos.close(); socket.close();
}
}
public class LoginClient { //客户端
public static void main(String[] args) throws Exception {
// 1.创建Socket，用来发送请求（0.5分）
Socket socket =
new Socket(InetAddress.getByName("127.0.0.1"), 8888);
// 2.创建输入流和输出流（0.5分）
DataInputStream dis =
new DataInputStream(socket.getInputStream());
ObjectOutputStream oos =
new ObjectOutputStream(socket.getOutputStream());
// 3.发送数据（1分）
Scanner input = new Scanner(System.in);
System.out.println("请输入用户名");
String username = input.nextLine();
System.out.println("请输入密码");
String password = input.nextLine();
User user = new User(username, password);
oos.writeObject(user);
// 4.接收反馈信息并输出（0.5分）
boolean flag = dis.readBoolean();
if (flag) {
System.out.println("登录成功");
} else {
System.out.println("登录失败");
}
// 5.关闭流和socket（0.5分）
dis.close(); oos.close(); socket.close();
}
}