一、填空题（共20个题目，总计20分）
1.Java虚拟机就是一个虚拟的用于执行 字节码文件 .class 的计算机。它是Java最核心的技术，是Java跨平台的基础。
2.使用Java开发应用程序包括编写源程序，编译源程序，解释并运行三个步骤，其中编译和解释分别需要使用javac.exe和 java.exe 实现。
3.一个十进制整数转换成八进制数后是1234，则它转为十六进制数后是 29c 。
4.Java中浮点数据类型包括float和double两种类型，其中float类型又被称作单精度类型，尾数可以精确到7位有效数字，在内存中占用
4 个字节。
1.使用Math.random( )返回带正号的 double值，该值大于等于0.0且小于1.0。使用该函数生成[30,60]之间的随机整数的语句是(int)(Math.random(
)*31)+30 5
6.for循环的语法格式是for (表达式1;表达式2;表达式3) {循环体}，其中在整个循环过程中只执行一次的部分是 表达式1 。
7.Java中 构造 方法与类名相同，没有返回值，在创建对象实例时由new运算符自动调用。
8.package 语句作为Java源文件的第一条语句，指明该源文件定义的类所在的包。
9.局部变量的名字与成员变量的名字相同，若想在该方法内使用成员变量，必须使用关键字 this
10.Java异常处理中，如果一个方法中出现了多个Checked异常，可以在方法声明中使用关键字 throws 声明抛出，各异常类型之间使用逗号分隔。
11.声明数组仅仅是给出了数组名字和元素的数据类型，要想真正地使用数组还必须为它 分配内存空间 。
12.Arrays类的binarySearch( ) 方法使用二分搜索法来搜索指定的数组，以获得指定的值。必须在进行此调用之前对数组进行 排序 ，否则否则结果是不确定的。
13.Object类有一个public方法是 toString() ，一个对象通过调用该方法可以获得该对象的字符串表示。
14.StringBuilder类是StringBuffer类的替代类，两者的共同点是都是可变长度字符串，其中线程安全的类是 StringBuffer 。
15.Java集合框架提供了一套性能优良、使用方便的接口和类，包括Collection和Map两大类，它们都位于 java.util 包中
16.TreeSet 是一种Collection类型的集合类，其中元素唯一，并采用二叉树作为存储结构，元素按照自然顺序排列。
17.Java IO流可以分为 节点流 和处理流两大类，其中前者处于IO操作的第一线，所有操作必须通过他们进行。
18.处于新建状态的线程被启动后，将进入线程队列排队等待CPU服务，此时它已经具备了运行条件，一旦轮到享用CPU资源时，就可以脱离创建它的主线程独立开始自己的生命周期。上述线程是处于
就绪 状态。
19.在线程通信中，调用 wait() 方法可以是当前线程处于等待状态，而为了唤醒一个等待的线程，需要调用的方法是notify( )。
20.在Socket编程中，IP地址用来标志一台计算机，但是一台计算机上可能提供多种应用程序，使用 端口号 来区分这些应用程序。

二、选择题（共25个题目，总计25分）
有一段Java 程序，其中public类名是A1，那么保存它的源文件名可以是（ A ）。（选择一项）

A A1.java
B. A1.class
C. A1
D. 都不对

在Java中，byte数据类型的取值范围是（ A ）。（选择一项）

A -128 ~ 127
B. -228 ~128
C. -255 ~ 256
D. -255 ~ 255

有以下方法的定义，请选择该方法的返回类型（ D ）。（选择一项）
method(byte x, double y) {
return (short)x/y*2;
}

A byte
B. short
C. int
D. double

以下选项中添加到代码中横线处会出现错误的是（ B D ）。（选择二项）
public class Test {
public float aMethod(float a, float b) {
return 0;
}

}

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 int aMethod(float a, float b) {
return 0;
}

阅读下列文件定入的Java代码，其执行结果是（ D ）。（选择一项）
public class Test {
public static void main(String[] args) {
char ch = ‘c’;
switch (ch) {
case ‘a’:
System.out.print(“a”); break;
case ‘b’:
System.out.print(“ab”);
case ‘c’:
System.out.print(“c”);
default:
System.out.print(“d”);
}
}
}

A a
B. b
C. c
D. cd

下面程序执行的结果是在屏幕上打印（ B ）次Java基础班。（选择一项）
for(int i=1;i<=10;i++){
if (i<5)
continue;
System.out.println(“Java基础班”);
}

A 5
B. 6
C. 7
D. 8

以下四个选项中和下面代码功能相同的是（ B ）。（选择一项）
int i = 1;
int sum = 0;
while (i <= 100) {
if (i % 2 == 0)
sum = sum + i;
i++;
}

A for (int x =1; x<=100;x++){ sum=sum+x;}
B. for (int x =0; x<=100;x+=2){ sum=sum+x;}
C. for (int x =1; x<=100;x+=2){ sum=sum+x;}
D. 上述全对

以下代码中错误的语句是（ D ）。（选择一项）
public class Something{
public static void main(String[] args){
final Other o=new Other();
new Something().addOne(o);//1
}
public void addOne( Other o){
o.i++;//2
o = new Other();//3
}
}
class Other{
public int i;
}

A 1
B. 2
C. 3
D. 没有错误

在Java中，以下程序编译运行后的输出结果为（ D ）。（选择一项）
public class Test {
int x, y;
Test(int x, int y) {
this.x = x;
this.y = y;
}
public static void main(String[] args) {
Test pt1, pt2;
pt1 = new Test(3, 3);
pt2 = new Test(4, 4);
System.out.print(pt1.x + pt2.x);
}
}

A 6
B. 34
C. 8
D. 7

下列选项中关于Java中类方法的说法错误的是（ AC ）。（选择二项）

A 在类方法中可用this来调用本类的类方法
B. 在类方法中调用本类的类方法时可直接调用
C. 在类方法中只能调用本类中的类方法
D. 在类方法中调用实例方法需要先创建对象

下列选项中关于Java中super关键字的说法正确的是（ AD ）。（选择一项）

A super关键字是在子类对象内部指代其父类对象的引用
B. super关键字不仅可以指代子类的直接父类，还可以指代父类的父类
C. 子类通过super关键字只能调用父类的方法，而不能调用父类的属性
D. 子类通过super关键字可以调用父类的构造方法

编译运行如下Java代码，输出结果是（ D ）。（选择一项）
class Base {
public void method(){
System.out.print (“Base method”);
}
}
class Child extends Base{
public void methodB(){
System.out.print (“Child methodB”);
}
}
class Sample {
public static void main(String[] args) {
Base base= new Child();
base.methodB();
}
}

A Base method
B. Child methodB
C. Base method
Child methodB
D. 编译错误

在Java中，关于引用数据类型的类型转换说法正确的是（ AB ）。（选择二项）

A 引用数据类型的类型转换有向上转型和向下转型
B. 向下转型，必须转换成其真实子类型，而不能随意转换
C. 向下转型是自动进行的，也称隐式转换
D. 向上转型可以使用instanceof操作符来判断转型的合法性

在Java接口中，下列选项中属于有效的方法声明是（ AC ）。（选择二项）

A public void aMethod( );
B. final void aMethod( );
C. void aMethod(){ }
D. private void aMethod( );

以下选项中关于匿名内部类的说法正确的是（ BD ）。（选择二项）

A. 匿名内部类可以实现多个接口，或者继承一个父类
B. 匿名内部类不能是抽象类，必须实现它的抽象父类或者接口里包含的所有抽象方法
C. 匿名内部类没有类名，所以匿名内部类不等定义构造方法
D. 匿名内部类可以直接访问外部类的所有局部变量

阅读如下Java代码，在控制台输入"-1",执行结果是（B）。（选择一项）
public class Demo {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
System.out.print(“请输入数字：”);
try {
int num = input.nextInt();
if (num < 1 || num > 4) {
throw new Exception(“必须在1-4之间！”);
}
} catch (InputMismatchException e) {
System.out.println(“InputMismatchException”);
} catch (Exception e) {
System.out.println(e.getMessage());
}
}
}

A 输出：InputMismatchException
B. 输出：必须在1-4之间！
C. 什么也没输出
D. 编译错误

关于Integer类中的静态方法parseInt()方法说法正确的是（ BC ）。（选择二项）

A 将小数转换成整数
B. 将数字格式的字符串转成整数
C. 使用parseInt()方法可能抛出异常
D. 将单个字符转成整数

以下程序片段中可以正常编译的是（ C ）。（选择一项）

A String s = “Gone with the wind”;
String k = s+t;
String t = “good”;
B. String s = “Gone with the wind”;
String t;
t = s[3]+“one”;
C. String s = “Gone with the wind”;
String stanfard = s.toUpperCase();
D. String s = “home directory”;
String t = s – “directory”;

以下代码的执行结果是（ C ）。（选择一项）
Set s=new HashSet();
s.add(“abc”);
s.add(“abc”);
s.add(“abcd”);
s.add(“ABC”);
System.out.println(s.size());

A. 1
B. 2
C. 3
D. 4

File类中的isDirectory( )方法的作用是（ BD ）。（选择二项）

A. 判断File对象封装的是否是文件
B. 判断File对象封装的是否是目录
C. 判断File对象中封装的是否是根目录
D. 返回值类型是boolean

阅读下列文件定入的JAVA代码，共有（ C ）处错误。（选择一项）
import java.io.*;
public class TestIO {
public static void main(String []args){
String str =“文件写入练习”;
FileWriter fw = null; //1
try{
fw = new FileWriter(“c:\mytext.txt”); //2
fw.writerToEnd(str); //3
}catch(IOException e){ //4
e.printStackTrace();
}finally{
//此处省略关闭流
}
}
}

A 0
B. 1
C. 2
D. 3

以下选项中关于Java中线程控制方法的说法正确的是（ AD ）。（选择二项）

A. join ( ) 的作用是阻塞指定线程等到另一个线程完成以后再继续执行
B. sleep ( ) 的作用是让当前正在执行线程暂停，线程将转入就绪状态
C. yield ( ) 的作用是使线程停止运行一段时间，将处于阻塞状态
D. setDaemon( )的作用是将指定的线程设置成后台线程

Java中线程安全问题是通过关键字（ c ）解决的?。（选择一项）

A. finally
B. wait( )
C. synchronized
D. notify( )

ServerSocket的监听方法accept( )方法的返回值类型是（ A ）。（选择一项）

A. Socket
B. void
C. Object
D. DatagramSocket

以下选项中关于Java中获取Class对象的方式正确的是（ CD ）。（选择二项）

A. Class c1 = String.getClass( );
B. String str = new String(“bjsxt”);
Class clazz = str.class;
C. Class c1 = Integer.TYPE;
D. Class clazz = Class.forName(“java.lang.Object”);

三、判断题（共20个题目，总计10分，正确√，错误×）
1.和C++相比，Java取消了指针，不再有多重继承，不需要手动回收垃圾。（ 对 ）
2.Java具有一次编译，到处运行的特点，其含义是Java的源代码可以一次性编译成计算机的机器码，并在不同的平台上运行。（ 错 ）
3.char 数据类型用来表示在ASCII编码表中的一个字符，在内存中占用1个字节空间，所以不能表示一个汉字。（ 错 ）
4.赋值和条件运算符是运算级别最低的两种运算符，两者都具有自右向左的结合性。（ 对 ）
5.多重循环是指一个循环体内又包含另一个完整的循环结构。外层循环变量变化一次，内层循环变量要从头到尾变化一遍。（ 对 ）
6.任何可用递归解决的问题也能使用循环解决，递归既花时间又耗内存，在要求高性能的情况下尽量避免使用递归。（对 ）
7.访问权限是private的变量，只能在本类和与本类同一个包中的其他类使用。（ 错 ）
8.对于子类创建的一个对象，如果子类继承了父类的方法，未重写，则运行时调用子类的方法。（ 错 ）
9.ArithmeticException，ArrayIndexOutOfBoundsException，NullPointerException是运行时异常，而ClassNotFoundException，ClassCastException是Checked异常。（错 ）
10.数组的长度是确定的，数组一旦被创建，它的大小就是不可以改变的。但是其元素类型可以是不同类型，允许出现混合类型。（ 错 ）
11.创建数组后，系统会给每个数组元素一个默认值，如double型元素的默认值是0.0。（ 对 ）
12.JK1.5后提供了自动装箱和自动拆箱功能，从而可以实现基本数据类型和对应包装类之间的自动转换，简化了操作。（ 对 ）
13.java.sql.Date类和java.util.Date类的关系是前者是后者的父类，其中前者没有提供无参数构造方法，而后者可以提供无参数构造方法来获取当前时间。（ 错 ）
14.Collection是Java集合顶级接口，其中的元素无序，唯一。Java平台不提供这个接口任何直接的实现。（ 对 ）
15.Iterator接口可以遍历任何Collection接口的实现类，可以从一个Collection中使用iterator( )方法来获取迭代器实例。迭代器取代了Java集合框架中的Enumeration。（ 对 ）
16.序列化是指将字节序列转换成Java对象，只有实现了Serializable接口的类的对象才可以被序列化。（ 错 ）
17.一个进程可以包括多个线程。两者的一个主要区别是：线程是资源分配的单位，而进程CPU调度和执行的单位。（ 错 ）
18.用new关键字建立一个线程对象后，该线程对象就处于新生状态。处于新生状态的线程有自己的内存空间，通过调用start进入就绪状态。（ 对 ）
19.TCP协议是一种面向无连接的、可靠的、基于字节流的传输层通信协议，该协议占用系统资源多、效率较低。（ 错 ）
20.Java反射技术中，对于一个private修饰的成员变量，可以再设置setAccessible(true)后进行暴力访问。（ 对 ）

四、简答题（共5个题目，总计25分）
1.面向过程和面向对象的区别。（5分）

1.编程思路不同： 面向过程以实现功能的函数开发为主，而面向对象要首先抽象出类、属性及其方法，然后通过实例化类、执行方法来完成功能。（1分）
2.封装性：都具有封装性，但是面向过程是封装的是功能，而面向对象封装的是数据和功能。（1分）
3.面向对象具有继承性和多态性，而面向过程没有继承性和多态性，所以面向对象优势是明显。（1分）
4.面向对象耦合性低，更利于修改维护。（盖浇饭/蛋炒饭）。（1分）
5.面向过程更适合解决简单问题。面向对象更适合解决复杂问题。（1分）

2.Error和Exception的区别。（5分）

1.Error类，表示仅靠程序本身无法恢复的严重错误，比如说内存溢出、动态链接异常、虚拟机错误。（1分）应用程序不应该抛出这种类型的对象。假如出现这种错误，除了尽力使程序安全退出外，在其他方面是无能为力的。（1分）
2.Exception类，由Java应用程序抛出和处理的非严重错误，比如所需文件没有找到、零作除数，数组下标越界等。（1分）它的各种不同子类分别对应不同类型异常。可分为两类：Checked异常和Runtime异常。（1分）所以在进行程序设计时，应该更关注Exception类。（1分）

3.列举常用的字节输入流和输出流并说明其特点，至少5对。（5分）

1.FileInputStream和FileOutputStream 节点流 以文件为数据源和目的地（1分）
2.BufferedInputStream和BufferedOutputStream 处理流 提供了缓冲功能，提高读写效率（1分）
3.DataInputStream和DataOutputStream 处理流 提供了方便读写基本数据类型和String数据的方法（1分）
4.ObjectInputStream和ObjectOutputStream 处理流 不仅提供了方便读写基本数据类型和String数据的方法，也提供了读写引用类型数据的方法（1分）
5.ByteArrayInputStream和ByteArrayOutputStream 节点流 以字节数组为数据源和目的地（1分）

4.创建线程的两种方式分别是什么？各有什么优缺点。（5分）

1.方式1：继承java.lang.Thread类，并覆盖run() 方法。（1分）
优势：编写简单；（0.5分）
劣势：无法继承其它父类（0.5分）
2.方式2：实现java.lang.Runnable接口，并实现run()方法。（1分）
优势：可继承其它类，多线程可共享同一个Thread对象；（1分）
劣势：编程方式稍微复杂，如需访问当前线程，需调用Thread.currentThread()方法（1分）

5.简述基于UDP的Socket编程的主要步骤。
提示：分别说明服务器端和客户端的编程步骤。（5分）

服务器端（server）：
1)构造DatagramSocket实例。（0.5分）
2)创建数据包DatagramPacket，存取发送和接收的数据、IP和端口。（0.5分）
3)通过DatagramSocket实例的receive方法接收客户端数据。（0.5分）
4)通过DatagramSocket的send方法向客户端发出反馈信息。（0.5分）
5)关闭DatagramSocket。（0.5分）
客户端（client）：
1)构造DatagramSocket实例。（0.5分）
2)创建数据包DatagramPacket，存取发送和接收的数据、IP和端口。（0.5分）
3)通过DatagramSocket实例的receive方法接收客户端数据。（0.5分）
4)通过DatagramSocket的send方法向客户端发出反馈信息. （0.5分）
5)关闭DatagramSocket。（0.5分）

五、编码题（共3个题目，总计20分）
1.给20块钱买可乐，每瓶可乐3块钱，喝完之后退瓶子可以换回1块钱，问最多可以喝到多少瓶可乐。（5分）
public class Test {
public static void main(String[] args) {
int money = 20, price = 3; //0.5分
// temp表示每一次购买的可乐瓶数
int temp = 0;
// change表示每次购买完可乐剩下的钱
int change = 0;
// sum表示总的可乐瓶数
int sum = 0; //0.5分
// 如果钱数大于可乐价格
while (money >= price) {//0.5分
// 购买可乐
temp = money / price; //0.5分
// 总可乐瓶数增加
sum += temp; //0.5分
// 计算买可乐剩下的钱
change = money % price; //0.5分
// 兑换可乐瓶子，计算剩余的总钱数
money = temp + change; //0.5分
}
// 输出结果
System.out.println(sum); //0.5分
}
}


2.写一个方法对任意数据类型数组进行排序。（6分）具体要求如下:
1)方法声明为public void sortArr(Object arr[]){ }
2)方法中首先输出排序前数组内容，然后进行排序，最后输出排序后数组内容。
3)可以是冒泡排序或其他算法实现，不直接调用Java提供的方法实现排序。
关键点：如何实现不同数据类型数组元素的大小比较

public void sort(Object [] arr){
//输出排序前数组 1分
for(int i=0;i<arr.length;i++){
System.out.println(arr[i]);
}
//大循环，一共n个元素，达到最终有序，至多n-1趟比较
Object temp;
for(int i=0;i<arr.length-1 ;i++){
//定义一个符号量
boolean flag = true;//没有交换，有序
//小循环
for(int j=0;j<arr.length-1-i;j++){
//如果前一个大于后一个
Comparables c1 = (Comparables)arr[j];
Comparables c2 = (Comparables)arr[j+1];
if(c1.compareTo(c2)>0){
//交换
temp = arr[j];
arr[j]=arr[j+1];
arr[j+1]=temp;
//修改符号量
flag = false;//交换过，无序
}
}
//判断经过此趟循环后是否已经有序
if(flag){
break;//退出外层循环，省略后续趟循环
}
}
//输出排序后数组
for(int i=0;i<arr.length;i++){
System.out.println(arr[i]);
}
}

3.实现List和Map数据的转换。（9分）具体要求如下：
功能1：定义方法public void listToMap( ){ }将List中Student元素封装到Map中
1)使用构造方法Student(int id,String name,int age,String sex )创建多个学生信息并加入List
2)遍历List，输出每个Student信息
3)将List中数据放入Map，使用Student的id属性作为key，使用Student对象信息作为value
4)遍历Map，输出每个Entry的key和value
功能2：定义方法public void mapToList( ){ }将Map中Student映射信息封装到List
1)创建实体类StudentEntry，可以存储Map中每个Entry的信息
2)使用构造方法Student(int id,String name,int age,String sex )创建多个学生信息，并使用Student的id属性作为key，存入Map
3)创建List对象，每个元素类型是StudentEntry
4)将Map中每个Entry信息放入List对象

在这里插入代码片public class TestListToMap {
public void listToMap () {
//1.创建多个学生信息
Student stu1 = new Student(110, "小明", 23, 98.0);
Student stu2 = new Student(111, "大刚", 21, 80.5);
Student stu3 = new Student(112, "小白", 12, 93.0);
//2.加入List
List<Student> list = new ArrayList<Student>();
list.add(stu1);
list.add(stu2);
list.add(stu3);
//3.遍历List，输出每个Student信息
for(Student stu:list){
System.out.println(stu);
}
//4.将List中数据放入Map，使用Student的id属性作为key
Map<Integer, Student> map = new HashMap<Integer, Student>();
Iterator<Student> it = list.iterator();
while(it.hasNext()){
Student stu = it.next();
map.put(stu.getId(), stu);
}
//5.遍历Map，输出每个Entry的key和value
Set<Entry<Integer,Student>> entrySet = map.entrySet();
for(Entry<Integer,Student> entry:entrySet){
System.out.println(entry.getKey()+"---->"+entry.getValue());
}
}
}

public class TestMapToList {
public void mapToList () {
//1.创建多个学生信息
Student stu1 = new Student(110, "小明", 23, 98.0);
Student stu2 = new Student(111, "大刚", 21, 80.5);
Student stu3 = new Student(112, "小白", 12, 93.0);
//2.使用Student的id属性作为key，存入Map
Map<Integer, Student> map = new HashMap<Integer, Student>();
map.put(stu1.getId(), stu1);
map.put(stu2.getId(), stu2);
map.put(stu2.getId(), stu3);
//3.创建List对象，每个元素类型是StudentEntry
List<StudentEntry> list = new ArrayList<StudentEntry>();
//4.将Map对象转化为List集合
for (Entry<Integer, Student> entry : map.entrySet()) {
StudentEntry studentEntry = new StudentEntry();
// 将map中的一个映射关系，封装为一个studentEntry对象
studentEntry.setKey(entry.getKey());
studentEntry.setStu(entry.getValue());
// 将studentEntry对象List集合
list.add(studentEntry);
}
//5.遍历Map
for (StudentEntry se : list) {
System.out.println(se.getKey() + "\t" + se.getStu());
}
}
}