【Java应用程序开发】【期末复习题】【2022秋】【答案近期更新完成】
文章目录
- 零、考试说明
- 一、单选题（175题，1'）
- 二、多选题（10题，2'）
- 三、判断题（20题，1'）
- 四、简答题（20题，5'）
- 五、编程题（8题，10'）
零、考试说明
答题时长：90分钟
试卷共包含57道题目，其中单选题30道，多选题10道，判断题10道，简答题5道，程序题2道。
一、单选题（175题，1’）
1.定义一个类,必须使用的关键字是( )
A.public
B.class
C.interface
D.static
2.抽象方法:( )
A.可以有方法体
B.不可以出现在非抽象类中
C.有方法体的方法
D.抽象类中的方法都是抽象方法
3.下面关于switch语句错误的是:
A.在同一个switch语句中,case后的值可以相同
B.没有break语句,也能编译运行
C.default语句可有可无
D.switch语句中表达式的值可以是String类型
class Myclass{
static int member;
}
public class Test{
public static void main(String args[]){
Myclass A = new Myclass();
Myclass B = new Myclass();
Myclass.member = 1;
A.member = 2;
B.member = 3;
System.out.println("member = "+ Myclass.member);
}
}
A.member = 1
B.member = 2
C.member = 3
D.member = 0
5.对于类A,B,C,D和接口 IA,IB,IC 有以下的定义，
class A{}
class B extends A implements IA{}
class C extends B implements IB{}
class D extends B implements IC{}
interface IA{}
interface IB extends IA{}
interface IC extends IA{}
下列类型转换中，正确的是（）
A.IB ib = new D()
B.IC ic = new D()
C.IC ic = new C()
D.D d = new B()
6.对于下面代码的运行结果描述,正确的是( )
public static void main(String[] args){
File f = new File("D:\\345.txt");
FileWriter fw;
try{
fw = new FileWriter(f);
String str = "chengliang\r\nrrrrrrttttttt";
fw.write(str);
}catch(IOException e){
e.printStackTrace();
}
}
A.D盘根目录下不会出现345.txt文件
B.D盘根目录下会出现345.txt文件,但是其中没有内容
C.会出现有345.txt文件,其中内容为str字符串的内容
D.345.txt文件中会出现乱码
7.在Java中,关于构造方法,下列说法错误的是( )
A.构造方法的名称必须与类名相同
B.构造方法可以带参数
C.构造方法不可以重载
D.构造方法绝对不能有返回值
8.下列哪些语句关于Java内存回收的说明是正确的? ( )
A.程序员必须创建一个线程来释放内存
B.内存回收程序负责释放无用内存
C.内存回收程序随机释放内存
D.内存回收程序可以在指定的时间释放内存对象
9.下面这段代码的输出为(忽略换行)
Object a = new Object();
Object b = new Object();
if(a.equals(b)){
System.out.println("YES");
}else{
System.out.println("NO");
}
b = a;
if(a.equals(b)){
System.out.println("YES");
}else{
System.out.println("NO");
}
A.YES NO
B.NO YES
C.YES YES
D.NO NO
10.Java语言的特点是:
(1) 面向对象(2) 安全性(3) 操作平台无关性(4) 多线程(5) 内存管理
A.(1)(3)(4)
B.(1)(2)(3)(4)
C.(1)(2)(3)(5)
D.(1)(2)(3)(4)(5)
11.在JAVA中,以下( )类的对象以键-值的方式存储对象
A.java.util.List
B.java.util.ArrayList
C.java.util.HashMap
D.java.util.LinkedList
12.下面关于继承的说法,正确的是( ) 。
A.超类的对象就是子类的对象
B.一个类可以有几个超类
C.一个类只能有一个子类
D.一个类只能有一个超类
13.面向对象的主要思想是:
将客观事物看作具有____和____的对象,通过抽象找出同一类对象的共同状态和行为,构成____。
A.状态,行为,类
B.属性,行为,方法
C.状态,行为,方法
D.属性,方法,类
14.线程通过( )方法可以使具有相同优先级线程获得处理器。
A.run
B.setPrority
C.yield
D.sleep
15.下列哪种操作不会抛出异常?
A.打开不存在的文件
B.用负数索引访问数组
C.浮点数除以0
D.浮点数乘以0
16.类Line的定义如下,其中的this代表的是:
class Line{
private int a,b;
public Line(int x,int y){
this.x = x;
this.y = y;
}
}
A.this指针
B.类名Line
C.父类的对象
D.Line类实例的当前对象引用
17.在Java中,存放字符串常量的对象属于( )类对象。
A.Character
B.String
C.StringBuffer
D.Vector
18.下面哪个不属于Java标准输入输出流
A.System.in
B.System.out
C.System.stream
D.System.err
19.在创建某类的对象时应该:
A.只要声明对象,就可以使用。
B.声明对象后,为对象分配内存空间初始化后,才能使用对象
C.对象是类的实例,只要存在类,就不用声明对象。
D.因为Java是单继承,所以一个类只能有一个对象。
20.Java语言间的继承关系是:
A.单继承
B.多继承
C.单继承和多继承
D.不能继承
21.Java application中的主类需包含main方法,以下哪项是main方法的正确形参?( )
A.String args
B.String []
C.Char arg
D.String args[]
22.关于对象成员占用内存的说法哪个正确?( )
A.同一个类的对象共用同一段内存
B.同一个类的对象使用不同的内存段,但静态成员共享相同的内存空间
C.对象的方法不占用内存
D.以上都不对
23.给定如下所示的Java代码,则运行时,会产生( )类型的异常
String s = null;
s.concat("abc");
A.ArithmeticException
B.NullPointerException
C.IOException
D.ClassNotFoundException
24.在以下哪种情况下不需要进行方法的覆盖
A.子类的方法和父类功能相同,但实现细节不同
B.在名字相同的方法中要做更多的事情
C.子类中要取消从父类继承的方法
D.以上都不是
25.在JAVA中,LinkedList类和ArrayList类同属于集合框架类,下列( )选项中的方法是LinkedList类有而ArrayList类没有的。
A.add(Object o)
B.add(int index,Object o)
C.remove(Object o)
D.removeLast()
26.A,B是两个定义好的接口,若接口C想要拓展这两个接口,以下做法正确的是
A.interface C extends A,B{}
B.interface implements A,B{}
C.class C extends A,B{}
D.class C implements A,B{}
27.已知MyInterface是一个接口,ClassA是实现了MyInterface的一个类,ClassB是ClassA的一个子类,则下列哪个语句是正确的
A.ClassB obj = new ClassA();
B.MyInterface obj = new ClassB()
C.ClassA obj = new MyInterface()
D.MyInterface obj = new MyInterface()
28.关于接口实现的语法,正确的是
A.可以用new运算符,直接产生接口对象
B.必须实现接口中的所有方法
C.来自接口的方法实现可以声明成private
D.接口的方法默认是protected修饰
29.关于接口哪个正确? ( )
A.实现一个接口只要实现接口的一个方法即可
B.接口可是实现java的多重继承
C.接口间不能有继承关系
D.接口和抽象类是同一回事
30.编译一个定义了两个类和三个方法的 Java 源程序文件,总共会产生( )个字节码文件。
A.5 个字节码文件,以“.java”为扩展名
B.2 个字节码文件,以“.java”为扩展名
C.5 个字节码文件,以“.class”为扩展名
D.2 个字节码文件,以“.class”为扩展名
31.下面哪个关键字不是类及成员的访问控制符:
A.public
B.private
C.static
D.protected
32.下列javaDoc注释正确的是( )
A./*我爱北京天安门*/
B.//我爱北京天安门*/
C./**我爱北京天安门*/
D./*我爱北京天安门**/
33.以下关于继承的叙述正确的是( )。
A.在Java中一个类只能实现一个接口
B.在Java中一个类不能同时继承一个类和实现一个接口
C.在Java中接口只允许单一继承
D.在Java中类只允许单一继承
34.对于try{……}catch子句的排列方式,下列正确的一项是( )
A.子类异常在前,父类异常在后
B.父类异常在前,子类异常在后
C.只能有子类异常
D.父类异常与子类异常不能同时出现
35.给定如下Java 程序代码片段,编译运行这段代码,结果是( B )。
java.util.HashMap
map = new java.util.HashMap();
map.put("name",null);
map.put("name","Jack");
System.out.println(map.get("name"));
A.null
B.Jack
C.nullJack
D.运行时出现异常
36.面向对象的程序设计方法采用了什么样的抽象方法构建程序的类与对象:
A.过程抽象
B.数据抽象
C.过程抽象与数据抽象
D.没有采用任何的抽象方法
37.要获取以下MyClass类中member的值,采用的语句是:
public class Myclass{
public static int member=1;
public static int getmember(){
return member;
}
};
A.MyClass.member()
B.MyClass().member
C.MyClass.member或者MyClass.getmember()
D.MyClass().member或者MyClass().getmember()
38.下列不属于面向对象程序设计的基本特征的是:
A.抽象
B.封装
C.继承
D.静态
39.下列选项中,用于声明包名的关键字是:
A.import
B.package
C.interface
D.protected
40.()类是所有异常类的父类。
A.Runable
B.Error
C.Exception
D.AWTError
41.在JAVA中ArrayList类实现了可变大小的数组,便于遍历元素和随机访问元素,已知获得了ArrayList类的对象bookTypeList,则下列语句中能够实现判断列表中是否存在字符串“小说”的是( )。
A.bookTypeList.add("小说");
B.bookTypeList.get("小说");
C.bookTypeList.contains("小说");
D.bookTypeList.remove("小说");
42.执行下面代码结果( )
for(int i=0;;){
System.out.println("这是 "+i);
break;
}
A.语法错误,缺少表达式2和表达式3
B.死循环
C.程序什么都不输出
D.输出:这是0
43.下列选项中关于Java中封装的说法错误的是( )。
A.封装就是将属性私有化,提供共有的方法访问私有属性
B.属性的访问方法包括setter方法和getter方法
C.setter方法用于赋值,getter方法用于取值
D.包含属性的类都必须封装属性,否则无法通过编译
44.以下程序段的输出结果是:
int i = 0;
for(i=4; i>0; i--) {
if(i==1)
break;
System.out.print(i);
}
System.out.print(i);
A.4321
B.4322
C.321
D.432
45.以下程序的运行结果是:( )
public class Increment{
public static void main(String args[]) {
int a;
a = 6;
System.out.print(a);
System.out.print(a++);
System.out.print(a);
}
}
A.666
B.667
C.677
D.676
46.下列哪一项不是构造方法的特点:
A.构造方法名必须与类名相同
B.构造方法不具有任何返回类型
C.任何一个类都含有构造方法
D.构造方法可以通过对象调用
47.A和B是两个定义好的接口,若类C想要实现这两个接口,以下做法正确的是
A.class C extends A implents B{}
B.class C implements A,B{}
C.class C implements A extends B{}
D.class C extends A,B
48.下列声明二维数组的语句不合法的是()
A.char c[][] = new char[2][3];
B.char c[][]=new char[6][];
C.char[][] c= new char[3][3];
D.char [][] c = new char[][4];
49.某类的成员方法只能被自己调用,修饰该方法的是:
A.public
B.protected
C.private
D.无修饰符
50.对象的特征在类中表示为变量,称为类的( )。
A.对象
B.属性
C.方法
D.数据类型
51.线程通过( )方法可以休眠一段时间,然后恢复运行。
A.run
B.setPrority
C.yield
D.sleep
52.将类的成员的访问权限设置为默认的,则该成员能被( ) 。
A.同一包中的类访问
B.其他包中的类访问
C.所有的类访问
D.所有的类的子类访问
53.关于Object类,下面说法正确的是
A.equals方法可以比较两个对象是否相等
B.如果两个对象同一,那么它们一定相等
C.如果两个对象相等,那么它们一定同一
D.相等和同一意思一样
54.以下关于抽象类和接口的说法错误的是( )
A.抽象类在Java语言中表示的是一种继承关系,一个类只能使用一次继承。但是一个类却可以实现多个接口。
B.在抽象类中可以没有抽象方法
C.实现抽象类和接口的类必须实现其中的所有方法,除非它也是抽象类。接口中的方法都不能被实现
D.接口中的方法都必须加上public关键字。
55.下列值不为true的表达式有( )。
A."john" = = "john"
B."john".equals("john")
C."john" = "john"
D."john".equals(new String("john"))
56.以下( )不是合法的标识符
A.STRING
B.x3x;
C.void
D.de$f
57.在Java中,下面对于构造函数的描述错误的是( )
A.类不一定要显式定义构造函数
B.构造函数的没有返回类型
C.如果构造函数不带任何参数,那么构造函数的名称和类名可以不同
D.一个类可以定义多个构造函数
58.关于类的描叙正确的是( )
A.在类中定义的变量称为类的成员变量,在别的类中可以直接使用
B.局部变量的作用范围仅仅在定义它的方法内,或者是在定义它的控制流块中
C.使用别的类的方法仅仅需要引用方法的名字即可
D.一个类的方法可以没有方法名
59.当( )方法终止时,能使线程进入死亡状态。
A.run
B.setPrority//更改线程优先级
C.yield//暂停当前线程的执行,执行其他线程
D.sleep//线程休眠
60.下面关于接口的说法正确的是:
A.接口具有多重继承性,一个接口可以继承多个父接口
B.接口中定义的数据,都是变量
C.接口中定义的方法,可以在定义时提供实现
D.接口用abstract 修饰
61.对异常处理语句try-catch-finally,下面那个说法是正确的:
A.如果有多个catch语句,对所有的catch语句都会执行一次
B.如果有多个catch语句,对每个符合条件的catch都会执行一次
C.多个catch的情况下,异常类的排列顺序应该是父类在前,子类在后
D.一般情况下,finally部分都会被执行一次
62.A类有a、b、c三个public变量成员,B类继承自A,并且增加了自己的public变量成员d,C继承自A,增加了自己的public变量成员e,则下列说法中错误的是
A.A类拥有c成员
B.B类拥有b成员
C.C类拥有x成员
D.B类拥有c成员
63.自定义异常类时,可以继承的类是( )
A.Error
B.Applet
C.Exception及其子类
D.AssertionError
64.在Java程序中,下面哪个是不合法的标志符()
A.2D
B.True
C._name
D.T1
65.为了区分重载多态中同名的不同方法,要求( )。
A.方法名不同
B.返回值类型不同
C.调用时用类名或对象名做前缀
D.形式参数个数或者类型不同
66.下面的代码段执行之后count的值是什么( )
int count = 1;
for (int i = 1; i <= 5; i++) {
count += i;
}
System.out.println(count);
A.5
B.1
C.15
D.16
67.关于Java中类的声明,下面哪个关键字是必须有的:
A.public
B.class
C.extends
D.implements
68.下面( )赋值语句不会出现编译警告或错误。
A.float f=1.3;
B.char c="a";
C.byte b=257;
D.int i=10;
69.( )表达式不可以作为循环条件
A.i++;
B.i>5;
C.bEqual = str.equals("q");
D.count = = i;
70.下面关于数组的说法中,错误的是( )
A.在类中声明一个整数数组作为成员变量,如果没有给它赋值,数值元素值为空
B.数组需要在内存中占用空间。
C.数组必须先声明,然后才能使用
D.数组本身是一个对象
71.如下哪个是Java中有效的关键字( )。
A.name
B.hello
C.false
D.good
72.变量命名规范说法正确的是( )
A.变量由字母、下划线、数字、$符号随意组成;
B.变量不能以数字作为开头;
C.A和a在java中是同一个变量;
D.不同类型的变量,可以起相同的名字;
73.下列代码输出结果是( )
int i = 10;
while ( i > 0 ){
i = i + 1;
if ( i = =10 ){
break;
}
}
A.while循环执行10次
B.死循环
C.循环一次都不执行
D.循环执行一次
74.有关类的说法,正确的是( ) 。
A.类具有封装性,所以类的数据是不能被访问的
B.类具有封装性,但可以通过类的公共接口访问类中的数据
C.声明一个类时,必须使用 public 修饰符
D.每个类中必须有 main 方法,否则程序无法运行
75.Java中,如果类C是类B的子类,类B是类A的子类,那么下面描述正确的是( )
A.C不仅继承了中的成员,同样也继承了A中的成员
B.C只继承了B中的成员
C.C只继承了A中的成员
D.C不能继承A或B中的成员
76.关于面向对象的说法正确的是( )
A.类可以让我们用程序模拟现实世界中的实体
B.有多少个实体就要创建多少个类
C.对象的行为和属性被封装在类中,外界通过调用类的方法来获得,但是要知道类的内部是如何实现
D.现实世界中的某些实体不能用类来描述
77.在横线中哪种方法访问的是A类的balance
class B{
public int balance;
public int getBalance() {
return balance;
}
}
class A extends B{
public int balance;
public void use_B_balance() {
______
}
}
A.balance
B.getBalance()
C.super.balance
D.super.getBalance()
78.下面代码输出结果是( )。
int i=0,s=0;
do{
if (i%2 = = 0 ){
i++;
continue;
}
i++;
s = s + i;
}
while (i<7);
System.out.println(s);
A.16
B.12
C.28
D.21
79.下面关于抽象方法的说法中,正确的是
A.可以有方法体
B.可以出现在非抽象类中
C.没有方法体
D.抽象类中的方法都被称为抽象方法
80.下列输出结果是( )
int a = 0 ;
while ( a < 5 ) {
switch(a){
case 0:
case 3 : a = a + 2;
case 1 :
case 2 : a = a + 3;
default : a = a + 5;
}
}
System.out.print ( a ) ;
A.0
B.5
C.10
D.其他
81.以下关于java异常说法不正确的是( )。
A.Throwable 类是 Java 语言中Error类和Exception类的父类。
B.当异常对象是Exception类(或其子类)的实例时,能通过 Java 虚拟机或者 throw 语句抛出该异常对象,并能通过try…catch…finally处理。
C.如果只用一个catch块捕捉多个异常对象,则catch 子句中的参数类型应是所有异常对象的父类。
D.以上说法都不对。
82.如果一个程序中有多个catch语句,则程序会按如下哪种情况执行:
A.找到合适的异常类型后执行后面的catch语句
B.找到每个符合条件的catch都要执行一次
C.找到合适的异常类型处理后就不再执行后面的catch语句
D.对每个catch语句都执行一次
83.在异常处理中,将可能抛出异常的方法放在( )语句块中
A.throws
B.catch
C.try
D.finally
84.以下有关构造方法的说法,正确的是:( )
A.一个类的构造方法只能有一个
B.构造方法在类定义时被调用
C.构造方法只能由对象中的其它方法调用。
D.构造方法和类同名
85.下面说法不正确的是( )。
A.列表(List)、集合(Set)和映射(Map)都是java.util包中的接口。
B.List接口是可以包含重复元素的有序集合。
C.Set接口是不包含重复元素的集合。
D.Map接口将键映射到值,键可以重复,但每个键最多只能映射一个值。
86.有如下代码片段:
int num1 = 10;
int num2 = 20;
String word = new String("exam");
double answer = 25.5;
另外定义了下列方法头:
public int stuff(String s, int x, int y) 以下哪个是正确的方法调用:
A.num1 = stuff("hello", num1, num2);
B.answer = stuff(word, answer, num2);
C.num2 = stuff("hello",num1,answer);
D.num1 = stuff(num1,num2,answer);
87.下列有关 Java 中接口的说法正确的是( )。
A.接口中含有具体方法的实现代码
B.若一个类要实现一个接口,则用到 “implements” 关键字
C.若一个类要实现一个接口,则用到“ extends ”关键字
D.接口不允许继承
88.null
A.null1
B.null2
C.null3
D.null4
89.下面哪个条件运算的结果等价于简单的if-else语句:
if(a > b)
System.out.println(a);
else
System.out.println(b);
A.System.out.println((a>b):a?b);
B.System.out.println((a>b):b?a);
C.System.out.println((a>b)?b:a);
D.System.out.println((a>b)?a:b);
90.对于类A,B,C,D和接口 IA,IB,IC 有以下的定义，
class A{}
class B extends A implements IA{}
class C extends B implements IB{}
class D extends B implements IC{}
interface IA{}
interface IB extends IA{}
interface IC extends IA{}
A tmpA = new A()
B tmpB = new B()
C tmpC = new C()
D tmpD = new D()
????????
则下列使用方法中正确的是()
A.tmpB = tmpA
B.tmpC =tmpD
C.tmpA = tmpC
D.tmpD = tmpB
91.下面的方法重载,正确的是( ) 。
A.
int fun(int a, float b）{ }
float fun(int a, float b) { }
B.
float fun(int a, float b) { }
float fun(int x, float y) { }
C.
float fun(float a) { }
float fun(float a, float b) { }
D.
float fun1(int a, float b) { }
float fun2(int a, float b) { }
92.为一个boolean类型变量赋值时,可以使用( )方式
A.boolean = 1;
B.boolean a = (9 >= 10);
C.boolean a="真";
D.boolean a = = false;
93.以下用于创建容器对象的类是( )
A.Frame
B.Checkbox
C.Button
D.TextField
94.程序员将可能发生异常的代码放在( )块中,无论如何都需要执行的代码在( )块中:
A.catch、try
B.try、finally
C.try、exception
D.try、final
95.下面哪个声明语句是正确的
A.abstract final class A;
B.abstract private move();
C.protected private number;
D.public abstract class B{}
96.关于异常,下列说法正确的是( )
A.异常是一种对象
B.一旦程序运行,异常将被创建
C.为了保证程序运行速度,要尽量避免异常控制
D.以上说法都不对
97.在Java接口中,下列选项中有效的方法声明是( )。
A.public void aMethod();
B.void aMethod(){};
C.protected void aMethod();
D.private void aMethod();
98.下列( )属于引用数据类型(选择两项)
A.double
B.char
C.用户自定义的Student类类型
D.int
99.考虑以下的方法头声明:
public void myMethod(int num, char letter)
下面哪个描述是正确的:
A.这个方法有个int型的参数,它的形式参数是letter
B.这个方法有个int型的参数,它的形式参数是num
C.这个方法有个char型的参数,它的实际参数是myMethod
D.这个方法是一个构造方法
100.下列哪一个import命令可以使我们在程序中创建数据库对象( )
A.import java.sql.*;
B.import java.util.*;
C.import java.io.*;
D.import java.net.*;
101.分析选项中关于Java中this关键字的说法正确的是( )
A.this关键字是在对象内部指代自身的引用
B.this关键字可以在类中的任何位置使用
C.this关键字和类关联,而不是和特定的对象关联
D.同一个类的不同对象共用一个this
102.若有定义:byte[] x={11,22,33,-66};
其中0≤k≤3,则对x数组元素错误的引用是( )
A.x[5-3]
B.x[4]
C.x[k]
D.x[0]
103.下列选项中关于Java中super关键字的说法正确的是( )。
A.super关键字是在子类对象内部指代其父类对象的引用
B.super关键字不仅可以指代子类的直接父类,还可以指代父类的父类
C.子类通过super关键字只能调用父类的方法,而不能调用父类的属性
D.子类通过super关键字只能调用父类的属性,而不能调用父类的方法
104.以下是接口I的定义:
interface I{
void setValue(int val);
int getValue();
}
以下哪段代码能够通过编译:
A.class A extends I{int value;public void setValue(int val){value=val;}public int getValue(){ return value;
B.class B implements I{int value; void setValue(int val){value=val;} public int getValue(){ return value;
C.interface C extends I {void add();}
D.interface D implements I{void add();}
105.下面说法正确的是
A.在写文件时,如果最后没有调用close方法则无法写入
B.写文件时在close方法之前,调用flush方法,可以写入
C.如果close方法之前没有调用flush方法,则无法写入
D.仅调用flush方法不能保证数据写入文件
106.关于接口声明的语法,以下说法正确的是
A.接口中的数据成员一定要有初值,且此值不能再更改,final关键词不可省略
B.接口中的方法必须是“抽象方法”,不能有方法体,可以省略public及abstract关键字
C.接口中的数据成员可以有变量,可以有常量。
D.只有接口中可以有抽象方法
107.如果想要文字量的的实际内容是 “I’m very interested in java Programming” (包含””),以下文字量声明正确的是:
A.string str = “I’m very interested in java Programming”
B.string str = \“I\’m very interested in java Programming\”
C.string str = “\“I\’m very interested in java Programming\””
D.string str = “I\’m very interested in java Programming”
108.给定java代码如下所示,在A处新增下列( )方法,是对cal方法的重载
public class Test{
public void cal(int x, int y, int z)
{
}
//A
}
A.public int cal(int x,int y,float z){return 0;}
B.public int cal(int x,int y,int z){return 0;}
C.public void cal2(int x, int y, int z){}
D.public viod cal(int z,int y,int x){}
109.给定如下代码,要在第三个构造方法的空白处填上一行代码使之能够调用第二个构造方法,这行代码应该是:
class Circle{
String name,radius;
int r;
public Circle(String n){
name = n;
}
public Circle(String n,int a){
name = n;
r = a;
}
public Circle(String n,String d,int a){
__________
radius = d;
}
}
A.Circle(n,a);
B.this(Circle(n,a));
C.this(n,a);
D.this(name,a);
110.在编写异常处理的Java程序中,每个catch语句块都应该与( )语句块对应,使得用该语句块来启动Java的异常处理机制。
A.if - else
B.switch
C.try
D.throw
111.下面关于抽象类和抽象方法的说法中,错误的是
A.抽象类可以包含非抽象方法
B.抽象类可以定义对象
C.抽象类可以包含抽象方法
D.抽象类不可以被实例化
112.不允许作为类及类成员的访问控制符的是( )。
A.public
B.private
C.static
D.protected
import java.io.*;
class Person{
public void print(){
System.out.print("Person ");
}
public void printMyGender(String s){
this.print();
System.out.print(s+" ");
}
}
class Gender{
String type="gender";
public void print(Person p){
p.printMyGender(type);
}
}
class Female extends Gender{
public Female(){
type="female";
}
}
class Male extends Gender{
public Male(){
type="male";
}
}
class Employee extends Person{
public void print(){
System.out.print("Employee ");
}
}
class Manager extends Employee{
public void print(){
System.out.print("Manager ");
}
}
public class Test{
public static void main(String[] args){
Manager man = new Manager();
Employee em = new Employee();
Gender gender1 = new Male();
Gender gender2 = new Female();
gender1.print(man);
gender2.print(em);
}
}
对于以上代码,其运行结果是
A.Person male Person female
B.Person gender Person gender
C.Manager male Employee female
D.Manager gender Employee gender
114.下面关于变量的说法,哪个是不正确的:
A.实例变量是类的成员变量
B.类变量用关键字static声明
C.类变量可以用<实例名>.<类变量名>访问
D.实例变量可以用<类名>.<实例变量名>访问
115.下面说法中错误的是
A.FileWriter中append参数为true时,可以实现在文件内容之后写追加操作
B.Java程序中每个字符占2字节
C.当使用PipedOutputStream类时,最后不需要调用输出流的close方法
D.BufferedWriter类的newLine方法是用于换行
116.下列类定义中哪些是合法的抽象类的定义?( )
A.abstract Animal{abstract void growl();
B.class abstract Animal{abstract void growl();}
C.abstract class Animal{abstract void growl();}
D.abstract class Animal{abstract void growl() {System.out.println(“growl”);};}
117.下面哪个流属于面向字符的输入流
A.BufferedWriter
B.FileInputStream
C.ObjectInputStream
D.InputStreamReader
118.下列选项中,用于引入其他包的关键字是:
A.import
B.package
C.infterface
D.protected
119.下列()不属于Java的基本数据类型
A.int
B.String
C.double
D.boolean
120.下列哪个选项是合法的标识符?( )
A.123
B._name
C.class
D.1first
121.在JAVA的异常处理模型中,能单独和finally语句一起使用的块是( A )。
A.try
B.catch
C.throw
D.throws
122.下面有关for循环的描述正确的是( )
A.for循环体语句中,可以包含多条语句,但要用大括号括起来
B.for循环只能用于循环次数已经确定的情况
C.在for循环中,不能使用break语句跳出循环
D.for循环是先执行循环体语句,后进行条件判断
123.下列说法正确的是( )
A.JAVA程序的main方法必须写在类里面
B.JAVA程序中可以有多个main方法
C.JAVA程序中类名必须与文件名一样
D.JAVA程序的main方法中如果只有一条语句,可以不用{}(大括号)括起来
124.下面关于面向对象概念的描述中,不正确的一项是:
A.在现实生活中,对象是指客观世界的实体
B.程序中的对象就是现实生活中的对象
C.在程序中,对象是通过一种抽象数据类型来描述的,这种抽象数据类型称为类
D.在程序中,对象是一组变量和相关方法的集合
125.JAVA所定义的版本中不包括:( )
A.JAVA2 EE
B.JAVA2 SE
C.JAVA2 ME
D.JAVA2 HE
126.null
A.null1
B.null2
C.null3
D.null4
127.下面关于多态性的说法,正确的是( ) 。
A.一个类中不能有同名的方法
B.子类中不能有和父类中同名的方法
C.子类中可以有和父类中同名且参数相同的方法
D.多态性就是方法的名字可以一样,但返回的类型必须不一样
128.当需要在文件中写入字符而不是字节时,在下面的类中最好选用( )类。
A.java.io.RandomAccessFile
B.java.io.PrintWriter
C.java.io.PrintStream
D.java.io.PrintOutputStream
129.Java程序运行时会自动检查数组的下标是否越界,如果越界,会抛出下面的哪一个异常?
A.SQLException
B.IOException
C.ArrayIndexOutOfBoundsException
D.SecurityManager
130.如果需要从文件中读取数据,可以在程序中创建哪一个对象
A.FileInputStream
B.FileOutputStream
C.DataOutputStream
D.FileWriter
131.定义一个类必须使用的关键字是( )
A.inface
B.class
C.interface
D.facebooK
132.与OutputStream流相对应的Java系统的“标准输出对象”是( )。
A.System.in
B.System.out
C.System.err
D.System.exit()
133.在Java语言中,下列关于类的继承的描述,正确的是( )。
A.一个类可以继承多个父类
B.一个类可以具有多个子类
C.子类可以使用父类的所有方法
D.子类一定比父类有更多的成员方法
134.A类继承自B类,那么A类中不可以使用
A.B类的保护方法
B.B类的公有属性
C.B类的私有属性
D.A类的私有属性
135.Java语言是( )
A.面向问题的解释型高级编程语言
B.面向机器的低级编程语言
C.面向过程的编译型高级编程语言
D.面向对象的解释型高级编程语言
136.假定类A有一个方法void method(),如果要求能够通过类名A直接调用method(),则其方法定义应该为
A.static void method()
B.public void method()
C.final void method()
D.abstract void method()
137.关于方法main()的说法哪个正确?( )
A.方法main()只能放在公共类中
B.main()的头定义可以根据情况任意更改
C.一个类中可以没有main()方法
D.所有对象的创建都必须放在main()方法中
138.关于下面程序片段, ( )的结论是正确的。
String a = "Java";
String b = "Java";
String x = "Ja";
String y = "va";
String c = x + y;
A.a 和b指向同一个实例对象,a 和c指向同一个实例对象
B.a 和 b 指向同一个实例对象,a 和 c 不指向同一个实例对象
C.a 和 b 不指向同一个实例对象,a 和 c 指向同一个实例对象
D.a 和 b 不指向同一个实例对象,a 和 c 不指向同一个实例对象
139.下面哪个代码片段是错误的:
A.
package mypackage;
public class Rectangle {//doing something...}
B.
import java.io. *;
package mypackage;
public class Rectangle {//doing something...}
C.
import java.io. *;
class Circle{//doing something...}
public class Rectangle {//doing something...}
D.
import java.io. *;
import java.awt. *;
public class Rectangle {//doing something...}
140.在Java中,一个类可同时定义许多同名的方法,这些方法的形式参数的个数、类型或顺序各不相同,传回的值也可以不相同。这种面向对象程序特性称为( )
A.隐藏
B.重写
C.重载
D.相同方法
141.下面关于方法的说法中不正确的是:( )
A.方法必须没有返回值
B.方法调用时要求形参和实参保持一致
C.方法允许重载
D.方法的参数可以为空
142.表达式(11+3*8)/4%3的值是( )
A.31
B.0
C.1
D.2
143.下列叙述那个是正确的( )。
A.java是面向对象的编程语言
B.abstract类中只有abstract方法
C.abstract类中可以有非abstract方法,但该方法不可以用final修饰
D.可以同是用final 和abstract修饰一个方法
144.在Java类的声明中,类体包含了哪些内容:
A.变量成员声明及初始化
B.方法声明
C.方法体
D.以上所有内容
145.下面的说法正确的是
A.abstract可以修饰字段、方法和类
B.抽象方法的body部分必须用大括号包住,但是需要为空
C.声明抽象方法,大括号可有可以没有
D.抽象方法没有方法体
146.关于Java的构造函数,下列说法哪个正确:
A.所有类都必须定义一个构造函数
B.构造函数必须有返回值
C.构造函数可以访问类的非静态成员
D.构造函数必须初始化类的所有数据成员
147.关于事件监听,正确的是( ) 。
A.一个事件监听器只能监听一个组件
B.一个事件监听器只能监听处理一种事件
C.一个组件可以注册多个事件监听器,一个事件监听器也可以注册到多个组件上
D.一个组件只能引发一种事件
148.构造函数何时被调用? ( )
A.创建对象时
B.类定义时
C.使用对象的方法时
D.使用对象的属性时
149.java语言中,下列哪一子句是异常处理的出口( )
A.try{…}子句
B.catch{…}子句
C.finally{…}子句
D.以上说法都不对
150.下面关于变量的说法,哪个是不正确的:
A.实例变量是类的成员变量
B.类变量用关键字static声明
C.类变量可以用<实例名>.<类变量名>访问
D.实例变量可以用<类名>.<实例变量名>访问
- (单选题)
关于下面的程序,哪个结论是正确的()
public class Test{
public static void main(String args[]){
int a[]=new int[5];
length = 10;
System.out.println(a.length);
}
}
A.程序可以正常运行,输出结果为10
B.程序可以正常运行,输出结果为5
C.程序可以正常运行,输出结果为15
D.程序无法运行
152.类与对象的关系是:
A.类是对象的抽象
B.对象是类的抽象
C.对象是类的子类
D.类是对象的具体实例
153.下面( )是合法的 Java 标识符。
A.#_pound
B._underscore
C.5Interstate
D.class
154.以下关于布局的说法,错误的是( )
A.BorderLayout是边框布局
B.null是空布局,空布局是指不允许在上面摆放组件。
C.FlowLayout是流布局,这种布局将其中的组件按照加入的先后顺序从左向右排列, 一行排满之后就转到下一行继续从左至右排列
D.GridLayout是网格布局,它以矩形网格形式对容器的组件进行布置。容器被分成大小相等的矩形,一个矩形中放置一个组件
155.Java类继承的层次结构为
A.树状结构
B.星状结构
C.网格结构
D.环形结构
156.以下程序片段,下列哪个选项插入到第2行将引起编译错误:
package mypackage;
class Myclass{
//do something
}
A.public class MainClass{}
B.package mypackage1;
C.class B{}
D.import java.util. *;
157.下列说法错误的是
A.读文件时,如果最后没有关闭输入流会引起程序错误
B.读文件时,可以用Reader类的read()方法判断是否读到文件结尾
C.Int read(char[] buf)方法是将读取的字符读入buf数组
D.读文件时不需要调用flush方法
158.给出下面代码,关于该程序以下哪个说法是正确的?( )
public class Person{
static int arr[] = new int[5];
public static void main(String a[]){
System.out.println(arr[0]);
}
}
A.编译时将产生错误
B.编译时正确,运行时将产生错误
C.输出零
D.输出空
159.下面说法中错误的是
A.FileReader类是Reader类的间接子类
B.InputStreamReader类是Reader类的子类
C.BufferedReader类可以读取一行
D.BufferedReader的readLine()函数,如果没有数据时会返回0
160.java中用来抛出异常的关键字是( )
A.try
B.catch
C.throw
D.finally
import java.io.*;
class Person{
public void print(){
System.out.print("Person ");
}
}
class Employee extends Person{
public void print(){
System.out.print("Employee ");
}
}
class Manager extends Employee{
public void print(){
System.out.print("Manager ");
}
}
public class Test{
public static void main(String[] args){
Manager man = new Manager();
Person person1 = new Manager();
Person person2=new Employee();
person1.print();
person2.print();
}
}
对于上述代码,其结果输出为
A.Manager Employee
B.Person Person
C.Manager Person
D.Person Manager
162.(1)汇编语言 (2)机器语言 (3)高级语言 (4)面向对象的高级语言
程序设计的发展历程按照发展顺序排序是:
A.(4)(3)(2)(1)
B.(1)(2)(3)(4)
C.(2)(1)(3)(4)
D.(4)(3)(1)(2)
163.以下( )代码,能够对数组正确初始化(或者是默认初始化)。
A.int[] a;
B.a = {1, 2, 3, 4, 5};
C.int[] a = new int[5]{1, 2, 3, 4, 5};
D.int[] a = new int[5];
164.关于接口和抽象类的说法,正确的是:
A.接口和抽象类都具有多重继承性,即一个可以继承多个
B.不相关的类可以实现同一个接口,而抽象类属于一个类的继承体系,且一般位于类体系的顶层
C.抽象类和接口都必须对数据成员进行初始化
D.抽象类和接口都可以在定义时提供实现方法体
165.score是一个整数数组,有五个元素,已经正确初始化并赋值,仔细阅读下面代码,程序运行结果是( )
temp = score[0];
for (int index = 1;index < 5;index++) {
if (score[index] < temp) {
temp = score[index];
}
}
A.求最大数
B.求最小数
C.找到数组最后一个元素
D.编译出错
166.下列说法哪个正确 ( )
A.不需要定义类,就能创建对象
B.对象中必须有属性和方法
C.属性可以是简单变量,也可以是一个对象
D.属性必须是简单变量
167.以下由do-while语句构成的循环执行的次数是( )
int k = 0;
do{
++k;
}while ( k < 1 );
A.一次也不执行
B.执行1次
C.无限次
D.有语法错,不能执行
168.另外的类要获取以下MyClass类中member的值,采用的语句是:
public class MyClass{
private static int member = 1;
public static int getMember(){
return member;
}
}
A.MyClass.member
B.new MyClass().member
C.MyClass.getMember()
D.MyClass().getMember()
169.关于下面程序, ( )的结论是正确的。
class J_SubClass extends J_Test{
public class J_Test {
J_Test(int i) {
System.out.println(i);
}
}
public static void main(String[] args) {
J_SubClass a = new J_SubClass();
}
}
A.不能通过编译,因为类 J_Test 没有定义无参数的构造方法
B.不能通过编译,因为类 J_SubClass 没有定义无参数的构造方法
C.不能通过编译,因为没有实现 J_SubClass(int i)的构造方法
D.可以成功通过编译
170.接口的所有成员方法都具有()修饰的特性。
A.private,final
B.public, abstact
C.static protected
D.static
171.下列不能作为switch表达式参数的数据类型是:
A.int
B.char
C.long
D.short
172.下面说法正确的是
A.FileWriter类是Writer类的子类
B.FileWriter类是OutputStreamReader类的子类
C.FileWriter类是FileOutputStream类的子类
D.Wirter类是OutputStreamWriter类的子类
173.用( )方法可以改变线程的优先级。
A.run
B.setPrority
C.yield
D.sleep
174.假设已经声明了一个类A的两个对象a1、a2,为了初始化a1和a2,下面语句正确的是:
A.a1, a2 = new A();
B.a1 ,a2 = new();
C.a1 = new(); a2 = new();
D.a1 = new A(); a2 = new A();
175.下面哪些是合法的抽象类定义
A.abstract A {abstract void method()}
B.class abstract B {abstract void method()}
C.abstract class C {abstract void method()}
D.abstract class D {abstract void method(){System.out.println(“d”)
二、多选题（10题，2’）
1.下面哪些是合法的标识符：
A.TwoUsers
B.this
C._endline
D.$persons
E.*point
2.对关键词continue和break的理解是正确的是：
A.执行break之后，程序的控制流跳转到循坏块的之后的语句继续执行
B.continue和break没有区别
C.执行break之后，程序的控制流程跳转到循坏块的迭代部分继续判断
D.执行到continue后，程序的控制流跳转到循环块的之后之后执行
E.执行到continue后，程序的控制流跳转到循环块的迭代部分继续判断
3.在Java的异常处理语句try-catch-final中，以下描述不正确的是：
A.当程序运行时抛出的异常是catch语句中异常的子类，异常也会被捕捉执行相应的catch语句
B.try后面是可能产生异常的代码，catch后面是捕获到某种异常对象时进行处理的代码，final后面是没有捕获到异常时要执行的代码
C.catch语句和final语句都可以缺省
D.try后面是可能产生异常的代码，catch后面是捕获到某种异常对象时进行处理的代码，final后面无论是否捕获到异常都必须执行的代码
E.catch语句用来处理程序运行时的非致命性错误，而final语句用来处理程序运行时的致命性错误
4.能否利用返回值对函数进行重载？
A.不行，Java系统无法区分仅返回值不同的函数，编译时会报错
B.不行，因为Java并未明确要求函数的返回值必须赋给变量
C.可以，因为返回值也是函数的重要组成部分
D.可以，但仅能用于返回值为简单变量的情况
E.可以，但要求一个函数有返回值，另一个函数没有返回值
5.如果一个程序段中有多个catch，则程序会按如下哪种情况执行？
A.对每个catch都执行一次
B.找到适合的例外类型后就不再执行后面的catch
C.按顺序找到和catch异常类型匹配的第一个catch块执行，如果final块是必须执行的
D.找到每个符合条件的catch都执行一次
E.找到适合的异常类型后继续执行后面的catch
6.下面关于继承的哪些叙述是正确的？
A.在java中一个类只能实现一个接口
B.在java中对类只允许单一继承
C.在java中一个类不能同时继承一个类和实现一个接口
D.java的单一继承使代码更可靠
E.java的类允许使用多继承，即一个类允许有多个父类
7.给定下列代码：
public class Parent{
public int addValue(int a,int b){
int s;
s = a + b;
return s;
}
}
class Child extends Parent{
}
下列的方法声明如果作为Child类的方法，哪些方法不是对Parent类中的addValue方法的重写。
A.public int addValue(int a,int C){//do something...}
B.public void addValue(){/*do something...*/}
C.public int addValue(int a,int b){/*do something...*/}
D.protected int addValue(int a,double b)
E.int addValue(int a,int b){/*do something...*/}
8.下列组件哪个是Swing顶层容器？
A.JPanel
B.JSplitPane
C.JDialog
D.JApplet
E.ContentPane
9.以下关于Object类的描述中，错误的是（）
A.Object类提供了wait，notify，notifyAll等函数用于线程间同步
B.Object类提供了clone，compare，delete，add，insert等函数用于对对象进行操作
C.Object类是其他一切类的直接或间接父类
D.Object类定义了一些每个类都应该具有的基本的成员变量和成员函数
E.Object类是所有自定义类的直接或间接父类，但不是系统类的父类
10.下面标识符哪些是Java中的保留字或关键字？
A.synchronized
B.switch
C.break
D.class
E.out
三、判断题（20题，1’）
1.一个流就是一个从源流向目的地的数据序列
A.对
B.错
2.引用一个类的属性或调用其方法,必须以这个类的对象为前缀
A.对
B.错
3.多线程没有安全问题
A.对
B.错
4.构造函数的方法名可由编程人员任意命名
A.对
B.错
5.在Java中,高优先级的可运行线程可能会抢占低优先级线程
A.对
B.错
6.Java有垃圾回收机制,内存回收程序可在指定的时间释放内存对象
A.对
B.错
7.多线程安全问题的解决方案可以使用Lock提供的具体的锁对象操作
A.对
B.错
8.Java程序里既是面向对象的又是面向过程的语言
A.对
B.错
9.构造函数用于创建类的实例对象,构造函数名应与类名相同,返回类型为void
A.对
B.错
10.继承是一种由已有的类创建新类的机制
A.对
B.错
11.Java只支持单继承,也就是说子类只能有一个直接父类
A.对
B.错
12.抽象方法使用关键词abstract修饰
A.对
B.错
13.Java中的引用变量需要初始化,简单变量可以不进行初始化
A.对
B.错
14.子类可以继承父类的除私有成员以外的其它所有成员
A.对
B.错
15.类的私有属性和私有方法可以被其子类访问
A.对
B.错
16.Java程序里,创建新的类对象用关键字new,回收无用的类对象使用关键字free
A.对
B.错
17.Java的源代码中定义几个类,编译结果就生成几个以.class为后缀的字节码文件
A.对
B.错
18.构造函数的方法名可由编程人员任意命名
A.对
B.错
19.如果线程死亡,它便不能运行
A.对
B.错
20.抽象方法使用关键词abstract修饰
A.对
B.错
四、简答题（20题，5’）
1.什么是JDBC。
2.Throw/throws有什么联系和区别?
3.什么是相等?什么是同一?
4.什么是事件源,事件监听,事件对象?
5.什么是异常?简述Java的异常处理机制。
6.什么是多态
7.简述Java链接数据库的步骤
8.什么是抽象的定义以及抽象的好处
9.简述程序、进程和线程之间的关系?什么是多线程程序?
10.什么是面向对象,什么是面向过程。
11.请论述java的内存回收机制。
12.什么是封装的定义以及封装好处有哪些
13.举例说明什么是方法重载,什么是方法重写。
14.简述对象锁的工作原理
15.什么是死锁
16.举例说明什么是方法重载,什么是方法重写。
17.什么是封装的定义以及封装好处有哪些
18.什么是抽象类和抽象方法?
19.什么是接口?和抽象类有什么相同点和不同点?
20.面向对象中抽象的定义以及抽象的好处
五、编程题（8题，10’）
1.按以下要求编写程序：
利用多线程编程思想，通过继承Thread类来实现多线程。
要求创建3个新线程，每个线程睡眠一段时间（0～6秒），然后结束。
2.编程实现多线程的内存共享：
用三个线程模拟电影院的4个售票口，总共出售50张票。
3.根据以下要求编程实现功能：
在C盘根目录创建文本文件Hello.txt。
（1）向文件中写入文本：I love Java very much.
（2）把hello.txt中的文本读出来显示到屏幕上。
（3）使用try、catch方法处理I/O异常
（4）利用BufferedWriter进行缓冲。
4.按以下要求编写程序：
（1） 定义包含5个元素的数组intArrayExc = {11,23,0,15,7}
（2） 捕获公式intArrayExc[i] / intArrayExc[i+1]可能抛出的异常
5.利用GUI技术，实现以下界面：
（1）填加按钮button事件监听；
（2）当点击按钮后，用户名和密码文本框内容清空。
6.参照以上类结构图编写代码：
设计Shape2D以及Shape3D接口，继承自父接口Shape
要求如下：
（1）Circle类实现Shape2D接口，Box类实现Shape3D接口。Shape接口中有个setColor（String color）方法，用来给图形设置颜色
（2）Shape2D接口中有一个计算面积的方法area()，还有一个计算周长的方法perimeter()
（3）Shape3D接口中有一个计算表面积的方法surfaceArea()，还有一个计算体积的方法volume()
（4） 设计接口ShowInfo,其中有showShapeInfo()方法，用来显示实现该接口类对象的详细信息
（5） 在测试类中创建Circle、Box类对象，并体现出多态思想
7.设计一个
Birthday类，其成员变量至少有：year,month,day；
（1）创建构造方法，并进行构造方法间的调用：
Birthday（int year,int month,int day）
Birthday（int year,int month）
Birthday（int year）
Birthday（ ）
（2）创建详细信息输出函数printBirthday()，输出对象的信息：输出格式 年-月-日
（3）分别用各种构造方法初始化不同的对象，然后调用printBirthday方法输出对象的信息
8.根据以下要求编写代码：
（1）将三个int型数字255/0/-1写入数据文件data.dat
（2）将data.dat中的三个整数读出并相加，结果输出到屏幕上。
9.按以下要求编写程序
（1）创建Shape类，有属性表示颜色color，以及get,set方法。
（2）创建一个Rectangle类，继承Shape类。添加width和height两个成员变量。
（3）在Rectangle中添加两种方法分别计算矩形的周长和面积。
（4）创建编程利用Rectangle输出一个矩形的周长和面积。