JavaSE 软件工程师 认证考试试卷3

JavaSE 软件工程师

认证考试试卷

 

笔试

 

考试时间150分钟

总分 100分

 

姓    名_______________________

身份证号_______________________

准考证号_______________________

 

 

考试结束后考卷必须收回，否则考试成绩无效

 

尚学堂JavaSE软件工程师认证考试试卷

 

一、   
填空题（共20个题目，总计20分）

1. Java虚拟机就是一个虚拟的用于执行   字节码文件       的计算机。它是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. for循环的语法格式是for (表达式1;表达式2;表达式3) {循环体}，其中在整个循环过程中只执行一次的部分是  表达式1         。
   1. Java中    构造方法       方法与类名相同，没有返回值，在创建对象实例时由new运算符自动调用。
6. Package        语句作为Java源文件的第一条语句，指明该源文件定义的类所在的包。
7. 局部变量的名字与成员变量的名字相同，若想在该方法内使用成员变量，必须使用关键字 
    this        。
8. Java异常处理中，如果一个方法中出现了多个Checked异常，可以在方法声明中使用关键字 
    throws        声明抛出，各异常类型之间使用逗号分隔。
9. 声明数组仅仅是给出了数组名字和元素的数据类型，要想真正地使用数组还必须为它    分配内存空间                 。
   1. Arrays类的binarySearch( ) 方法使用二分搜索法来搜索指定的数组，以获得指定的值。必须在进行此调用之前对数组进行   排序 ，否则否则结果是不确定的。
   2. Object类有一个public方法是  toString()    ，一个对象通过调用该方法可以获得该对象的字符串表示。
   3. StringBuilder类是StringBuffer类的替代类，两者的共同点是都是可变长度字符串，其中线程安全的类是 
      StringBuffer 。
   4. Java集合框架提供了一套性能优良、使用方便的接口和类，包括Collection和Map两大类，它们都位于  java.util包中
   5. Treeset  
               是一种Collection类型的集合类，其中元素唯一，并采用二叉树作为存储结构，元素按照自然顺序排列。
   6. Java
      IO流可以分为节点流和处理流两大类，其中前者处于IO操作的第一线，所有操作必须通过他们进行。
   7. 处于新建状态的线程被启动后，将进入线程队列排队等待CPU服务，此时它已经具备了运行条件，一旦轮到享用CPU资源时，就可以脱离创建它的主线程独立开始自己的生命周期。上述线程是处于     就绪         状态。
   8. 在线程通信中，调用  wait()   方法可以是当前线程处于等待状态，而为了唤醒一个等待的线程，需要调用的方法是notify( )。
   9. 在Socket编程中，IP地址用来标志一台计算机，但是一台计算机上可能提供多种应用程序，使用   端口号           来区分这些应用程序。

 

二、   
选择题（共25个题目，总计25分）

 

1)	有一段Java 程序，其中public类名是A1，那么保存它的源文件名可以是（  A   ）。（选择一项）
	A	A1.java
	B.	A1.class
	C.	A1
	D.	都不对

2)	在Java中，byte数据类型的取值范围是（  A   ）。（选择一项）
	A	-128 ~ 127
	B.	-228 ~128
	C.	-255 ~ 256
	D.	-255 ~ 255

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

4)	以下选项中添加到代码中横线处会出现错误的是（  BD   ）。（选择二项）
	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; }

5)	阅读下列文件定入的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

6)	下面程序执行的结果是在屏幕上打印（    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

7)	以下四个选项中和下面代码功能相同的是（  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.	上述全对

8)	以下代码中错误的语句是（  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.	没有错误

9)	在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

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 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.	编译错误

13)	在Java中，关于引用数据类型的类型转换说法正确的是（AB     ）。（选择二项）
	A	引用数据类型的类型转换有向上转型和向下转型
	B.	向下转型，必须转换成其真实子类型，而不能随意转换
	C.	向下转型是自动进行的，也称隐式转换
	D.	向上转型可以使用instanceof操作符来判断转型的合法性

14)	在Java接口中，下列选项中属于有效的方法声明是（  AC   ）。（选择二项）
	A	public void aMethod( );
	B.	final void aMethod( );
	C.	void aMethod(){ }
	D.	private void aMethod( );

15)	以下选项中关于匿名内部类的说法正确的是（   BD  ）。（选择二项）
	A.		匿名内部类可以实现多个接口，或者继承一个父类
	B.		匿名内部类不能是抽象类，必须实现它的抽象父类或者接口里包含的所有抽象方法
	C.		匿名内部类没有类名，所以匿名内部类不等定义构造方法
	D.		匿名内部类可以直接访问外部类的所有局部变量
16)	阅读如下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.	编译错误

17)	关于Integer类中的静态方法parseInt()方法说法正确的是（ BD    ）。（选择二项）
	A	将小数转换成整数
	B.	将数字格式的字符串转成整数
	C.	使用parseInt()方法可能抛出异常
	D.	将单个字符转成整数

18)	以下程序片段中可以正常编译的是（   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";
19)	以下代码的执行结果是（ C   ）。（选择一项）
	Set<String> s=new HashSet<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 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

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

四、   
简答题（共5个题目，总计25分）

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

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

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

1. 创建线程的两种方式分别是什么？各有什么优缺点。（5分）
   1. 方式1：继承java.lang.Thread类，并覆盖run() 方法。（1分）

　　　　　　优势：编写简单；（0.5分）

　　　　　　劣势：无法继承其它父类（0.5分）

1. 1. 方式2：实现java.lang.Runnable接口，并实现run()方法。（1分）

　　　　　　优势：可继承其它类，多线程可共享同一个Thread对象；（1分）

　　　　　　劣势：编程方式稍微复杂，如需访问当前线程，需调用Thread.currentThread()方法（1分）

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);
     }
 }