javaSE试题(三)
一、填空题（共20个题目，总计20分）
1.使用Java开发应用程序包括编写源程序，编译源程序，解释并运行三个步骤，其中Java源程序编译后生成的字节码文件的扩展名为 .class 。
2.在Java中，浮点型变量的类型有float和double两种，对于float型变量，内存分配4个字节，对于double型变量，内存分配 8 个字节。
3.在Java JDK1.7之前，switch只能支持byte、short、char、int或者其对应的封装类以及Enum类型。在JDK1.7中又加入了 String 类型。
4.在循环结构中，如果想跳出循环体，结束整个循环结构可以使用 break 语句。
5.类是组成Java程序的基本要素，类体有两部分构成：一部分是变量的定义，另一部分是 方法 的定义。
6. 方法重载 是指在一个类中可以有多个方法具有相同的名字，但这些方法的参数类型、个数、顺序必须不同，与方法的返回值和访问修饰符无关。
7. Package 关键字作为Java源文件的第一条非注释性语句，指明该源文件定义的类所有的包。
8.在Java中如果一个类中没有显示使用extends关键字标明这个类继承自哪个类，那么这个类就默认是 Object 的子类。
9.声明数组仅仅是给出了数组的名字和元素的数据类型，要想真正地使用数组还必须使用 new 关键字在堆内存中分配内存空间。
10.在Java中有二维数组int [ ] [ ] array={{1,2,3},{4,5}} ，可以使用 array[0].length 得到二维数组中第二维中第一个数组的长度。
11.在Java中使用java.lang包中的 StringBuffer 类来创建一个字符串对象，它代表一个字符序列可变的字符串，可以通过相应的方法改变这个字符串对象的字符序列。
12.在Java中每个Java基本类型在java.lang包中都在一个相应的包装类，把基本类型数据转换为对象，其中包装类Integer是 java.lang.Number 的直接子类。
13.对于一个已经不被任何引用变量引用的对象，当垃圾回收器准备回收该对象所占用的内存时，将自动调用该对象的 finalize() 方法。
14.Math类提供了许多数学运算的静态方法，其中 random() 方法是用来生成随机数的方法，其返回类型是double类型。
15.在Java中对于程序可能出现的检查时异常，要么用try…catch语句捕获并处理它，要么使用 throws 语句抛出它，由上一级调用者来处理。
16.read方法从输入流中顺序读取源中的单个字节数据，该方法返回字节值(0-255之间的一个整数)，如果到达源的末尾，该方法返回 -1 。
17.在Java中编写实现多线程应用有两种途径：一种是继承Thread类创建线程，另一种是实现 Runable 接口创建线程。
18. 链表 结构是一种由多个节点组成的数据结构，并且每个节点包含有数据以及指向下一个节点的引用。
19.在Java Socket网络编程中，开发基于TCP协议的服务器端程序使用的套接字是 ServerSocket 。
20.在Java中使用SAX解析XML文档主要有两个部分，一个是SAX解析器，一个是 事件处理器 。
二、选择题（共25个题目，总计25分）
-
在Java中，源文件Test.java中包含如下代码，则程序编译运行的结果是（ B ）。（选择一项）
public class Test {
public static void main(String[ ] args) {
system.out.println(“Hello!”);
}
}A 输出：Hello！
B. 编译出错，提示“无法解析system”
C. 运行正常，但没有输出任何内容
D. 运行时出现异常 -
在Java中，下面（ AB ）语句能正确通过编译。（选择两项）
A System.out.println(1+1);
B. char i =2+‘2’;
System.out.println(i);
C. String s=“on”+‘one’;
D. int b=255.0; -
分析如下Java代码，编译运行的输出结果是（ A ）。（选择一项）
public static void main(String[ ] args) {
boolean a=true;
boolean b=false;
if (!(a&&b)) {
System.out.print("!(a&&b)");
}else if (!(a||b)) {
System.out.println("!(a||b)");
}else {
System.out.println(“ab”);
}
}A !(a&&b)
B. !(a||b)
C. ab
D. !(a||b)ab -
在Java中有如下代码，则编译运行该类的输出结果是（ D ）。（选择一项）
public static void main(String[ ] args) {
for(int i=0;i<10;i++){
if (i%2!=0)
return;
System.out.print(i);
}
}A 13578
B. 02468
C. 0123456789
D. 0 -
在Java的程序类中如下方法定义正确的是（ A D ）。（选择两项）
A public int ufTest(int num){
int sum=num+100;
return sum;
}
B. public String ufTest(int num){
int sum=num+100;
return sum;
}
C. public void ufTest(int num){
int sum=num+100;
return sum;
}
D. public float ufTest(int num){
int sum=num+100;
return sum;
} -
分析下面的Java源程序，编译后的运行结果是（ B ）。（选择一项）
import java.util.*;
public class Test {
public static void main(String[ ] args) {
int [ ] numbers=new int[ ]{1,2,3};
System.out.println(Arrays.binarySearch(numbers, 2));
}
}
输出
A 输出：0
B. 输出：1
C. 输出：2
D. 输出：3 -
分析如下Java程序的代码所示，则编译运行后的输出结果是（C ）。（选择一项）
public class Test {
int count=9;
public void count1(){
count=10;
System.out.println(“count1=”+count);
}
public void count2(){
System.out.println(“count2=”+count);
}
public static void main(String[ ] args) {
Test t=new Test();
t.count1();
t.count2();
}
}A count1=9;
count2=9;
B. count1=10;
count2=9;
C. count1=10;
count2=10;
D. count1=9;
count2=10; -
在Java中，以下定义数组的语句正确的是（ CD）。（选择两项）
A int t[10]=new int[ ];
B. char [ ]a=”hello”;
C. String [ ] s=new String [10];
D. double[ ] d [ ]=new double [4][ ]; -
分析如下Java代码，该程序编译后的运行结果是（ D ）。（选择一项）
public static void main(String[ ] args) {
String str=null;
str.concat(“abc”);
str.concat(“def”);
System.out.println(str);
}A null
B. abcdef
C. 编译错误
D. 运行时出现NullPointerException异常 -
给定如下Java代码，编译运行后，输出结果是（ C ）。（选择一项）
public class Test {
public static void main(String[ ] args) {
StringBuffer a=new StringBuffer(“A”);
StringBuffer b=new StringBuffer(“B”);
operate(a, b);
System.out.println(a+","+b);
}
static void operate(StringBuffer x,StringBuffer y){
x=new StringBuffer(“BBB”);
y=x;
}
}A BBB,B
B. BBB,BBB
C. A,B
D. A,A -
给定如下Java程序，Test类中的四个输出语句输出结果依次是（ C ）。（选择一项）
class Person {
String name=“person”;
public void shout(){
System.out.println(name);
}
}
class Student extends Person{
String name=“student”;
String school=“school”;
}
public class Test {
public static void main(String[ ] args) {
Person p=new Student();
System.out.println(p instanceof Student);
System.out.println(p instanceof Person);
System.out.println(p instanceof Object);;
System.out.println(p instanceof System);
}
}A true,false,true,false
B. false,true,false,false
C. true,true,true,编译错误
D. true,true,false,编译错误
在Java中，LinkedList类与ArrayList类同属于集合框架类，下列（ CD ）选项中是LinkedList类有而ArrayList类没有的方法。（选择两项）
A add(Object o)
B. add(int index,Object o)
C. getFirst()
D. removeLast()
-
如下Java代码，输出的运行结果是（ A ）。（选择一项）
public class Test {
public static void main(String[ ] args) {
List list=new ArrayList();
list.add(“str1”);
list.add(2, “str2”);
String s=list.get(1);
System.out.println(s);
}
}A 运行时出现异常
B. 正确运行，输出str1
C. 正确运行，输出str2
D. 编译时出现异常 -
在Java中关于静态方法，以下说法中正确的是（ AC ）。（选择两项）
A 静态方法中不能直接调用非静态方法
B. 非静态方法中不能直接调用静态方法
C. 静态方法可以用类名直接调用
D. 静态方法里可以使用this -
如下Java代码运行的结果是（ B ）。（选择一项）
public class Test {
final int age;
public Test(){
age=10;
}
public static void main(String[ ] args) {
System.out.println(new Test().age);
}
}A 输出：0
B. 输出：10
C. 输出：null
D. 运行时出现异常 -
在Java中关于abstract关键字，以下说法正确的是（ AB ）。（选择两项）
A abstract类中可以没有抽象方法
B. abstract类的子类也可以是抽象类
C. abstract方法可以有方法体
D. abstract类可以创建对象 -
在Java中，下列关于读写文件的描述错误的是（ B ）。（选择一项）
A Reader类的read()方法用来从源中读取一个字符的数据
B. Reader类的read(int n )方法用来从源中读取一个字符的数据
C. Writer类的write(int n)方法用来向输出流写入单个字符
D. Writer类的write(String str)方法用来向输出流写入一个字符串 -
分析如下Java代码，有标注的四行代码中，有错误的是第（ D ）处。（选择一项）
import java.io.FileWriter;
import java.io.IOException;
public class Test {
public static void main(String[ ] args) {
String str = “Hello World”;
FileWriter fw = null;
try {
fw = new FileWriter(“c:\hello.txt”); // 1
fw.write(str); // 2
} catch (IOException e) {
e.printStackTrace(); // 3
} finally {
fw.close(); // 4
}
}
}A 1
B. 2
C. 3
D. 4 -
在Java的IO操作中，（ BD ）方法可以用来刷新流的缓冲。（选择两项）
A void release()
B. void close()
C. void remove()
D. void flush() -
下列关于线程的优先级说法中，正确的是（ BC ）。（选择两项）
A 线程的优先级是不能改变的
B. 线程的优先级是在创建线程时设置的
C. 在创建线程后的任何时候都可以重新设置
D. 线程的优先级的范围在1-100之间 -
下列关于Java线程的说法正确的是（ B ）。（选择一项）
A 每一个Java线程可以看成由代码、一个真实的CPU以及数据三部分组成
B. 创建线程的两种方法中，从Thread类中继承的创建方式可以防止出现多父类的问题
C. Thread类属于java.util程序包
D. 使用new Thread(new X()).run();方法启动一个线程 -
在Java网络编程中，使用客户端套接字Socket创建对象时，需要指定（ A ）。（选择一项）
A 服务器主机名称和端口
B. 服务器端口和文件
C. 服务器名称和文件
D. 服务器地址和文件 -
在Java的反射中关于代理说法正确的是（ BD ）。（选择两项）
A 动态代理类与静态代理类一样，必须由开发人员编写源代码，并进行编译
B. 代理类与被代理类具有同样的接口
C. 动态代理是public、final和abstract类型的
D. java.lang.reflect包中的Proxy类提供了创建动态代理类的方法 -
在编写XML 文件时，下列关于属性的声明说法正确的是（ AD ）。（选择两项）
A 标记中可以使用多个属性
B. 属性可以出现在起始标记或结束标记中
C. 属性是不区分大小写的
D. 属性值必须用引号引上 -
在使用UDP套接字通信时，常用（ D ）类把要发送的信息打包。（选择一项）
A String
B. DatagramSocket
C. MulticastSocket
D. DatagramPacket
三、判断题（共20个题目，总计10分，正确√，错误×）
1.Java语言是一种面向对象的语言，具有较好的安全性和可移植性及与平台无关等特性。（ 对 ）
2.假设有一个Java源程序文件，它只定义了一个具有public属性的类Hello，那么编译该文件的命令是“javac Hello”。（ 错 ）
3.在编译Java源程序时，计算机根本不会去识别各个变量名的具体含义，因此命名规范对编写Java程序而言不是必要的，而且有可能会降低编写Java源程序的效率。（ 错 ）
4.在Java中任何一个子类的构造方法都必须调用其父类的构造方法（包括隐式调用），并且调用父类的构造方法的语句必须是子类构造方法的第一条语句。（ 错 ）
5.Java语言为所有的Java程序自动导入包“java.lang”，因此Java程序可以直接用“java.lang”中的类和接口。（ 对 ）
6.Java中的类不允许多重继承，但接口支持多重继承。（ 对 ）
7.父类Person中定义了一个private void show()的方法，那么子类要重写这个方法时，方法的访问修饰符可以是默认的，protected或public。（ 错 ）
8.抽象方法不能含有方法体，并且必须定义在抽象类中。（ 错 ）
9.构造方法用于创建对象，一般不允许有任何返回值，因此需要在构造方法返回类型处标注为void。（ 错 ）
10.在Java中对象可以赋值，只要使用赋值运算符即可，相当于生成了一个各属性与赋值对象相同的新对象。（ 错 ）
11.Java允许创建不规则数组，即Java多维数组中各行的列数可以不同。（对 ）
12.在Java异常处理中可以使用多个catch子句，此时应将异常类的父类Exception放到第一个catch子中。（ 错 ）
13.与未加访问控制符的缺省情况相比，public和protected修饰符扩大了类及其属性和方法的被访问范围，private修饰符则缩小了这种范围。（ 对）
14.泛型是JavaSE1.7的新特性，泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。Java语言引入泛型的好处是安全简单。（ 错 ）
15.List是有序的Collection，使用此接口能够精确的控制每个元素插入的位置。用户能够使用索引来访问List中的无素，这类似于Java的数组。（ 对 ）
16.在使用File类中的delete()方法时，删除时可能文件不存在，所以我们最好先判断一下是否存在，不然会出现NullPointerException异常。（ 错 ）
17.当一个线程进入一个对象的一个synchronized方法后，其它线程不可以再进入该对象的其它方法执行。（ 对 ）
18.TCP/IP传输控制协议是Internet的主要协议，定义了计算机和外设进行通信的规则。TCP/IP网络参考模型包括七个层次：应用层、会话层、表示层、传输层、网络层、链路层和物理层。（ 错 ）
19.Java反射机制是指：Java程序可以加载一个运行时才得知名称的类，获悉其完整结构信息（但不包括methods定义），并生成其对象实体、或对其fields设值、或调用其methods。（ 对）
20.XML在不同的语言里解析方式都是一样的，只不过实现的语法不同而已。基本的解析方式有两种，一种叫SAX，另一种叫DOM。SAX是基于事件流的解析，DOM是基于XML文档树结构的解析。（ 对 ）
四、简答题（共5个题目，总计25分）
1.Java异常处理中，关键字try、catch、finally、throw、throws分别代表什么含义？（5分）
try：用来指定一块预防所有“异常”的程序。（1分）
catch:子右紧跟在try块后面，用于指定你想要捕捉的“异常”的类型。（1分）
finally:为确保一段代码不管发生什么“异常”都被执行一段代码。（1分）
throw:语句用来明确地抛出一个“异常”，在方法体中。（1分）
throws:用来标明一个方法可以抛出的各种“异常”，写在方法名的后面。（1分）
2.请你简述sleep( )和wait( )有什么区别？（5分）
sleep是线程类(Thread)的方法；（0.5分）作用是导致此线程暂停执行指定时间，给执行机会给其他线程，但是监控状态依然保持，到时后会自动恢复；（1分）调用sleep()不会释放对象锁。（1分）
wait是Object类的方法；（0.5分）对此对象调用wait方法导致本线程放弃对象锁，进入等 待此对象的等待锁定池。（1分）只有针对此对象发出notify方法(或notifyAll)后本线程才进入对象锁定池，准备获得对象锁进行运行状态。（1分）
3.请你简述HashMap和Hashtable的区别？（5分）
共同点：
1)二者都实现了Map接口，是将惟一键映射到特定的值上。（1分）
2)底层都采用哈希表作为存储结构，查询速度快，在很多情况下可互用。（1分）
主要区别：
1)Hashtable继承Dictionary类，HashMap是Java1.2引进的Map实现。（1分）
2)Hashtable的线程安全的，而HashMap不是。在多个线程访问Hashtable时，不需要自己为它的方法实现同步，而HashMap就必须为之提供外同步。（1分）
3)HashMap没有排序，允许一个null键和多个null值，而Hashtable不允许。（0.5分）
4)HashMap把Hashtable的contains( )去掉了，改成containsValue和containsKey，因为contains方法容易让人引起误解。（0.5分）
4.什么是设计模式？设计模式的作用？（5分）
设计模式是一套被反复使用的、多数人知晓、经过分类编目的优秀代码设计经验的总结。每个设计模式都是特定环境下特定问题的处理方法。（1分）
设计模式主要作用如下：
1)重用设计和代码。重用设计比重用代码更有意义，自动带来代码重用。（1分）
2)提高扩展性。大量使用面向接口编程，预留扩展插槽，新的功能或特性很容易加入到系统中来。（1分）
3)提高灵活性。通过组合提高灵活性，可以允许代码修改平稳发生，对一处的修改不会波及到很多其他模块。（1分）
4)提高开发效率。正确使用设计模式，可以节省大量的时间。（1分）
5.TCP/IP协议栈中，TCP协议和UDP协议的联系和区别？（5分）
联系
TCP和UDP是TCP/IP协议栈中传输层的两个协议，它们使用网络层功能把数据包发送到目的地，从而为应用层提供网络服务。（1分）
区别
- TCP是面向连接的传输。UDP是无连接的传输。（1分）
- TCP保证数据按照发送顺序到达，UDP无法保证。（1分）
- TCP是可靠性传输，而UDP则是不可靠传输。（1分）
- UDP因为少了很多控制信息，所以传输速度比TCP速度快。（0.5分）
- TCP适合用于传输大量数据，UDP适合用于传输小量数据。（0.5分） 比喻： TCP的server和client之间通信就好比两个人打电话。UDP的server和client之间的通信就像两个人发电报或者发短信。
通过生活案例正确说明TCP和UDP区别，可加分1分，但总分不超过5分
五、编码题（共3个题目，总计20分）
1.编写两个线程,一个线程打印1-52的整数，另一个线程打印字母A-Z。打印顺序为12A34B56C….5152Z。即按照整数和字母的顺序从小到大打印，并且每打印两个整数后，打印一个字母，交替循环打印，直到打印到整数52和字母Z结束。（8分）
打印类（共享资源）
public class Printer {
private int index=1;//设为1，方便计算3的倍数
//打印数字的方法，每打印两个数字，等待打印一个字母
public synchronized void print(int i){
while(index%3==0){
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.print(""+i);
index++;
notifyAll();
}
//打印字母，每打印一个字母，等待打印两个数字
public synchronized void print(char c){
while(index%3!=0){
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.print(""+c);
index++;
notifyAll();
}
}
打印字母线程
public class LetterPrinter extends Thread {
private Printer p;
public LetterPrinter(Printer p){
this.p=p;
}
public void run(){
for(char c='A';c<='Z';c++){
p.print(c);
}
}
}
打印数字线程
public class NumberPrinter extends Thread {
private Printer p;
public NumberPrinter(Printer p){
this.p=p;
}
public void run(){
for(int i=1;i<=52;i++){
p.print(i);
}
}
}
测试类
public class Test {
public static void main(String[] args) {
Printer p=new Printer(); //创建打印机对象
Thread t1=new NumberPrinter(p); //创建线程对象
Thread t2=new LetterPrinter(p); //创建线程对象
t1.start(); //启动线程
t2.start(); //启动线程
}
}
2.使用IO包中的类读取D盘上exam.txt文本文件的内容，每次读取一行内容，将每行作为一个输入放入ArrayList的泛型集合中并将集合中的内容使用加强for进行输出显示。（5分）
public class Test {
public static void main(String[] args) throws IOException {
String path="D:\\exam.txt";
outputMethod(path);
}
public static void outputMethod(String path) throws IOException {
List list = new ArrayList(); // 创建集合对象
// 创建缓冲区对象
BufferedReader br = new BufferedReader(new FileReader(path));
String line = br.readLine(); // 读取数据每次读一行
while (line != null) {
list.add(line);
line = br.readLine();
}
br.close(); //关闭
for(String s:list){
System.out.println(s);
}
}
}
3.使用反射机制完成学生对象的创建并输出学生信息。（7分）
学生类
public class Student {
private String name;//姓名
private int age;//年龄
private int score;//成绩
//…此处省略各个属性的getter和setter方法
public Student(String name, int age, int score) {
super();
this.name = name;
this.age = age;
this.score = score;
}
public Student() {
super();
}
@Override
public String toString() {
return name+"\t"+age+"\t"+score;
}
}
测试类
public class TestStudent {
public static void main(String[] args) throws Exception {
Scanner input = new Scanner(System.in);
System.out.println("请输入学员的信息:(如:mary:20:90)");
String info = input.next();
// 使用split方法进行分割
String[] spinfo = info.split(":");
// 调用Constructor的newInstance方法创建对象
Class clazz =
(Class) Class.forName("com.bjsxt.bean.Student");
Constructor cons =
clazz.getConstructor(String.class, int.class,int.class);
String name = spinfo[0];
int age = Integer.parseInt(spinfo[1]);
int score = Integer.parseInt(spinfo[2]);
Student stu = (Student) cons.newInstance(name,age,score);
System.out.println(stu);
}
}