一. 单选题(共4题,56.8分)
1. (单选题)下面关于Set集合处理重复元素的说法正确的是( );
- A. 如果加入一个重复元素,将抛出异常
- B. 如果加入一个重复元素,add方法将返回false
- C. 集合通过调用equals方法可以返回包含重复值的元素
- D. 添加重复值将导致编译出错
我的答案: B正确答案: B
14.2分
2. (单选题)定义一个Worker类,关于hashCode()方法的说法正确的是?( )
- A. 在Worker类中,hashCode()方法必须被重写
- B. 如果hashCode的值相同,则两个Worker类的对象就认为是相等的
- C. hashCode的值不同时,则两个对象必定不同
- D. 以上说法均正确
我的答案: C正确答案: C
14.2分
3. (单选题)关于Iterator的描述错误的是:( )
- A. Iterator可以对集合Set中的元素进行遍历
- B. hasNext()方法用于检查集合中是否还有下一个元素
- C. next()方法返回集合中的下一个元素
- D. next()方法的返回值为false时,表示集合中的元素已经遍历完毕
我的答案: D正确答案: D
14.2分
4. (单选题)以下关于Set对象的创建错误的是?( )
- A. Set set=new Set();
- B. Set set=new HashSet();
- C. HashSet set=new HashSet();
- D. Set set=new HashSet(10);
我的答案: A正确答案: A
14.2分
二. 多选题(共1题,14.2分)
5. (多选题)下列有关HashSet的描述正确的是( )
- A. HashSet是Set的一个重要实现类
- B. HashSet中的元素无序但可以重复
- C. HashSet中只允许一个null元素
- D. 不适用于存取和查找
我的答案: AC正确答案: AC
14.2分
三. 判断题(共2题,29分)
6. (判断题)TreeMap是采用一种有序树的结构实现了Map的子接口SortedMap,该类按键的升序的次序排列元素。
- A. 对
- B. 错
我的答案: 对正确答案: 对
14.2分
7. (判断题)ArrayList类采用可变大小的数组实现List接口,并提供了访问数组大小的方法,它的对象会随着元素的增加其容器自动扩大。
- A. 对
- B. 错
我的答案: 对正确答案: 对
1. (单选题)
以下程序段输出的结果是( )。
public class Test{
public static void main(String[] args){
String str="ABCDE";
str.subtring(3);
str.concat("XYZ");
System.out.print(str);
}
}
- A. DE
- B. DEXYZ
- C. ABCDE
- D. CDEXYZ
我的答案: C 正确答案: C
0分
2. (单选题)在Java语言中,下列表达式返回false的是( )。
- A. "hello"=="hello"
- B. "hello".equals(new StringBuilder("hello"))
- C. "hello".equals("hello")
- D. "hello".equals(new String("hello"))
我的答案: B正确答案: B
0分
3. (单选题)
String str1="java";
String str2="java";
String str3=new String("java");
StringBuffer str4=new StringBuffer("java");
以下表达式的值为true的是( )。
- A. str1==str2;
- B. str1==str4;
- C. str2==str3;
- D. str3==str4;
我的答案: A正确答案: A
12.5分
4. (单选题)
下面程序段的输出结果是( )。
StringBuffer buf1=new StringBuffer(20);
System.out.println(buf1.length()+","+buf1.capacity());
- A. 0,20
- B. 0,null
- C. 20,20
- D. 0,0
我的答案: A正确答案: A
12.5分
5. (单选题)
下面的程序段执行后输出的结果是( )。
StringBuffer buf=new StringBuffer("Beijing2008");
buf.replae(0,7,"Hangzhou");
System.out.println(buf.toString());
- A. Hangzhou2008
- B. Hangzhoug2008
- C. Hangzhou008
- D. Beijing2008
我的答案: A正确答案: A
12.5分
二. 判断题(共3题,37.5分)
6. (判断题)在Java中,“abc”.length( )的值是3。
- A. 对
- B. 错
我的答案: 对正确答案: 对
12.5分
7. (判断题)用“+”可以实现字符串的拼接,用“-”可以从一个字符串中去除一个字符子串。
- A. 对
- B. 错
我的答案: 错正确答案: 错
12.5分
8. (判断题)StringBuffer的实例对象所包含的字符序列可以被修改。
- A. 对
- B. 错
我的答案: 对正确答案: 对
1. (单选题)如果Java捕获异常语句结构中包含一个try语句块、多个catch语句块和一个finally语句块,( )。
- A. finally语句块可能会被执行
- B. 多个catch语句块中可能有一个会被执行
- C. 多个catch语句块可能全部会被执行
- D. 多个catch语句块中肯定有一个会被执行
我的答案: B正确答案: B
16.6分
2. (单选题) Java类库中直接继承自Throwable类的类是( )。
- A. 只有Error和Exception类
- B. 只有Exception类
- C. 有Error、Exception类等多个类
- D. 只有Error类
我的答案: A正确答案: A
16.6分
3. (单选题)通过Java捕获异常的语句结构是的( )。
- A. 肯定可以捕获到出现的异常
- B. 一旦捕获到异常,程序结束运行
- C. 只能有针对性的捕获一个或多个异常
- D. 只能捕获指定的一个特定异常
我的答案: C正确答案: C
0分
4. (单选题)如果在一个自定义类的一个方法中需要抛出异常,( )。
- A. 只能抛出自定义的异常
- B. 只能抛出在本类中定义的异常
- C. 可以抛出Java类库中定义的异常
- D. 可以抛出未定义的异常
我的答案: C正确答案: C
16.6分
5. (单选题) Java定义的异常是类,这种类与其他类的最基本区别是( )。
- A. 异常类没有直接或间接的继承自Object类
- B. 异常类全部直接或间接地继承自Throwable类
- C. 异常类全部直接或间接的继承自Error类
- D. 异常类没有直接或间接地继承自Throwable类
我的答案: B正确答案: B
16.6分
6. (单选题)通过Java捕获异常语句结构捕获异常的过程中,( )。
- A. 一个catch只能捕获一个特定的异常
- B. 一个异常可以同时被多个catch捕获
- C. 一个catch能捕获一个特定异常及其父类异常。
- D. 一个catch能捕获一个特定异常及其子类异常
我的答案: D正确答案: D
1. (程序题)
编程练习:
1. 创建接口Ball
-
包含抽象方法play( )
2. 创建外部类BallTest
-
定义方法 void playBall(Ball ball),调用接口中的 play( ) 方法
3. 分别通过成员内部类、方法内部类以及匿名内部类完成接口实现
-
在BallTest中,创建成员内部类 Inner_m 实现接口Ball,在类中重写 play( ) 方法,输出两条信息,分别为"成员内部类:"和"打篮球"
-
在BallTest中, 创建成员方法 info() ,在方法中创建方法内部类 Inner_f 实现Ball接口,重写 play( ) 方法,输出三条信息,分别为"**********","方法内部类:" 和 "打乒乓球"
-
在测试类Test中通过匿名内部类实现接口Ball,并重写 play( )方法,输出两条信息,分别为 "**********","匿名内部类:" 和 "打排球"
4. 创建测试类Test,通过创建BallTest类及相关内部类实例,调用相关方法,依次完成相关内部类测试。运行效果参见效果图:
成员内部类:
打篮球
方法内部类:
打乒乓球
匿名内部类:
打排球
我的答案:
public class Test {
public static void main(String[] args) {
BallTest.Inner_m nb = new BallTest().new Inner_m();
nb.play();
BallTest wb = new BallTest();
Ball ball = wb.info();
ball.play();
BallTest nm = new BallTest();
nm.playBall(new Ball() {
public void play() {
// System.out.println("***************");
System.out.println("匿名内部类:\n打排球");
}
});
}
}
interface Ball{
public void play();
}
class BallTest {
void playBall(Ball ball) {
ball.play();
}
class Inner_m implements Ball {
public void play() {
System.out.println("成员内部类:");
System.out.println("打篮球");
};
}
public Ball info() {
class Inner_f implements Ball {
public void play() {
System.out.println("方法内部类:");
System.out.println("打乒乓球");
};
}
return new Inner_f();
}
}
正确答案:
成员内部类: 打篮球 方法内部类: 打乒乓球 匿名内部类: 打排球
1. (程序题)
编程练习:
1. 定义一个父类Animal类
属性:kind(种类)
方法:创建带参(kind为参数)构造方法
创建cry():void方法
2. 编写三个具体的子类Cat类、Dog类、Sheep类
分别重写父类中的 cry() 方法,输出信息分别为
Cat类:小猫的叫声:喵喵喵~~~
Dog类:小狗的叫声:汪汪汪~~~
Sheep类:小羊的叫声:咩咩咩~~~
3. 编写测试类,首先生成长度为3的父类对象数组,然后依次向数组中存入数据,现设定存储规则为:
b) 生成一个 Cat 类的对象,存入数组中第一个位置
c) 生成一个 Dog 类的对象,存入数组中第二个位置
d) 生成一个 Sheep 类的对象,存入数组中第三个位置
最后循环输出数组成员,并分别调用 cry() 方法。运行效果:
小猫的叫声:喵喵喵~~~
小狗的叫声:汪汪汪~~~
小羊的叫声:咩咩咩~~~
正确答案:
小猫的叫声:喵喵喵~~~ 小狗的叫声:汪汪汪~~~ 小羊的叫声:咩咩咩~~~
答案解析:
public class Test {
public static void main(String[] args) {
//生成父类对象数组,数组长度为3
Animal[] animal=new Animal[3];
//数组中存放三种具体子类的实例
animal[0]=new Cat();
animal[1]=new Dog();
animal[2]=new Sheep();
//循环输出,循环体中每个对象分别调用cry()方法。
for(int i=0;i<animal.length;i++){
animal[i].cry();
}
}
}
class Animal {
//属性:kind(种类)
private String kind;
public Animal(){
}
//创建带参(king为参数)构造函数
public Animal(String kind){
this.setKind(kind);
}
//应用封装实现对私有属性的get/set操作
public void setKind(String kind){
this.kind=kind;
}
//创建成员方法cry():void
public void cry(){
}
}
class Cat extends Animal {
//重写父类cry()方法,输出信息为“小猫的叫声:喵喵喵~~~”
public void cry(){
System.out.println("小猫的叫声:喵喵喵~~~");
}
}
class Dog extends Animal {
//重写父类cry()方法:输出信息为“小狗的叫声:汪汪汪~~~”
public void cry(){
System.out.println("小狗的叫声:汪汪汪~~~");
}
}
class Sheep extends Animal {
//重写父类的方法cry(),要求输出信息“小羊的叫声:咩咩咩~~~”
public void cry(){
System.out.println("小羊的叫声:咩咩咩~~~");
}
}
33.3分
2. (程序题)
编程练习:
1、创建一个抽象类Vehicle,拥有一个抽象方法getWheels(),返回值类型为String。
2、创建两个类Car和Motobike继承自Vehicle类,并实现getWheels()方法。
3、创建测试类Test,在主方法中创建Car和Motobike类的实例对象,调用getWheels(),并将信息显示在控制台。运行效果如下:
汽车有四个车轮
摩托车有两个车轮
正确答案:
汽车有四个车轮 摩托车有两个车轮
答案解析:
public class Test {
public static void main(String[] args) {
Car c=new Car();
System.out.println(c.getWheels());
Motobike m=new Motobike();
System.out.println(m.getWheels());
}
}
abstract class Vehicle{
public abstract String getWheels();
}
class Car extends Vehicle{
@Override
public String getWheels() {
// TODO Auto-generated method stub
return "汽车有四个车轮";
}
}
class Motobike extends Vehicle{
public String getWheels() {
// TODO Auto-generated method stub
return "摩托车有两个车轮";
}
}
33.3分
3. (程序题)
编程练习:
1、根据杨梅和香蕉的共性,抽取父类水果(Fruits)
私有属性:水果的形状(shape)和口感(taste)
方法:
1) 带参构造函数(参数为shape和taste)
2) 创建无参无返回值得方法eat(描述内容为:水果可供人们食用!)
3) 重写equals方法,比较两个对象是否相等(比较shape,taste)
2、子类Waxberry
私有属性:颜色(color)
方法:
1) 调用父类的构造方法,完成属性赋值
2) 创建不允许重写的face方法,描述为:杨梅:**、**,果味酸甜适中。
3) 重写父类eat方法,描述为:杨梅酸甜适中,非常好吃!
4) 重写toString方法,输出的表现形式不同(输出shape,color,taste)
5) 要求Waxberry类不允许有子类
3、子类:Banana
私有属性:品种(variety)
方法:
1) 带参构造方法为所有属性赋值
2) 创建无参无返回值的advantage方法,描述为:**果形**,果肉香甜,可供生食。
3) 重载要求(2)中的advantage方法(带参数color),描述为:**颜色为**
4、测试,运行效果参照效果图:
1) 实例化2个父类对象,并传入两组相同的参数值
2) 调用父类eat方法
3) 测试重写equals方法,判断两个对象是否相等
4) 实例化子类Wacberry对象,并传入相关参数值
5) 调用子类face方法和重写父类eat方法后的eat方法
6) 测试重写toString方法,输出子类对象的信息
7) 实例化Banana类对象,并传入相关参数值
8) 调用子类的advantage和它的重载方法
正确答案:
水果可供人们食用! fru1和fru2的引用比较:true ————————————————————————— 杨梅:紫红色、圆形,果味酸甜适中。 杨梅酸甜适中,非常好吃! 杨梅的信息:果实为圆形、紫红色、酸甜适中,非常好吃! ————————————————————————— 仙人蕉果形短而稍圆,果肉香甜,可供生食。 仙人蕉颜色为黄色。
答案解析:
public class Test {
public static void main(String[] args) {
// 实例化2个父类对象,传入两组相同的参数值
Fruits fru1=new Fruits("杨梅","果味酸甜适中");
Fruits fru2=new Fruits("杨梅","果味酸甜适中");
// 调用父类eat方法
fru1.eat();
// 测试重写equals方法,判断两个对象是否相等
System.out.println("fru1和fru2的引用比较:"+fru1.equals(fru2));
System.out.println("—————————————————————————");
// 实例化子类对象,并传入相关参数值
Waxberry waxberry=new Waxberry("圆形","酸甜适中","紫红色");
// 调用子类face方法和eat方法
waxberry.face();
waxberry.eat();
// 测试重写toString方法,输出子类对象的信息
System.out.println(waxberry);
System.out.println("—————————————————————————");
// 实例化Banana类对象,并传入相关参数值
Banana banana=new Banana("短而稍圆","果肉香甜","仙人蕉");
// 调用子类的advantage和它的重载方法
banana.advantage();
banana.advantage("黄色");
}
}
class Fruits {
// 私有属性:水果的形状(shape)和口感(taste)
private String shape;
private String taste;
public Fruits() {
}
// 带参构造函数(参数为shape和taste)
public Fruits(String shape,String taste) {
this.setShape(shape);
this.setTaste(taste);
}
//通过封装实现对私有属性的get/set访问
public void setShape(String shape){
this.shape=shape;
}
public String getShape(){
return this.shape;
}
public void setTaste(String taste){
this.taste=taste;
}
public String getTaste(){
return this.taste;
}
// 创建无参无返回值得方法eat(描述内容为:水果可供人们食用!)
public void eat(){
System.out.println("水果可供人们食用!");
}
// 重写equals方法,比较两个对象是否相等(比较shape,tast)
public boolean equals(Object obj){
if(obj==null)
return false;
Fruits f=(Fruits)obj;
if(this.getShape().equals(f.getShape())&& this.getTaste().equals(f.getTaste()))
return true;
else return false;
}
}
final class Waxberry extends Fruits{
// 私有属性:颜色(color)
private String color;
public void setColor(String color){
this.color=color;
}
public String getColor(){
return this.color;
}
//创建构造方法,完成调用父类的构造方法,完成属性赋值
public Waxberry(String shape,String taste,String color){
super(shape,taste);
this.setColor(color);
}
//创建不允许重写的face方法,描述为:杨梅:**、**,果味酸甜适中
public final void face(){
System.out.println("杨梅:"+this.getColor()+"、"+this.getShape()+",果味酸甜适中。");
}
//重写父类eat方法,描述为:杨梅酸甜适中,非常好吃!
public void eat(){
System.out.println("杨梅酸甜适中,非常好吃!");
}
//重写toString方法,输出的表现形式不同(输出shape,color,taste)
public String toString(){
return "杨梅的信息:果实为"+this.getShape()+"、"+this.getColor()+"、"+this.getTaste()+",非常好吃!";
}
}
class Banana extends Fruits{
// 私有属性:品种(variety)
private String variety;
public void setVariety(String variety){
this.variety=variety;
}
public String getVariety(){
return this.variety;
}
//创建带参构造方法为所有属性赋值
public Banana(String shape,String taste,String variety){
super(shape,taste);
this.setVariety(variety);
}
//创建无参无返回值的advantage方法,描述为:**果形**,果肉香甜,可供生食。
public void advantage(){
System.out.println(this.getVariety()+"果形"+this.getShape()+",果肉香甜,可供生食。");
}
//创建重载advantage方法(带参数color),描述为:**颜色为**
public void advantage(String color){
System.out.println(this.getVariety()+"颜色为"+color+"。");
}
}