一、 选择题
|
1. |
Person类和Test类的代码如下所示，则代码中的错误语句是（ C ）。（选择一项） |
|
|
|
public class Person { public String name; public Person(String name) { this.name = name; } } public class Test { public static void main(String[] args) { final Person person = new Person("欧欧"); person.name = "美美"; person = new Person("亚亚"); } } |
|
|
|
|
|
|
|
A. |
final Person person = new Person("欧欧"); |
|
|
B. |
person.name = "美美"; |
|
|
C. |
person = new Person("亚亚"); |
|
|
D. |
没有错误 |
|
2. |
如下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. |
运行时出现异常 |
|
3. |
以下代码中错误的语句是（ D ）。（选择一项） |
|
|
|
public class Something{ public static void main(String[] args){ final Other o=new Other(); new Something().addOne(o);//1 } public void addOne( Other o){ o.i++;//2 o = new Other();//3 } } class Other{ public int i; } |
|
|
|
|
|
|
|
A |
1 |
|
|
B. |
2 |
|
|
C. |
3 |
|
|
D. |
没有错误 |
|
4. |
下列选项中，关于Java的抽象类和抽象方法说法正确的是（ AC ）。（选择二项） |
|
|
|
|
|
|
|
A |
抽象类中可以含有0个或多个抽象方法 |
|
|
B. |
抽象类中不可以有构造方法 |
|
|
C. |
一个类中若有抽象方法，则这个类必为抽象类 |
|
|
D. |
子类必须重写父类所有的抽象方法 |
|
5. |
在Java中关于abstract关键字，以下说法正确的是（ AB ）。（选择两项） |
|
|
|
|
|
|
|
A |
abstract类中可以没有抽象方法 |
|
|
B. |
abstract类的子类也可以是抽象类 |
|
|
C. |
abstract方法可以有方法体 |
|
|
D. |
abstract类可以创建对象 |
|
6. |
以下选项可替换题目中//add code here而不产生编译错误的是（ AD ）。（选择二项） |
|
|
|
public abstract class MyClass{ public int constInt=5; //add code here public void method( ){ } } |
|
|
|
|
|
|
|
A |
public abstract void method(int a); |
|
|
B. |
constInt =constInt+5; |
|
|
C. |
public int method( ); |
|
|
D. |
public abstract void anotherMethod( ); |
|
7. |
在Java接口中，下列选项中属于有效的方法声明是（ AC ）。（选择二项） |
|
|
|
|
|
|
|
A |
public void aMethod( ); |
|
|
B. |
final void aMethod( ); |
|
|
C. |
void aMethod(){ } |
|
|
D. |
private void aMethod( ); |
|
8. |
以下选项中关于匿名内部类的说法正确的是（ BC ）。（选择二项） |
|
|
|
|
|
|
|
A. |
匿名内部类可以实现多个接口，或者继承一个父类 |
|
|
B. |
匿名内部类不能是抽象类，必须实现它的抽象父类或者接口里包含的所有抽象方法 |
|
|
C. |
匿名内部类没有类名，所以匿名内部类不能定义构造方法 |
|
|
D. |
匿名内部类可以直接访问外部类的所有局部变量 |
二、 判断题（共20个题目，总计10分）
- 声明为final的类不能是超类。（ T ）
- 使用final修饰的变量将变成常量，其中不能再被改变；使用final修饰的方法将无法被子类重载；使用final修饰的类将无法再被其他类继承。（ T ）
- 抽象方法不能含有方法体，并且必须定义在抽象类中。（ F ）
- 抽象类是指在class前加使用abstract关键字修饰，且可以存在抽象方法和普通方法的类。（ T ）
- 接口中只有常量，没有变量；只有抽象方法，并且全部都是public方法。（ T ）
- 抽象类和接口都不能实例化，都没有构造方法。（ F ）
- 接口并不要求实现类和接口在概念本质上一致的，仅仅是实现了接口定义的约定或者能力而已。接口定义了“做什么”，而实现类负责完成“怎么做”，体现了功能（规范）和实现分离的原则。（ T ）
- 内部类作为外部类成员，权限修饰符和其他成员一样，可声明为private、默认、protected或public。( T )
- 匿名内部类适合创建那种只需要使用一次的类，它可以实现一个或多个接口，或者继承一个父类。（ F ）
- 对于物理连接，比如数据库连接、输入流输出流、Socket连接等，垃圾回收机制无能为力，必须手动关闭才可以。( T )
- 垃圾回收机制回收任何对象之前，总会先调用它gc( )方法，该方法是Object类提供的方法。不要主动调用某个对象的该方法，应该交给垃圾回收机制调用。（ F ）
三、 简答题
- final和abstract关键字的作用。
- 接口和抽象类的联系和区别。
- 内部类的类型及其特点。
四、 编码题
1.编写程序描述兔子和青蛙
需求说明：使用面向对象的思想，设计自定义类描述兔子和青蛙。
实现思路及关键代码
1) 分析兔子和青蛙的共性
2) 根据共性，定义抽象的动物类
属性：名字、颜色、类别（哺乳类、非哺乳类）
方法：吃饭，发出叫声
3) 根据青蛙会游泳 抽象游泳的接口
方法：游泳
4) 定义兔子继承动物类，青蛙继承动物同时实现游泳接口
程序运行结果如图所示。
1 /**
2 *
3 * 动物类
4 *
5 * @author Administrator
6 *
7 */
8 public abstract class Animal
9 {
10 private String name;//名字
11 private String color;//颜色
12 private String type;//类别（哺乳类、非哺乳类）
13 public Animal()
14 {
15 super();
16 }
17 public Animal(String name, String color, String type)
18 {
19 super();
20 this.name = name;
21 this.color = color;
22 this.type = type;
23 }
24 public String getName()
25 {
26 return name;
27 }
28 public void setName(String name)
29 {
30 this.name = name;
31 }
32 public String getColor()
33 {
34 return color;
35 }
36 public void setColor(String color)
37 {
38 this.color = color;
39 }
40 public String getType()
41 {
42 return type;
43 }
44 public void setType(String type)
45 {
46 this.type = type;
47 }
48 /**
49 *
50 * 发出叫声
51 *
52 */
53 public abstract void shout();
54 /**
55 *
56 * 吃饭
57 *
58 */
59 public abstract void eat();
60 }
61 /**
62 *
63 * 游泳接口
64 *
65 * @author Administrator
66 *
67 */
68 public interface Swimmable
69 {
70 /**
71 *
72 * 游泳
73 *
74 */
75 public void swim();
76 }
77 public class Frog extends Animal implements Swimmable
78 {
79 public Frog()
80 {
81 super();
82 }
83 public Frog(String name, String color, String type)
84 {
85 super(name, color, type);
86 }
87 @Override
88 public void shout()
89 {
90 System.out.println("那只" + super.getColor()
91 + "的，名字叫" + super.getName() + "的青蛙正在呱呱的叫");
92 }
93 @Override
94 public void eat()
95 {
96 System.out.println("青蛙是" + super.getType() + ",爱吃昆虫");
97 }
98 @Override
99 public void swim()
100 {
101 System.out.println("虽然不是鱼，但是青蛙也是游泳高手");
102 }
103 }
104 public class Rabbit extends Animal
105 {
106 public Rabbit()
107 {
108 super();
109 }
110 public Rabbit(String name, String color, String type)
111 {
112 super(name, color, type);
113 }
114 @Override
115 public void shout()
116 {
117 System.out.println("那只" + super.getColor()
118 + "的，名字叫" + super.getName() + "的兔子正在叽叽的叫");
119 }
120 @Override
121 public void eat()
122 {
123 System.out.println("兔子是" + super.getType() + ",爱吃胡萝卜");
124 }
125 }
126 public class Test
127 {
128 public static void main(String[] args)
129 {
130 Animal rabbit = new Rabbit("美人", "黑色", "哺乳类");
131 rabbit.shout();
132 rabbit.eat();
133 System.out.println("====================");
134 Animal frog = new Frog("大兵", "绿色", "非哺乳类");
135 frog.shout();
136 frog.eat();
137 Swimmable swimer = (Swimmable) frog;
138 swimer.swim();
139 }
140 }
2.编写程序描述影视歌三栖艺人
需求说明：请使用面向对象的思想，设计自定义类，描述影视歌三梄艺人。
实现思路及关键代码
1) 分析影视歌三栖艺人的特性
a) 可以演电影
b) 可以演电视剧
c) 可以唱歌
2) 定义多个接口描述特性
a) 演电影的接口-----方法：演电影
b) 演电视剧的接口-----方法：演电视剧
c) 唱歌的接口-----方法：唱歌
3) 定义艺人类实现多个接口
程序运行结果如图2所示。
1 /**
2 *
3 * 可演电影接口
4 *
5 * @author Administrator
6 *
7 */
8 public interface Filmable
9 {
10 /**
11 *
12 * 演电影
13 *
14 */
15 public void actFilm();
16 }
17 /**
18 *
19 * 会唱歌接口
20 *
21 * @author Administrator
22 *
23 */
24 public interface Singable
25 {
26 /**
27 *
28 * 唱歌
29 *
30 */
31 public void sing();
32 }
33 /**
34 *
35 * 会演电视剧接口
36 *
37 * @author Administrator
38 *
39 */
40 public interface TVable
41 {
42 /**
43 *
44 * 演电视剧
45 *
46 */
47 public void showTV();
48 }
49 public class Star implements Filmable, TVable, Singable
50 {
51 private String name;//姓名
52 public Star()
53 {
54 super();
55 }
56 public Star(String name)
57 {
58 super();
59 this.name = name;
60 }
61 public String getName()
62 {
63 return name;
64 }
65 public void setName(String name)
66 {
67 this.name = name;
68 }
69 @Override
70 public void sing()
71 {
72 System.out.println("我会唱歌");
73 }
74 @Override
75 public void showTV()
76 {
77 System.out.println("我能演电视剧");
78 }
79 @Override
80 public void actFilm()
81 {
82 System.out.println("我能演电影");
83 }
84 public void introduce()
85 {
86 System.out.println("大家好，我是" + name);
87 }
88 }
89 public class Test
90 {
91 public static void main(String[] args)
92 {
93 Star star = new Star("马素素");
94 star.introduce();
95 star.actFilm();
96 star.showTV();
97 star.sing();
98 }
99 }
3.写一个方法对任意引用数据类型数组进行排序。具体要求如下:
1) 方法声明为public void sortArr(Object arr[]){ }
2) 方法中首先输出排序前数组内容，然后进行排序，最后输出排序后数组内容。
3) 可以是冒泡排序或其他算法实现，不直接调用Java提供的方法实现排序。
思路：任意类实现Comparable接口来实现该引用数据类型的元素排序，在sort()方法中将Object强转成Comparable实现两个对象的比较。
1 public void sort(Object[] arr)
2 {
3 //输出排序前数组
4 for (int i = 0; i < arr.length; i++)
5 {
6 System.out.println(arr[i]);
7 }
8 //大循环，一共n个元素，达到最终有序，至多n-1趟比较
9 Object temp;
10 for (int i = 0; i < arr.length - 1; i++)
11 {
12 //定义一个符号量
13 boolean flag = true;//没有交换，有序
14 //小循环
15 for (int j = 0; j < arr.length - 1 - i; j++)
16 {
17 //如果前一个大于后一个
18 Comparables c1 = (Comparables) arr[j];
19 Comparables c2 = (Comparables) arr[j + 1];
20 if (c1.compareTo(c2) > 0)
21 {
22 //交换
23 temp = arr[j];
24 arr[j] = arr[j + 1];
25 arr[j + 1] = temp;
26 //修改符号量
27 flag = false;//交换过，无序
28 }
29 }
30 //判断经过此趟循环后是否已经有序
31 if (flag)
32 {
33 break;//退出外层循环，省略后续趟循环
34 }
35 }
36 //输出排序后数组
37 for (int i = 0; i < arr.length; i++)
38 {
39 System.out.println(arr[i]);
40 }
41 }
五、 可选题
1.实现不同符合PCI规范的适配器
需求说明：PCI是一种规范，所有实现了该规范的适配器，必如显卡、声卡、网卡都可以安装到PCI插槽上并工作。模拟实现该功能。
实现思路及关键代码
1) 定义PCI接口，具有传送数据send()方法
2) 定义显卡VideaCard类，实现该接口
3) 定义声卡AudioCard类，实现PCI接口
4) 定义网卡NetCard类，实现PCI接口
5) 定义测试类，让显卡、声卡、网卡发送数据
1 class a
2 {
3 /**
4 *
5 * PCI接口
6 *
7 * @author Administrator
8 *
9 *
10 *
11 */
12 public interface PCI
13 {
14 /**
15 *
16 * 传输数据
17 *
18 */
19 public void send();
20 }
21 public class VideoCard implements PCI
22 {
23 @Override
24 public void send()
25 {
26 System.out.println("使用PCI接口传输视频数据");
27 }
28 }
29 public class SoundCard implements PCI
30 {
31 @Override
32 public void send()
33 {
34 System.out.println("使用PCI接口传输声音数据");
35 }
36 }
37 public class NetCard implements PCI
38 {
39 @Override
40 public void send()
41 {
42 System.out.println("使用PCI接口传输网络数据");
43 }
44 }
45 public class Test
46 {
47 public static void main(String[] args)
48 {
49 PCI p1 = new VideoCard();
50 p1.send();
51 PCI p2 = new SoundCard();
52 p2.send();
53 PCI p3 = new NetCard();
54 p3.send();
55 }
56 }
57 }
2.实现不同引用类型对象的大小比较
需求说明：学生类，新闻类，商品类虽然是完全不同的类，但是都具有比较的能力，比如可以比较两个学生的大小，但需要指定比较的依据是学号、姓名还是成绩等。
实现思路及关键代码：
将比较的能力定义为接口，让学生、新闻、商品类都实现该接口。
1) 定义接口Comparable，其中包含唯一的方法int compareTo(Object obj)；返回值>0，表示大于，返回值=0，表示等于，返回值<0，表示小于。
2) 定义学生类，包括学号、姓名、年龄和分数，实现Comparable接口，按照分数倒序排列；
3) 定义新闻类，包括编号（int类型）、标题、内容和点击数，实现Comparable接口，按照编号正序排列；
4) 定义测试类，分别创建两个学生对象、新闻对象，进行比较并输出结果。
1 /**
2 *
3 * 比较接口
4 *
5 * @author Administrator
6 *
7 *
8 *
9 */
10 public interface Comparable
11 {
12 /**
13 *
14 * 比较
15 *
16 * @param obj 另外一个对象
17 *
18 * @return 比较的结果 >0 大于 =0 等于 <0 小于
19 *
20 */
21 public int compareTo(Object obj);
22 }
23 public class News implements Comparable
24 {
25 private int nid;//编号
26 private String title; //标题
27 private String contents;//内容
28 private String type;//新闻类别
29 public News()
30 {
31 super();
32 }
33 public News(int nid, String title, String contents, String type)
34 {
35 super();
36 this.nid = nid;
37 this.title = title;
38 this.contents = contents;
39 this.type = type;
40 }
41 /**
42 *
43 * 按照新闻编号正序排列
44 *
45 */
46 public int compareTo(Object obj)
47 {
48 News other = (News) obj;
49 return this.nid - other.nid;
50 }
51 @Override
52 public String toString()
53 {
54 return "News [nid=" + nid + ", title=" + title + ", contents="
55 + contents + ", type=" + type + "]";
56 }
57 }
58 public class Student implements Comparable
59 {
60 private int id;
61 private String name;
62 private int age;
63 private double score;
64 public Student()
65 {
66 super();
67 }
68 public Student(int id, String name, int age, double score)
69 {
70 super();
71 this.id = id;
72 this.name = name;
73 this.age = age;
74 this.score = score;
75 }
76 /**
77 *
78 * 按照学生成绩降序排序
79 *
80 */
81 public int compareTo(Object obj)
82 {
83 Student other = (Student) obj;
84 if (this.score > other.score)
85 {
86 return -1;
87 } else if (this.score < other.score)
88 {
89 return 1;
90 } else
91 {
92 return 0;
93 }
94 }
95 @Override
96 public String toString()
97 {
98 return "Student [id=" + id + ", name=" + name + ", age=" + age
99 + ", score=" + score + "]";
100 }
101 }
102 public class Test
103 {
104 public static void main(String[] args)
105 {
106 //
107 Student stu1 = new Student(11, "小红", 18, 97d);
108 Student stu2 = new Student(12, "小东", 20, 98d);
109 if (stu1.compareTo(stu2) > 0)
110 {
111 System.out.println(stu2);
112 System.out.println(stu1);
113 } else
114 {
115 System.out.println(stu1);
116 System.out.println(stu2);
117 }
118 //
119 News news1 = new News(33, "恒大亚冠", "恒大亚冠小组被淘汰", "体育");
120 News news2 = new News(44, "上海尚学堂", "请原谅我的姗姗来迟", "IT");
121 if (news1.compareTo(news2) > 0)
122 {
123 System.out.println(news2);
124 System.out.println(news1);
125 } else
126 {
127 System.out.println(news1);
128 System.out.println(news2);
129 }
130 }
131 }