JavaSE 软件工程师
认证考试试卷
笔试
考试时间150分钟
总分 100分
姓 名_______________________
身份证号_______________________
准考证号_______________________
考试结束后考卷必须收回,否则考试成绩无效
尚学堂JavaSE软件工程师认证考试试卷
一、
填空题(共20个题目,总计20分)
- Java虚拟机就是一个虚拟的用于执行 字节码文件 的计算机。它是Java最核心的技术,是Java跨平台的基础。
- 使用Java开发应用程序包括编写源程序,编译源程序,解释并运行三个步骤,其中编译和解释分别需要使用javac.exe和 java.exe
实现。 - 一个十进制整数转换成八进制数后是1234,则它转为十六进制数后是 29C 。
- Java中浮点数据类型包括float和double两种类型,其中float类型又被称作单精度类型,尾数可以精确到7位有效数字,在内存中占用 4 个字节。
- 使用Math.random( )返回带正号的 double值,该值大于等于0.0且小于1.0。使用该函数生成[30,60]之间的随机整数的语句是:(int)(Math.random(
)*31)+30。
- 使用Math.random( )返回带正号的 double值,该值大于等于0.0且小于1.0。使用该函数生成[30,60]之间的随机整数的语句是:(int)(Math.random(
- for循环的语法格式是for (表达式1;表达式2;表达式3) {循环体},其中在整个循环过程中只执行一次的部分是 表达式1 。
- Java中 构造方法 方法与类名相同,没有返回值,在创建对象实例时由new运算符自动调用。
- Package 语句作为Java源文件的第一条语句,指明该源文件定义的类所在的包。
- 局部变量的名字与成员变量的名字相同,若想在该方法内使用成员变量,必须使用关键字
this 。 - Java异常处理中,如果一个方法中出现了多个Checked异常,可以在方法声明中使用关键字
throws 声明抛出,各异常类型之间使用逗号分隔。 - 声明数组仅仅是给出了数组名字和元素的数据类型,要想真正地使用数组还必须为它 分配内存空间 。
- Arrays类的binarySearch( ) 方法使用二分搜索法来搜索指定的数组,以获得指定的值。必须在进行此调用之前对数组进行 排序 ,否则否则结果是不确定的。
- Object类有一个public方法是 toString() ,一个对象通过调用该方法可以获得该对象的字符串表示。
- StringBuilder类是StringBuffer类的替代类,两者的共同点是都是可变长度字符串,其中线程安全的类是
StringBuffer 。 - Java集合框架提供了一套性能优良、使用方便的接口和类,包括Collection和Map两大类,它们都位于 java.util包中
- Treeset
是一种Collection类型的集合类,其中元素唯一,并采用二叉树作为存储结构,元素按照自然顺序排列。 - Java
IO流可以分为节点流和处理流两大类,其中前者处于IO操作的第一线,所有操作必须通过他们进行。 - 处于新建状态的线程被启动后,将进入线程队列排队等待CPU服务,此时它已经具备了运行条件,一旦轮到享用CPU资源时,就可以脱离创建它的主线程独立开始自己的生命周期。上述线程是处于 就绪 状态。
- 在线程通信中,调用 wait() 方法可以是当前线程处于等待状态,而为了唤醒一个等待的线程,需要调用的方法是notify( )。
- 在Socket编程中,IP地址用来标志一台计算机,但是一台计算机上可能提供多种应用程序,使用 端口号 来区分这些应用程序。
二、
选择题(共25个题目,总计25分)
1) |
有一段Java 程序,其中public类名是A1,那么保存它的源文件名可以是( A )。(选择一项) |
|
A |
A1.java |
|
B. |
A1.class |
|
C. |
A1 |
|
D. |
都不对 |
2) |
在Java中,byte数据类型的取值范围是( A )。(选择一项) |
|
A |
-128 |
|
B. |
-228 |
|
C. |
-255 |
|
D. |
-255 |
3) |
有以下方法的定义,请选择该方法的返回类型( |
|
|
method(byte return (short)x/y*2; } |
|
A |
byte |
|
B. |
short |
|
C. |
int |
|
D. |
double |
4) |
以下选项中添加到代码中横线处会出现错误的是( BD )。(选择二项) |
|
|
public class Test { public float aMethod(float return 0; } } |
|
A |
public float aMethod(float a, float b, float 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; } |
5) |
阅读下列文件定入的Java代码,其执行结果是( D )。(选择一项) |
|
public class Test { public static void 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 |
6) |
下面程序执行的结果是在屏幕上打印( B )次Java基础班。(选择一项) |
|
for(int if (i<5) continue; System.out.println("Java基础班"); } |
||
A |
5 |
|
B. |
6 |
|
C. |
7 |
|
D. |
8 |
7) |
以下四个选项中和下面代码功能相同的是( B )。(选择一项) |
|
int i = 1; int sum = 0; while (i <= 100) { if (i % 2 == 0) sum = sum + i; i++; } |
||
A |
for (int x =1; |
|
B. |
for (int x =0; |
|
C. |
for (int x =1; |
|
D. |
上述全对 |
8) |
以下代码中错误的语句是( |
|
public class Something{ public static void final Other o=new new } public void addOne( o.i++;//2 o = new Other();//3 } } class Other{ public int i; } |
||
A |
1 |
|
B. |
2 |
|
C. |
3 |
|
D. |
没有错误 |
9) |
在Java中,以下程序编译运行后的输出结果为( D )。(选择一项) |
|
public class Test { int x, y; Test(int x, int y) { this.x = x; this.y = y; } public static void Test pt1, pt2; pt1 = new Test(3, 3); pt2 = new Test(4, 4); System.out.print(pt1.x } } |
||
A |
6 |
|
B. |
34 |
|
C. |
8 |
|
D. |
7 |
10) |
下列选项中关于Java中类方法的说法错误的是( A C )。(选择二项) |
|
A |
在类方法+中可用this来调用本类的类方法 |
|
B. |
在类方法中调用本类的类方法时可直接调用 |
|
C. |
在类方法中只能调用本类中的类方法 |
|
D. |
在类方法中调用实例方法需要先创建对象 |
11) |
下列选项中关于Java中super关键字的说法正确的是( AD )。(选择一项) |
|
A |
super关键字是在子类对象内部指代其父类对象的引用 |
|
B. |
super关键字不仅可以指代子类的直接父类,还可以指代父类的父类 |
|
C. |
子类通过super关键字只能调用父类的方法,而不能调用父类的属性 |
|
D. |
子类通过super关键字可以调用父类的构造方法 |
12) |
编译运行如下Java代码,输出结果是( D )。(选择一项) |
|
class Base { public void System.out.print ("Base } } class Child extends public void System.out.print ("Child } } 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. |
编译错误 |
13) |
在Java中,关于引用数据类型的类型转换说法正确的是(AB )。(选择二项) |
|
A |
引用数据类型的类型转换有向上转型和向下转型 |
|
B. |
向下转型,必须转换成其真实子类型,而不能随意转换 |
|
C. |
向下转型是自动进行的,也称隐式转换 |
|
D. |
向上转型可以使用instanceof操作符来判断转型的合法性 |
14) |
在Java接口中,下列选项中属于有效的方法声明是( AC )。(选择二项) |
|
A |
public |
|
B. |
final |
|
C. |
void aMethod(){ } |
|
D. |
private |
15) |
以下选项中关于匿名内部类的说法正确的是( BD )。(选择二项) |
||
A. |
匿名内部类可以实现多个接口,或者继承一个父类 |
||
B. |
匿名内部类不能是抽象类,必须实现它的抽象父类或者接口里包含的所有抽象方法 |
||
C. |
匿名内部类没有类名,所以匿名内部类不等定义构造方法 |
||
D. |
匿名内部类可以直接访问外部类的所有局部变量 |
||
16) |
阅读如下Java代码,在控制台输入"-1",执行结果是(B)。(选择一项) |
||
public class Demo { public static void Scanner input = new System.out.print("请输入数字:"); try { int num = if (num < throw } } catch System.out.println("InputMismatchException"); } catch (Exception e) System.out.println(e.getMessage()); } } } |
|||
A |
输出:InputMismatchException |
||
B. |
输出:必须在1-4之间! |
||
C. |
什么也没输出 |
||
D. |
编译错误 |
||
17) |
关于Integer类中的静态方法parseInt()方法说法正确的是( BD )。(选择二项) |
|
A |
将小数转换成整数 |
|
B. |
将数字格式的字符串转成整数 |
|
C. |
使用parseInt()方法可能抛出异常 |
|
D. |
将单个字符转成整数 |
18) |
以下程序片段中可以正常编译的是( C )。(选择一项) |
||
A |
String s = String k = String t = |
||
B. |
String s = String t; t = |
||
C. |
String s = String |
||
D. |
String s = String t = s |
||
19) |
以下代码的执行结果是( C )。(选择一项) |
||
|
Set<String> 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 |
||
20) |
File类中的isDirectory( )方法的作用是( BD )。(选择二项) |
|
A. |
判断File对象封装的是否是文件 |
|
B. |
判断File对象封装的是否是目录 |
|
C. |
判断File对象中封装的是否是根目录 |
|
D. |
返回值类型是boolean |
21) |
阅读下列文件定入的JAVA代码,共有( C )处错误。(选择一项) |
|
import java.io.*; public class TestIO { public static void String str ="文件写入练习"; FileWriter fw = null; //1 try{ fw = new fw.writerToEnd(str); //3 }catch(IOException e.printStackTrace(); }finally{ //此处省略关闭流 } } } |
||
A |
0 |
|
B. |
1 |
|
C. |
2 |
|
D. |
3 |
22) |
以下选项中关于Java中线程控制方法的说法正确的是( AD )。(选择二项) |
|
A. |
join ( ) 的作用是阻塞指定线程等到另一个线程完成以后再继续执行 |
|
B. |
sleep ( |
|
C. |
yield ( ) 的作用是使线程停止运行一段时间,将处于阻塞状态 |
|
D. |
setDaemon( |
|
23) |
Java中线程安全问题是通过关键字( C )解决的?。(选择一项) |
|
A. |
finally |
|
B. |
wait( ) |
|
C. |
synchronized |
|
D. |
notify( ) |
|
24) |
ServerSocket的监听方法accept( )方法的返回值类型是( |
|
A. |
Socket |
|
B. |
void |
|
C. |
Object |
|
D. |
DatagramSocket |
|
25) |
以下选项中关于Java中获取Class对象的方式正确的是( C D )。(选择二项) |
|
A. |
Class c1 = |
|
B. |
String str = new String(“bjsxt”); Class clazz = str.class; |
|
C. |
Class c1 = |
|
D. |
Class |
三、
判断题(共20个题目,总计10分,正确√,错误×)
- 和C++相比,Java取消了指针,不再有多重继承,不需要手动回收垃圾。( T)
- Java具有一次编译,到处运行的特点,其含义是Java的源代码可以一次性编译成计算机的机器码,并在不同的平台上运行。( F )
- char 数据类型用来表示在ASCII编码表中的一个字符,在内存中占用1个字节空间,所以不能表示一个汉字。( F )
- 赋值和条件运算符是运算级别最低的两种运算符,两者都具有自右向左的结合性。( T )
- 多重循环是指一个循环体内又包含另一个完整的循环结构。外层循环变量变化一次,内层循环变量要从头到尾变化一遍。( T )
- 任何可用递归解决的问题也能使用循环解决,递归既花时间又耗内存,在要求高性能的情况下尽量避免使用递归。( T )
- 访问权限是private的变量,只能在本类和与本类同一个包中的其他类使用。( F )
- 对于子类创建的一个对象,如果子类继承了父类的方法,未重写,则运行时调用子类的方法。( F )
- ArithmeticException,ArrayIndexOutOfBoundsException,NullPointerException是运行时异常,而ClassNotFoundException,ClassCastException是Checked异常。(F )
- 数组的长度是确定的,数组一旦被创建,它的大小就是不可以改变的。但是其元素类型可以是不同类型,允许出现混合类型。( F )
- 创建数组后,系统会给每个数组元素一个默认值,如double型元素的默认值是0.0。( T )
- JK1.5后提供了自动装箱和自动拆箱功能,从而可以实现基本数据类型和对应包装类之间的自动转换,简化了操作。( T )
- java.sql.Date类和java.util.Date类的关系是前者是后者的父类,其中前者没有提供无参数构造方法,而后者可以提供无参数构造方法来获取当前时间。( F )
- Collection是Java集合*接口,其中的元素无序,唯一。Java平台不提供这个接口任何直接的实现。( T )
- Iterator接口可以遍历任何Collection接口的实现类,可以从一个Collection中使用iterator( )方法来获取迭代器实例。迭代器取代了Java集合框架中的Enumeration。(T )
- 序列化是指将字节序列转换成Java对象,只有实现了Serializable接口的类的对象才可以被序列化。(F )
- 一个进程可以包括多个线程。两者的一个主要区别是:线程是资源分配的单位,而进程CPU调度和执行的单位。( F )
- 用new关键字建立一个线程对象后,该线程对象就处于新生状态。处于新生状态的线程有自己的内存空间,通过调用start进入就绪状态。( T )
- TCP协议是一种面向无连接的、可靠的、基于字节流的传输层通信协议,该协议占用系统资源多、效率较低。( F
) - Java反射技术中,对于一个private修饰的成员变量,可以再设置setAccessible(true)后进行暴力访问。( T )
四、
简答题(共5个题目,总计25分)
- 面向过程和面向对象的区别。(5分)
- 编程思路不同: 面向过程以实现功能的函数开发为主,而面向对象要首先抽象出类、属性及其方法,然后通过实例化类、执行方法来完成功能。(1分)
- 封装性:都具有封装性,但是面向过程是封装的是功能,而面向对象封装的是数据和功能。(1分)
- 面向对象具有继承性和多态性,而面向过程没有继承性和多态性,所以面向对象优势是明显。(1分)
- 面向对象耦合性低,更利于修改维护。(盖浇饭/蛋炒饭)。(1分)
- 面向过程更适合解决简单问题。面向对象更适合解决复杂问题。(1分)
- Error和Exception的区别。(5分)
- Error类,表示仅靠程序本身无法恢复的严重错误,比如说内存溢出、动态链接异常、虚拟机错误。(1分)应用程序不应该抛出这种类型的对象。假如出现这种错误,除了尽力使程序安全退出外,在其他方面是无能为力的。(1分)
- Exception类,由Java应用程序抛出和处理的非严重错误,比如所需文件没有找到、零作除数,数组下标越界等。(1分)它的各种不同子类分别对应不同类型异常。可分为两类:Checked异常和Runtime异常。(1分)所以在进行程序设计时,应该更关注Exception类。(1分)
- 列举常用的字节输入流和输出流并说明其特点,至少5对。(5分)
- FileInputStream和FileOutputStream 节点流 以文件为数据源和目的地(1分)
- BufferedInputStream和BufferedOutputStream 处理流 提供了缓冲功能,提高读写效率(1分)
- DataInputStream和DataOutputStream 处理流 提供了方便读写基本数据类型和String数据的方法(1分)
- ObjectInputStream和ObjectOutputStream 处理流 不仅提供了方便读写基本数据类型和String数据的方法,也提供了读写引用类型数据的方法(1分)
- ByteArrayInputStream和ByteArrayOutputStream 节点流 以字节数组为数据源和目的地(1分)
- 创建线程的两种方式分别是什么?各有什么优缺点。(5分)
- 方式1:继承java.lang.Thread类,并覆盖run() 方法。(1分)
优势:编写简单;(0.5分)
劣势:无法继承其它父类(0.5分)
- 方式2:实现java.lang.Runnable接口,并实现run()方法。(1分)
优势:可继承其它类,多线程可共享同一个Thread对象;(1分)
劣势:编程方式稍微复杂,如需访问当前线程,需调用Thread.currentThread()方法(1分)
- 简述基于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分)
关闭DatagramSocket。(0.5
五、 编码题(共3个题目,总计20分)
1. 给20块钱买可乐,每瓶可乐3块钱,喝完之后退瓶子可以换回1块钱,问最多可以喝到多少瓶可乐。(5分)
public static void main(String[] args) {
int a = 20;//当前的钱数
int price = 3;//可乐单价
int sum = 0;//喝可乐数量
int cola = 0;//可乐瓶子换的钱
int s = 0;//剩下的钱
while(a>price){
cola = a/price;//可乐瓶子数量
sum+=cola;//喝可乐数量
s=a%price;//剩下的钱
a =cola+s;//当前的钱=瓶子换的钱+剩下的钱
}
System.out.println("最多可以喝到:"+sum+"瓶可乐");
}
2. 写一个方法对任意数据类型数组进行排序。(6分)具体要求如下:
1) 方法声明为public void sortArr(Object arr[]){ }
2) 方法中首先输出排序前数组内容,然后进行排序,最后输出排序后数组内容。
3) 可以是冒泡排序或其他算法实现,不直接调用Java提供的方法实现排序。
关键点:如何实现不同数据类型数组元素的大小比较 public class Array_2 {
public void sortArr(int arr[]){
int temp = 0;
for(int i=0;i<arr.length;i++) {
for(int j=i+1;j<arr.length;j++) {
if(arr[i]>arr[j]){
temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}
}
System.out.println(Arrays.toString(arr));
}
public static void main(String[] args) {
int[] arr ={10,25,110,-20,18,-36,65,14,3};
Array_2 a =new Array_2();
a.sortArr(arr);
} } 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 Student_3 {
/**
* 使用构造方法Student(int id,String name,int age,String sex )
*/
private int id;
private String name;
private int age;
private String sex; public Student_3() {
} public Student_3(int id, String name, int age, String sex) {
this.id = id;
this.name = name;
this.age = age;
this.sex = sex;
} public int getId() {
return id;
} public String getName() {
return name;
} public int getAge() {
return age;
} public String getSex() {
return sex;
} public void setId(int id) {
this.id = id;
} public void setName(String name) {
this.name = name;
} public void setAge(int age) {
this.age = age;
} public void setSex(String sex) {
this.sex = sex;
} @Override
public String toString() {
return "["+id +" "+ name +" "+ age +" "+ sex+"]";
}
}
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set; public class Test_3 {
//List集合转Map集合
public void listToMap(Student_3 s1,Student_3 s2 ){
//1.创建List集合
List<Student_3> list = new ArrayList<>();
//2.创建Map集合
Map<Integer, Student_3> map = new HashMap<>();
//3.传入学生对象
list.add(s1);
list.add(s2);
Iterator<Student_3> it = list.iterator();
//4.遍历List集合
while(it.hasNext()){
Student_3 stu = it.next();
//5.将学生id作为Map集合的Key,学生对象作为Map集合的Vaul
map.put(stu.getId(), stu);
}
//6.遍历Map集合
Set<Entry<Integer, Student_3>> entrySet = map.entrySet();
for (Entry<Integer, Student_3> en : entrySet) {
System.out.println(en);
} } //Map集合转List集合
public void mapToList(Student_3 s3,Student_3 s4){
//1.创建Map集合
Map< Integer, Student_3> map = new HashMap<>();
//2.创建List集合
List<Student_3> list = new ArrayList<>();
//3.将学生id作为Map集合的Key,学生对象作为Map集合的Vaul
map.put(s3.getId(),s3);
map.put(s4.getId(),s4);
//4.遍历Map集合
Set<Entry<Integer, Student_3>> entrySet = map.entrySet();
for (Entry<Integer, Student_3> e : entrySet) {
//5.将Map集合的值加入到Liat集合中
list.add(e.getValue());
}
//6.遍历List集合
Iterator<Student_3> it = list.iterator();
while(it.hasNext()){
System.out.println(it.next());
} }
public static void main(String[] args) {
//创建四个学生对象
Student_3 s1 = new Student_3(101, "张三", 25, "男");
Student_3 s2 = new Student_3(102, "马琴", 25, "女");
Student_3 s3 = new Student_3(103, "赵薇", 36, "女");
Student_3 s4 = new Student_3(104, "李小梅", 31, "女");
//创建Test_3的实例
Test_3 t = new Test_3();
System.out.println("List集合转Map集合");
//调用List集合转Map集合方法并传入学生对象s1,s2
t.listToMap(s1,s2);
System.out.println("\n");
System.out.println("Map集合转List集合");
//调用Map集合转List集合方法并传入学生对象s3,s4
t.mapToList(s3, s4);
}
}