一. 单选题（共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+"。");
}
}
894
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
