JAVA习题(一)

一、选择题（共20题，每题2分，少选错选不得分，共40分）
1、【单选题】
以下（D）不是Object类的方法
A. split(）
B. equals()
C. toString（）
D. hasNext（）
解析:split(),equals(),toString()都是Object类中的方法，hasNext（）不是

2、【单选题】
阅读下面程序段:
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(“bos.txt”));
bos.write( “hello”.getBytes(“utf-8”)));
假设bos.txt不存在，运行该程序段后，文件bos.txt的字节数为（）
A.5
B.10
C.4
D.0
正确答案：D
此题目考查的是缓冲流写的操作。 缓冲流执行写的操作，只是将内容写入到缓冲区中，并没有真正写入文件 所以程序执行后，文件中并没有数据，要想真正写入数据需要调用flush()方法。
选项D正确。

3、【单选题】
String[] arr = new String[3];
System.out.println(arr[0].length());
运行结果是（ ）。
A.会出现编译错误。
B.运行期会抛出ArithmeticException异常
C.运行期会抛出IOException异常
D.运行期会抛出NullPointerException异常
正确答案：D
此题目考查的是当对一个null值的对象，访问其属性或方法
程序会出现NullPointerException异常。

4、【单选题】
请看下列代码：
public class Foo {
public static void main (String[]args) throws Exception {
String name = “tarena”;
byte[] c = name.getBytes();//将字符串按默认字符集转换为一组字节
try {
File f = new File(“company.txt”);//创建File对象
FileOutputStream out = new FileOutputStream(f, true);
out.write©;
out.close();
}catch (IOException e) {}
}
}
假设文件company.txt中已存在一些内容，则关于上述代码的说法正确的是：（D）。
A.编译错误
B.程序可以通过编译，运行后文件company.txt没有任何改变
C.程序可以通过编译，运行后文件company.txt的长度变为0
D.程序可以通过编译，运行后company.txt文件末尾增加了字符串“tarena”
解析: FileOutputStream有两种构造方法:
FileOutputStream(File file):是覆盖操作
FileOutputStream(File file,Boolean b):是追加操作

5、【单选题】
下列代码运行的结果是：（B）
public class Boxer {
Integer i;
int x;
public Boxer(int y) {
x = i + y;
System.out.println(x);
}
public static void main(String[] args) {
new Boxer(new Integer(4));
}
}
A.输出：4
B.在运行时抛出NullPointerException异常
C.在运行时抛出NumberFormatException异常
D.在运行时抛出IllegalStateException异常
解析:Integer包装类型属于引用类型,引用类型默认值为null,Integer i未进行整型数值初始化,所以在调用时运行到x=i+y;时无法进行运算,会抛出空指针异常.

6、【单选题】
在异常处理中，如释放资源、关闭文件、关闭数据库连接等由（ ）来完成。
A.try子句
B.catch子句
C.finally子句
D.throw子句
正确答案：C
此题目考查的是finally语句块的功能。
为了保证资源释放，会将资源释放的语句在finally语句块中。
　
7、【单选题】
下列关于多线程中锁机制正确的是（ ）。
A.关键字synchronized只能用于方法声明上。
B.成员方法使用synchronized，那么当前方法的锁对象为当前方法所属的对象
C.静态方法使用synchronized，那么当前方法的锁对象为当前方法所属对象
D.为了尽量避免多线程带来的安全问题，尽可能的扩大synchronized修饰的代码范围。
正确答案：B
此题目考查的是锁机制。
选项A错误，synchronized可以用在方法声明上，也可以用在代码块上
实例方法使用synchronized，那么当前方法的锁对象为当前方法所属的对象
静态方法使用synchronized，那么当前方法的锁对象为当前类的字节码文件对象
选项B正确。选项C错误
选项D错误，为了提高并发的执行效率，应当尽量在允许的情况下减少同步范围

8、【单选题】
下列代码编译和运行的结果是：（C）。
public class Threads5 {
public static void main(String[] args) {
new Thread(new Runnable() {
public void run() {
System.out.print(“bar”);
}
}).start();
}
}
A.编译错误
B.抛出运行时异常
C.输出：bar
D.代码正常运行，但是无输出
解析:使用匿名内部类实现Runnable()接口创建线程的方式,重写Runnable接口内的run方法,但是启动线程的方法在此接口中没有,所以还需要创建其实现类对象,然后调用实现类的start方法启动线程.

9、【单选题】
线程调用了sleep()方法后，该线程将进入( C )状态
A.就绪状态 B.运行状态 C.阻塞状态 D.终止状态
解析:sleep()方法调用后会阻塞指定时间毫秒数,当时间到了后会自动回到可运行状态等待分配时间片再次运行该线程.
　
10、【单选题】
哪个关键字可以对对象加锁？( B )
A.transient B.synchronized C.serialize D.static
解析: synchronized是线程对象锁,可以起到同步效果以及互斥效果.
　
11、【单选题】
List和Set集合的上层接口是( B )
A. java.util.Map B. java.util.Collection C. java.util.List D. java.util.Set
解析:List和Set集合接口继承自Collection接口,Map 则不是
　
12、【单选题】
请看下列代码的输出结果是：（D）。
public static void main(String[] args) {
List list = new ArrayList();
for (int i = 0; i < 10; i++) {//循环10次后该集合的元素为[0,1,2,3,4,5,6,7,8,9]
list.add(i);
}
List subList = list.subList(4, 9); //子集合为[4,5,6,7,8]
for (int i = 0; i < subList.size(); i++) { //循环5次
subList.set(i, subList.get(i) * 10); //每次循环将对应下标位置的元素乘以10,
//[40,50,60,70,80]
}
System.out.println(list);//subList获取的List与原List占有相同的存储空间，对 子List的操作会影响的原List
}
A.[0, 1, 2, 3, 40, 50, 60, 70, 80, 90]
B.[0, 1, 2, 3, 4, 50, 60, 70, 80, 90]
C.[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
D.[0, 1, 2, 3, 40, 50, 60, 70, 80, 9]
解析:subList获取的List与原List占有相同的存储空间，对子List的操作会影响的原List。

13、【单选题】
请看以下代码：
Map<String,Double> map=new HashMap<String,Double>();
map.put(“tom”,123.6);
map.put(“jim”,234.5);
map.put(“jerry”,45.3);
《插入代码》
《插入代码》处要实现的功能是把key为"jim"的value值在原有数字的基础上加100
正确的是（A）。
A.map.put(“jim”,map.get(“jim”)+100);
B.map.set(“jim”,map.get(“jim”)+100);
C.map.put(“jim”,234.5);
D.map.set(“jim”,234.5);
解析：本题考查修改Map集合中的元素。
Map中的key值不能相同，如果想修改Map中某个元素的vlaue值
即为向Map中添加key相同，value不同的元素，即是覆盖原来的元素
选项BD错误，Map集合中没有set方法。
选项AC语法正确，C没有完成需求，没有加100

14、【单选题】
ArrayList类的底层数据结构是( A )
A. 数组结构 B. 链表结构 C.哈希表结构 D.红黑树结构
解析:ArrayList的底层数据结构是数组结构,LinkedList底层是链表结构.
15、【单选题】
阅读下面XML文档，然后判断下列说法正确的是（ ）。

TEDU

北京海淀

A.是元素对象，同样也是文本对象 B.是元素对象，同样也是文本对象 C.北京海淀是文本对象 D.北京海淀是元素对象 正确答案：C 此题目考查的是XML文档中元素的含义 如都是元素对象 元素中的文本，都属于文本对象

16、【多选题】
下列异常类中，属于RuntimeException的子类的是：（ ）。
A.FileNotFoundException
B.IOException
C.ClassCastException
D.ArrayIndexOutOfBoundsException
正确答案：CD
此题目考查的是Java中异常类型的分类。
Java中有两种异常，检查异常和运行时异常，检查异常必须处理，运行时异常可以不处理，选项AB为检查异常，CD为运行时异常，即为RuntimeException的子类，选项CD正确。

17、【多选题】
下面哪些是Thread类的方法（ABD）
A start() B run() C exit() D getPriority()
解析：A: start()启动线程的方法
B: run()线程的运行方法
D:getPriority()返回线程的优先级
exit()是System类的方法，如System.exit(0)。终止虚拟机也就是退出你的Java程序.
　
18、【多选题】
关于集合框架，说法正确的是（ ）。
A.与数组不同，集合框架是容量可变的容器
B.集合框架不能保存基本类型，但是可以将它们转换为包装类后保存
C.集合框架中的List, Set, Map接口都是Collection接口的子接口
D.集合类除了提供可变容量的存储外，还提供了对数据的操作方法
正确答案：ABD
本题考查集合框架
选项C错误，Map接口不是Collection接口的子接口。

19、【多选题】
下列代码说法正确的是：（AB）。
public class DaemonThread extends Thread{
public DaemonThread(String name){
super(name);
}
public void run() {
while (true) {
System.out.println(“Daemon thread running…”);
}
}
public static void main(String[] args) {
DaemonThread dt = new DaemonThread(“dtThread”);
dt.setDaemon(true);//设置dt为守护线程
dt.start();
} }
A.名为dtThread的线程为守护线程
B.运行上述代码，main 线程一退出，则虚拟机退出
C.运行上述代码，程序会一直跑下去，因为main线程结束了，但dt线程是一个无限循环，还没有结束，虚拟机不能退出
D.main线程是守护线程
解析:守护线程又称为后台线程

• 与普通线程的一个最主要区别在于结束时机.
• 当一个进程结束时,所有运行的守护线程都会被强制结束.
• 当一个进程中的所有前台(普通)线程结束时,进程就会结束.
  A:对, dt.setDaemon(true);//设置dt为守护线程
  B:对main方法是前台主线程,main方法执行完,前台线程结束后则守护线程也结束
  C:dt被设置为守护线程,守护线程在前台线程结束后会被强制结束
  D:main是前台主线程.

20、【多选题】
下列选项中，对Object类描述正确的是（ ）。
A.Java中所有的类，都默认自动继承了Object类
B.Java中所有的类都从Object类中继承了toString()方法、hashCode()方法和equals()等方法
C.Object类中toString()方法的返回值是一个字符串，equals方法的返回值为1或0
D.定义类的时候，类中必须重写Object类中的toString(),equals(),hashCode()方法
正确答案：AB
本题考查有关Object类的说法
选项AB正确
选项C错误，equals()方法返回true或false
选项D错误，自定义类建议重写Object类中的3个方法，但不是必须。

二、填空简答题（共5题，每题5分，共25分）
1、写出Thread创建线程步骤。
答：（1）创建一个新的线程类，继承Thread类并覆盖Thread类的run()方法；
（2）创建一个线程类的对象，创建方法与一般对象的创建相同，使用关键字new完成。
（3）启动新线程对象，调用start()方法。
（4）线程自己调用run()方法。
2、简述为什么引入泛型？
答：从使用中可以看到，存放的数据取出来用时，必须强制转化为它的实际类型；
这样不能保证程序类型的安全，增加了程序出错的机率，而且带来了麻烦；
因此java中引入了“泛型”的概念。
3、HashMap和HashTable的区别是？
答：Hashtable是线程安全的，也就是说是同步的，而HashMap是线程序不安全的，不是同步的。
4、进程和线程的区别是什么？
答：进程是执行着的应用程序，而线程是进程内部的一个执行序列。一个进程可以有多个线程。
5、简述Runnable创建线程步骤
答：（1）创建一个实现Runnable接口的类，并且在这个类中重写run方法。
（2）使用关键字new一个ThreadType的实例；
（3）通过Runnable的实例创建一个线程对象，在创建线程对象时，调用的构造函数是new Thread(ThreadType)，它用ThreadType中实现的run()方法作为新线程对象的run()方法。
（4）通过调用ThreadType对象的start()方法启动线程运行。

三、程序代码题（共2题，35分）

1. 按照要求完成以下操作。（分值分配： Person类—7分 Teacher类—7分 Student类—7分 测试类—14分）
   1. 创建Person，Teacher，Student类
      其中，Person为父类，Teacher和Student都继承Person
      Person中有属性：String name,int age(是Teacher，Student中共有的属性，自己思考访问控制修饰符)
      在Person中写出无参构造方法Person(),
      有参构造方法Person(String name,int age),在方法体中为name，age赋值
      在Person中定义方法：showMessage(),用于展示人的信息，打印输出“展示某个人的信息”
2. 在Teacher类中定义私有的属性：工号:int teacherId
   定义以下构造方法：
   1.无参构造方法 Teacher()
   2.有参构造方法Teacher(String name,int age,int teacherId)
   该构造方法中调用父类的2个参数的构造方法
   并为成员变量teacherId赋值为参数的值
   在Teachar中重写方法showMessage():在方法体中输出“老师的信息是：姓名：xx,年龄：xx,工号：xx”
3. 在Student类中定义私有的属性：学号:int studentId
   定义以下构造方法：
   1.无参构造方法 Student()
   2.有参构造方法Student(String name,int age,int studentId)
   该构造方法中调用父类的2个参数的构造方法
   并为成员变量studentId赋值为参数的值
   在Student中重写方法showMessage():
   在方法体中输出“学生的信息是：姓名：xx，年龄：xx，学号：xx”
4. 写测试类Test
   在main方法中创建Person[] ,长度为5， 存入2个老师，3个学生，之后遍历数组，调用showMessage()显示每个人的信息

答案:

public class Person {
	protected String name;
	protected int age;
	
	public Person() {
		super();
	}

	public Person(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	
	public void showMessage() {
		System.out.println("展示某个人的信息");
	}
}

public class Teacher extends Person {
	private int teacherId;

	public Teacher() {
		super();
	}

	public Teacher(String name, int age,int teacherId) {
		super(name, age);
		this.teacherId = teacherId;
	}
	
	@Override
	public void showMessage() {
		System.out.println("老师的信息是：姓名："+name+",年龄："+age+",工号："+teacherId);
	}
	
}

public class Student extends Person{
	private int studentId;

	public Student() {
		super();
	}

	public Student(String name, int age,int studentId) {
		super(name, age);
		this.studentId = studentId;
	}
	
	@Override
	public void showMessage() {
		System.out.println("学生的信息是：姓名："+name+",年龄："+age+",学号："+studentId);
	}
	
}

public class Test {
	public static void main(String[] args) {
		Person[] persons = new Person[5];
		Teacher teacher = new Teacher("张力",41,1001);
		Teacher teacher2 = new Teacher("王可", 33, 1002);
		
		Student student = new Student("tom", 22, 1003);
		Student student2 = new Student("jack", 21, 2002);
		Student student3 = new Student("rose", 21, 2003);
		
		persons[0]= teacher;
		persons[1] = teacher2;
		persons[2] = student;
		persons[3] = student2;
		persons[4] = student3;
		
		for(int i=0;i<persons.length;i++) {
			persons[i].showMessage();
		}
	}

}