javaSE试题

一、不定项选择题（共10小题，每题3分，共30分）

1、以下选项中是对一个Java源文件进行正确编译的语句是（ A ）。

A.    javac Test.java

B.    javac Test

C.    java Test

D.    java Test.class

 

2、以下选项中属于合法的Java标识符的是（ CD ）。

A.    public

B.    3num

C.    name

D.    _age

 

3、while循环和do-while循环的区别是（ D ）。

A.    没有区别，这两个结构在任何情况下效果一样

B.    while循环比do-while循环执行效率高

C.    while循环是先循环后判断，所以循环体至少被执行一次

D.    do-while循环是先循环后判断，所以循环体至少被执行一次

 

4、以下语句中关于Java构造方法的说法错误的是（ B ）。

A.    构造方法的作用是为创建对象进行初始化工作，比如给成员变量赋值

B.    一个Java类可以没有构造方法，也可以提供1个或多个构造方法

C.    构造方法与类同名，不能书写返回值类型

D.    构造方法的第一条语句如果是super()，则可以省略，该语句作用是调用父类无参数的构造方法

 

5、以下关于this和super关键字的说法错误的是（ BD ）。

A.    this关键字指向当前对象自身，super关键字指向当前对象的直接父类

B.    在main方法中可以存在this或super关键字。

C.    this和super关键字都可以访问成员属性，成员方法和构造方法

D.    在一个类的构造方法中可以同时使用this和super来调用其他构造方法

 

6、以下选项中关于int和Integer的说法错误的是（ BD ）。

A.    int是基本数据类型，Integer是int的包装类，是引用数据类型

B.    int的默认值是0，Integer的默认值也是0

C.    Integer可以封装了属性和方法提供更多的功能

D.    Integer i=5;该语句在JDK1.5之后可以正确执行，使用了自动拆箱功能

 

7、以下选项中关于Java集合的说法错误的是（ AC ）。

A.    List接口和Set接口是Collections接口的两个子接口

B.    List接口中存放的元素具有有序，不唯一的特点

C.    Set接口中存放的元素具有无序，不唯一的特点

D.    Map接口存放的是映射信息，每个元素都是一个键值对

 

8、在JAVA中，下列哪些说法是正确的( AC )  

A.    java源文件的扩展名为.java

B.    写好的java源程序可以直接运行

C.    编写的源程序必须先编译后才能运行

D.    程序员可以读懂扩展名为.class的文件

 

9、下面哪些赋值语句是正确的?( ABD )

A.   long l = 012;//正确,八进制数

B.   float f = -412;//正确

C.   int i = (int) true;//布尔型不能强转成整型

D.   double d = 0x12345678;//正确，在double的范围内。十六进制数

 

10、下面哪些函数是public void aMethod(){...}的重载函数?( BD ) 

A.   void aMethod( ){...}

B.   public int aMethod(int a, float b){...}

C.   public void aMethod (){...}

D.   public float aMethod (int m){…}

 

 

 

二、简答题（共10小题，每题5分，共50分）

1、JRE、JDK、JVM分别是什么？三者之间有什么联系？

答：JDK ：英文名称（Java Development Kit），Java 开发工具包。jdk 是整个 Java 开发的核心，它集成了 jre 和开发工具包。

JRE ：英文名称（Java Runtime Environment），我们叫它：Java 运行时环境。它主要包含两个部分，jvm 的标准实现和 Java 的一些基本类库。它相对于 jvm 来说，多出来的是一部分的 Java 类库。

JVM ：英文名称（Java Virtual Machine），就是我们耳熟能详的 Java 虚拟机。它只认识 xxx.class 这种类型的文件，它能够将 class 文件中的字节码指令进行识别并调用操作系统向上的 API 完成动作。jvm 是 Java 能够跨平台的核心。

这三者的关系是：一层层的嵌套关系，JDK 包含 JRE，JRE 包含 JVM；

 

2、Java中的基本类型有哪些？它们的字节数，bit数分别是多少？

答：Java中的基本数据类型只有8个：

byte（1个字节，8bit）、short（2个字节，16bit）、int（4个字节，32bit）、long（8个字节，64bit）、

float（4个字节，32bit）、double（8个字节，64bit）、char（2个字节，16bit）、boolean（1个字节，8bit）

 

 

 

3、是否可以继承String类，为什么？

答：String 类是final类，不可以被继承。

 

4、逻辑运算符中&和&&的相同点和不同点？

答：相同点：Java中&&和&都是表示与的逻辑运算符，都表示逻辑运输符and，当两边的表达式都为true的时候，整个运算结果才为true，否则为false。

不同点：&&的短路功能，当第一个表达式的值为false的时候，则不再计算第二个表达式；&则两个表达式都执行。

 

5、String、StringBuilder、StringBuffer之间的区别？

答：Java平台提供了两种类型的字符串：String和StringBuffer/StringBuilder，它们可以储存和操作字符串。其中String是只读字符串，也就意味着String引用的字符串内容是不能被改变的，一旦修改 String的值就是隐形的重建了一个新的对象，释放了原 String对象。而StringBuffer/StringBuilder类表示的字符串对象可变的，可以直接进行修改。StringBuilder是Java 5中引入的，线程不安全，它和StringBuffer的方法完全相同，区别在于它是在单线程环境下使用的，因为它的所有方面都没有被synchronized修饰，因此它的效率也比StringBuffer要高。

 

6、接口是否可以继承（extends）接口？抽象类是否可以实现（implements）接口？抽象类是否可以继承具体类？

答：接口可以继承接口，而且支持多重继承。抽象类可以实现(implements)接口，抽象类可继承具体类也可以继承抽象类。

 

7、阐述静态变量和实例变量的区别？

答：静态变量是被static修饰符修饰的变量，也称为类变量，它属于类，不属于类的任何一个对象，一个类不管创建多少个对象，静态变量在内存中有且仅有一个拷贝；实例变量必须依存于某一实例，需要先创建对象然后通过对象才能访问到它。静态变量可以实现让多个对象共享内存。

 

8、List、Map、Set三个接口存取元素时，各有什么特点？

答：List以特定索引来存取元素，有序，可以有重复元素。Set无序，不能存放重复元素（用对象的equals()方法来区分元素是否复）。Map保存键值对（key-value pair）映射。

 

9、阐述final、finally的区别。

答：

final：修饰符（关键字）有三种用法：1、类被声明为final，意味着它不能再派生出新的子类，即不能被继承；2、将变量声明为final，可以保证它们在使用中不被改变；被声明为final的变量必须在声明时给定初值，而在以后的引用中只能读取不可修改。3、被声明为final的方法不能在子类中被重写。

finally：通常放在try…catch…的后面，finally块中的代码总能执行，这就意味着程序无论正常执行还是发生异常，这里的代码只要JVM不关闭都能执行，可以将释放外部资源的代码写在finally块中。

 

10、阐述流的分类。

答：

1.输入流和输出流

按照流的流向来分，可以分为输入流和输出流。输入、输出都是从程序运行所在内存的角度来划分的。

输入流：只能从中读取数据，而不能向其写入数据。由InputStream和Reader作为基类

输出流：只能向其写入数据，而不能从中读取数据。由OutputStream和Writer作为基类

2.字节流和字符流

字节流和字符流的用法几乎完全一样，区别在于字节流和字符流所操作的数据单元不同。

字节流操作的数据单元是8位的字节，由InputStream和OutputStream作为基类。

字符流操作的数据单元是16位的字符，由 Reader和 Writer作为基类。

3.节点流和处理流

按照流的角色来分，可以分为节点流和处理流。

节点流：可以从向一个特定的IO设备（如磁盘、网络）读/写数据的流。也被称为低级流。

处理流：用于对一个已存在的流进行连接或封装，通过封装后的流来实现数据读/写功能。也称为高级流。

 

 

 

三、编程题（共2小题，每题20分，共40分）

注意：本大题需要把源码粘贴在对应题目下方，并且需要录制运行过程和运行结果视频。

 

1、假设1701班有40个学生，学号为170101~170140，全部参加Java集合阶段检测，给出所有同学的成绩（整数、随机产生，范围为50~100），请编写程序将本班各位同学成绩从高往低排序打印输出。

注：成绩相同时学号较小的先打印；要求：①打印的信息包含学号、姓名（姓名统一为“同学X”[X=01,02,03,...]和学号后两位一致）和成绩，具体格式参考截图。②遍历输出时使用迭代器

答：参考代码：

1. package com.gx.test;  
2.   
3. import java.util.ArrayList;  
4. import java.util.Collections;  
5. import java.util.Iterator;  
6. import java.util.List;  
7. import java.util.Random;  
8.   
9. public class TestOne {  
10.     public static void main(String[] args) {  
11.   
12.         List listStudent = new ArrayList<>();  
13.         Random random = new Random();  
14.         // 生成40个学生，并随机生成成绩  
15.         for (int i = 0; i < 40; i++) {  
16.             StudentOne student = new StudentOne();  
17.             student.setId(170101 + i);  
18.             String name = "";  
19.             if (i + 1 < 10) {  
20.                 name = "同学 0" + (i + 1);  
21.             } else {  
22.                 name = "同学 " + (i + 1);  
23.             }  
24.             student.setName(name);  
25.             // 注意这个随机范围 ，要能取到100  
26.             int score = random.nextInt(51) + 50;  
27.             student.setScore(score);  
28.             // 把学生添加到list中  
29.             listStudent.add(student);  
30.         }  
31.         // 对list进行排序  
32.         Collections.sort(listStudent);  
33.   
34.         // 使用迭代器遍历输出list  
35.         Iterator iterator = listStudent.iterator();  
36.         while (iterator.hasNext()) {  
37.             StudentOne studentOne = iterator.next();  
38.             System.out.println("学号：" + studentOne.getId()  
39.                     + ",姓名：" + studentOne.getName()  
40.                     + ",成绩：" + studentOne.getScore());  
41.         }  
42.     }  
43. }  
44.   
45. class StudentOne implements Comparable {  
46.   
47.     private int id;// 学号  
48.     private String name;// 姓名  
49.     private int score;// 成绩  
50.   
51.     public int getId() {  
52.         return id;  
53.     }  
54.   
55.     public void setId(int id) {  
56.         this.id = id;  
57.     }  
58.   
59.     public String getName() {  
60.         return name;  
61.     }  
62.   
63.     public void setName(String name) {  
64.         this.name = name;  
65.     }  
66.   
67.     public int getScore() {  
68.         return score;  
69.     }  
70.   
71.     public void setScore(int score) {  
72.         this.score = score;  
73.     }  
74.   
75.     @Override  
76.     public int compareTo(StudentOne o) {  
77.         if (this.score != o.score) {  
78.             return o.score - this.score;  
79.         } else {  
80.             return this.id - o.id;  
81.         }  
82.     }  
83. }  

或者：

1. package com.gx.test;  
2.   
3. import java.util.ArrayList;  
4. import java.util.Collections;  
5. import java.util.Comparator;  
6. import java.util.Iterator;  
7. import java.util.List;  
8. import java.util.Random;  
9.   
10. public class TestOne {  
11.     public static void main(String[] args) {  
12.   
13.         List students = new ArrayList<>();  
14.         Random random = new Random();  
15.         // 生成40个学生 并随机生成成绩  
16.         for (int i = 0; i < 40; i++) {  
17.             int number = 20190101 + i;  
18.             String name = "同学 ";  
19.             if (i < 9) {  
20.                 name += "0" + (i + 1);  
21.             } else {  
22.                 name += (i + 1);  
23.             }  
24.             int score = random.nextInt(51) + 50;  
25.   
26.             Student student = new Student(number, name, score);  
27.   
28.             // 添加到list  
29.             students.add(student);  
30.         }  
31.   
32.         // 排序  
33.         Collections.sort(students, new Comparator() {  
34.   
35.             @Override  
36.             public int compare(Student o1, Student o2) {  
37.                 if (o1.getScore() != o2.getScore()) {  
38.                     return o2.getScore() - o1.getScore();  
39.                 } else {  
40.                     return o1.getNumber() - o2.getNumber();  
41.                 }  
42.             }  
43.         });  
44.   
45.         // 使用迭代器迭代  
46.         Iterator iterator = students.iterator();  
47.         while (iterator.hasNext()) {  
48.             Student student = iterator.next();  
49.             System.out.println("学号：" + student.getNumber() + ",姓名：" + student.getName() + "，成绩：" + student.getScore());  
50.         }  
51.   
52.     }  
53. }  
54.   
55. class Student {  
56.     /** 
57.      * 学号 
58.      */  
59.     private int number;  
60.     /** 
61.      * 姓名 
62.      */  
63.     private String name;  
64.     /** 
65.      * 成绩 
66.      */  
67.     private int score;  
68.   
69.     public Student(int number, String name, int score) {  
70.         super();  
71.         this.number = number;  
72.         this.name = name;  
73.         this.score = score;  
74.     }  
75.   
76.     public int getNumber() {  
77.         return number;  
78.     }  
79.   
80.     public void setNumber(int number) {  
81.         this.number = number;  
82.     }  
83.   
84.     public String getName() {  
85.         return name;  
86.     }  
87.   
88.     public void setName(String name) {  
89.         this.name = name;  
90.     }  
91.   
92.     public int getScore() {  
93.         return score;  
94.     }  
95.   
96.     public void setScore(int score) {  
97.         this.score = score;  
98.     }  
99. }  

 

 

2、使用IO流的知识，复制文件夹。

要求：复制文件夹中的所有文件、目录，且保持目录结构不变

答：参考代码

1. package com.gx.test;  
2.   
3. import java.io.File;  
4. import java.io.FileInputStream;  
5. import java.io.FileOutputStream;  
6. import java.io.IOException;  
7.   
8. public class TestTwo {  
9.   
10.     public static void main(String[] args) throws IOException {  
11.   
12.         copyDir("D:/mycode/java2017", "E:/z/java2017");  
13.         System.out.println("复制完成！");  
14.     }  
15.   
16.     /** 
17.      * 复制目录 
18.      * @param fromDir 
19.      * @param toDir 
20.      * @throws IOException 
21.      */  
22.     public static void copyDir(String fromDir, String toDir)  
23.             throws IOException {  
24.         // 创建目录的File对象  
25.         File dirSouce = new File(fromDir);  
26.         // 判断源目录是不是一个目录  
27.         if (!dirSouce.isDirectory()) {  
28.             // 如果不是目录那就不复制  
29.             return;  
30.         }  
31.         // 创建目标目录的File对象  
32.         File destDir = new File(toDir);  
33.         // 如果目的目录不存在  
34.         if (!destDir.exists()) {  
35.             // 创建目的目录  
36.             destDir.mkdir();  
37.         }  
38.           
39.         // 获取源目录下的File对象列表  
40.         File[] files = dirSouce.listFiles();  
41.         for (File file : files) {  
42.             //拼接新的fromDir(fromFile)和toDir(toFile)的路径  
43.             String strFrom = fromDir + File.separator  
44.                     + file.getName();  
45.             String strTo = toDir + File.separator  
46.                     + file.getName();  
47.             // 判断File对象是目录还是文件  
48.             // 判断是否是目录  
49.             if (file.isDirectory()) {  
50.                 //递归调用 复制目录的方法  
51.                 copyDir(strFrom, strTo);  
52.             }  
53.             // 判断是否是文件  
54.             if (file.isFile()) {  
55.                 System.out.println("正在复制文件: "+file.getName());  
56.                 //调用 复制文件的方法  
57.                 copyFile(strFrom, strTo);  
58.             }  
59.         }  
60.     }  
61.   
62.     /** 
63.      * 复制文件 
64.      * @param fromFile 
65.      * @param toFile 
66.      * @throws IOException 
67.      */  
68.     public static void copyFile(String fromFile, String toFile)  
69.             throws IOException {  
70.         //字节输入流--读取文件  
71.         FileInputStream in = new FileInputStream(fromFile);  
72.         //字节输出流--写入文件  
73.         FileOutputStream out = new FileOutputStream(toFile);  
74.         //把读取到的内容写入新文件  
75.         //把字节数组设置大一些  1*1024*1024=1M  
76.         byte[] bs = new byte[1*1024*1024];  
77.         int count = 0;  
78.         while ((count = in.read(bs)) != -1) {  
79.             out.write(bs, 0, count);  
80.         }  
81.         //关闭流  
82.         in.close();  
83.         out.flush();  
84.         out.close();  
85.     }  
86. }