抽象类+接口+内部类作业题
一、 选择题
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接口中，下列选项中属于有效的方法声明是（a ）。（选择二项） |
|
A |
public void aMethod( ); |
|
B. |
final void aMethod( ); |
|
C. |
void aMethod(){ } |
|
D. |
private void aMethod( ); |
|
8. |
以下选项中关于匿名内部类的说法正确的是（ b,c ）。（选择二项） |
|
A. |
匿名内部类可以实现多个接口，或者继承一个父类 |
|
B. |
匿名内部类不能是抽象类，必须实现它的抽象父类或者接口里包含的所有抽象方法 |
|
C. |
匿名内部类没有类名，所以匿名内部类不能定义构造方法 |
|
D. |
匿名内部类可以直接访问外部类的所有局部变量 |
|
二、 判断题（共20个题目，总计10分）
1. 声明为final的类不能是超类。（ dui ）
2. 使用final修饰的变量将变成常量，其中不能再被改变；使用final修饰的方法将无法被子类重写；使用final修饰的类将无法再被其他类继承。（对 ）
3. 抽象方法不能含有方法体，并且必须定义在抽象类中。（ 错 ）
4. 抽象类是指在class前加使用abstract关键字修饰，且可以存在抽象方法和普通方法的类。（ dui ）
5. 接口中只有常量，没有变量；只有抽象方法，并且全部都是public方法。（ dui ）
6. 抽象类和接口都不能实例化，都没有构造方法。（ cuo ）
7. 接口并不要求实现类和接口在概念本质上一致的，仅仅是实现了接口定义的约定或者能力而已。接口定义了“做什么”，而实现类负责完成“怎么做”，体现了功能（规范）和实现分离的原则。（ dui ）
8. 内部类作为外部类成员，权限修饰符和其他成员一样，可声明为private、默认、protected或public。( dui )
9. 匿名内部类适合创建那种只需要使用一次的类，它可以实现一个或多个接口，或者继承一个父类。（ cuo ）
10. 对于物理连接，比如数据库连接、输入流输出流、Socket连接等，垃圾回收机制无能为力，必须手动关闭才可以。( dui )
11. 垃圾回收机制回收任何对象之前，总会先调用它gc( )方法，该方法是Object类提供的方法。不要主动调用某个对象的该方法，应该交给垃圾回收机制调用。（ cuo ）
三、 简答题
1. final和abstract关键字的作用。
1、final修饰类中的属性或者变量
无论属性是基本类型还是引用类型，final所起的作用都是变量里面存放的“值”不能变。
这个值，对于基本类型来说，变量里面放的就是实实在在的值，如1，“abc”等。
而引用类型变量里面放的是个地址，所以用final修饰引用类型变量指的是它里面的地址不能变，并不是说这个地址所指向的对象或数组的内容不可
final修饰属性，声明变量时可以不赋值，而且一旦赋值就不能被修改了。对final属性可以在三个地方赋值：声明时、初始化块中、构造方法中。总之一定要赋值。
2、final修饰类中的方法
作用：可以被继承，但继承后不能被重写。
3、final修饰类
作用：类不可以被继承
abstract（抽象）修饰符，可以修饰类和方法
1，abstract修饰类，会使这个类成为一个抽象类，这个类将不能生成对象实例，但可以做为对象变量声明的类型，也就是编译时类型，抽象类就像当于一类的半成品，需要子类继承并覆盖其中的抽象方法。
2，abstract修饰方法，会使这个方法变成抽象方法，也就是只有声明（定义）而没有实现，实现部分以"；"代替。需要子类继承实现（覆盖）。
注意：有抽象方法的类一定是抽象类。但是抽象类中不一定都是抽象方法，也可以全是具体方法。
abstract修饰符在修饰类时必须放在类名前。
abstract修饰方法就是要求其子类覆盖（实现）这个方法。调用时可以以多态方式调用子类覆盖（实现）后的方法，也就是说抽象方法必须在其子类中实现，除非子类本身也是抽象类。
注意：父类是抽象类，其中有抽象方法，那么子类继承父类，并把父类中的所有抽象方法都实现（覆盖）了，子类才有创建对象的实例的能力，否则子类也必须是抽象类。抽象类中可以有构造方法，是子类在构造子类对象时需要调用的父类（抽象类）的构造方法。
2.
3. 接口和抽象类的联系和区别。
4.
5.
|
接口 |
抽象类 |
多继承 |
支持 |
不支持 |
类型限制 |
没有 |
有，只能是引用类型 |
方法实现 |
继承类型中必须给出方法实现 |
继承类中可以不给出 |
扩展性 |
比较麻烦 |
相对比较灵活 |
多层继承 |
比较麻烦，需要借助虚函数 |
比较灵活 |
6. 内部类的类型及其特点。内部类的类型及其特点。
⒈ 静态内部类 内部类对象可以访问创建它的对象的实现，包括私有数据
2，成员内部类 内部类不为同一包的其他类所见，具有很好的封装性
3，局部内部类
4匿名内部类 匿名内部类可以方便的定义运行时回调；
7. 介绍Java垃圾回收机制。
1）发现无用信息对象；（2）回收被无用对象占用的内存空间，使该空间可被程序再次使用 需要注意的是，调用System.gc()也仅仅是一个请求(建议)。JVM接受这个消息后，并不是立即做垃圾回收，而只是对几个垃圾回收算法做了加权，使垃圾回收操作容易发生，或提早发生，或回收较多而已。一旦垃圾回收器准备好释放对象占用的存储空间，首先会去调用finalize()方法进行一些必要的清理工作。只有到下一次再进行垃圾回收动作的时候，才会真正释放这个对象所占用的内存空间。
四、 编码题
1. 编写程序描述兔子和青蛙
需求说明：使用面向对象的思想，设计自定义类描述兔子和青蛙。
实现思路及关键代码
1) 分析兔子和青蛙的共性
2) 根据共性，定义抽象的动物类
属性：名字、颜色、类别（哺乳类、非哺乳类）
方法：吃饭，发出叫声
3) 根据青蛙会游泳 抽象游泳的接口
方法：游泳
4) 定义兔子继承动物类，青蛙继承动物同时实现游泳接口
程序运行结果如图所示。
package cn.rabit;
public class Rabbit extends Animal{
@Override
public void eat() {
System.out.println("兔子是"+this.getType()+",爱吃胡萝卜");
}
@Override
public void shout() {
System.out.println("那只"+this.getColor()+"的，名叫"+this.getName()
+"的兔子正在呱呱的叫");
}
}
package cn.rabit;
public class Frog extends Animal implements Ability{
@Override
public void swiming() {
System.out.println("虽然不是鱼，但青蛙也是泳坛高手");
}
@Override
public void eat() {
System.out.println("兔子是"+this.getType()+",爱吃昆虫");
}
@Override
public void shout() {
System.out.println("那只"+this.getColor()+"的，名叫"+this.getName()
+"的青蛙正在呱呱的叫");
}
}
package cn.rabit;
public abstract class Animal {
private String name;
private String color;
private String type;
public abstract void eat();
public abstract void shout();
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
public String getType() {
return type;
}
public void setType(String type) {
this.type = type;
}
}
package cn.rabit;
public interface Ability {
public void swiming();
}
package cn.rabit;
public class TestRabbit {
public static void main(String[] args) {
Rabbit r=new Rabbit();
Frog f=new Frog();
f.setName("大冰");
f.setColor("绿色");
f.setType("非哺乳类");
r.setName("美人");
r.setColor("黑色");
r.setType("哺乳类");
//"美人","黑色","哺乳类"
r.shout();
r.eat();
System.out.println("====================");
f.shout();
f.eat();
f.swiming();
}
}
2. 编写程序描述影视歌三栖艺人
需求说明：请使用面向对象的思想，设计自定义类，描述影视歌三梄艺人。
实现思路及关键代码
1) 分析影视歌三栖艺人的特性
a) 可以演电影
b) 可以演电视剧
c) 可以唱歌
2) 定义多个接口描述特性
a) 演电影的接口-----方法：演电影
b) 演电视剧的接口-----方法：演电视剧
c) 唱歌的接口-----方法：唱歌
3) 定义艺人类实现多个接口
程序运行结果如图2所示。
public interface TvShow {
public void showTv();
}
public interface Sing {
public void showSinging();
}
public interface Movie {
public void showMovie();
}
public class Actor implements TvShow, Movie, Sing {
private String name;
Actor(String name){
this.name=name;
}
@Override
public void showSinging() {
System.out.println("我可以唱歌");
}
@Override
public void showMovie() {
System.out.println("我可以演电影");
}
@Override
public void showTv() {
System.out.println("我可以演电视剧");
}
public static void main(String[] args) {
Actor a=new Actor("马素素");
a.showMovie();
a.showSinging();
a.showTv();
}
}
3. 写一个方法对任意引用数据类型数组进行排序。具体要求如下:
1) 方法声明为public void sortArr(Object arr[]){ }
2) 方法中首先输出排序前数组内容，然后进行排序，最后输出排序后数组内容。
3) 可以是冒泡排序或其他算法实现，不直接调用Java提供的方法实现排序。
思路：任意类实现Comparable接口来实现该引用数据类型的元素排序，在sort()方法中将Object强转成Comparable实现两个对象的比较。
package cn.sort.pxd2;
public class Student implements Comparable{
private int age;
Student s[]=new Student[4];
Student (int age){
this.age=age;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public void sortArr(Object s[]){
Student[] st=(Student [])s;
for(int i=0;i<s.length-1;i++){
for(int j=0;j<s.length-1-i;j++){
if(st[j].getAge()>st[j+1].getAge()){
int tmp=st[j].getAge();
st[j].setAge(st[j+1].getAge());
st[j+1].setAge(tmp);
}
}
}
}
}
package cn.sort.pxd2;
public interface Comparable{
public void sortArr(Object t[]);
}
package cn.sort.pxd2;
public class Test11 {
public static void main(String[] args) {
Student s1=new Student(1);
Student s2=new Student(3);
Student s3=new Student(7);
Student s4=new Student(2);
Student s[]=s1.s;
s[0]=s1;
s[1]=s2;
s[2]=s3;
s[3]=s4;
for(int i=0;i<s.length;i++){
System.out.print(s[i].getAge()+" ");
}
s1.sortArr(s);
System.out.println();
for(int i=0;i<s.length;i++){
System.out.print(s[i].getAge()+" ");
}
}
}
五、 可选题
1. 实现不同符合PCI规范的适配器
需求说明：PCI是一种规范，所有实现了该规范的适配器，必如显卡、声卡、网卡都可以安装到PCI插槽上并工作。模拟实现该功能。
实现思路及关键代码
1) 定义PCI接口，具有传送数据send()方法
2) 定义显卡VideaCard类，实现该接口
3) 定义声卡AudioCard类，实现PCI接口
4) 定义网卡NetCard类，实现PCI接口
5) 定义测试类，让显卡、声卡、网卡发送数据
2. 实现不同引用类型对象的大小比较
需求说明：学生类，新闻类，商品类虽然是完全不同的类，但是都具有比较的能力，比如可以比较两个学生的大小，但需要指定比较的依据是学号、姓名还是成绩等。
实现思路及关键代码：
将比较的能力定义为接口，让学生、新闻、商品类都实现该接口。
1) 定义接口Comparable，其中包含唯一的方法int compareTo(Object obj)；
2) 定义学生类，包括学号、姓名、年龄和分数，实现Comparable接口，按照分数倒序排列；
3) 定义新闻类，包括编号（int类型）、标题、内容和点击数，实现Comparable接口，按照编号正序排列；
4) 定义测试类，分别创建两个学生对象、新闻对象，进行比较并输出结果。
5) 返回值>0，表示大于，返回值=0，表示等于，返回值<0，表示小于。
package student.news.goods;
public interface Comparable {
public int compareTo(Object obj);
}
package student.news.goods;
public class Student implements Comparable {
private int studentId;
private String name;
private int score;
private int age;
Student (int score){
this.score=score;
}
@Override
public int compareTo(Object obj) {
Student stu=(Student)obj;
if(this.score>stu.score)return 1;
if(this.score<stu.score)return -1;
return 0;
}
}
package student.news.goods;
public class News implements Comparable {
private int serialNumber;
private String title;
private String content;
private int clicks;
News(int serialNumber) {
this.serialNumber = serialNumber;
}
@Override
public int compareTo(Object obj) {
News ne = (News) obj;
if (this.serialNumber > ne.serialNumber)
return 1;
if (this.serialNumber < ne.serialNumber)
return -1;
return 0;
}
}
package student.news.goods;
public class Test {
public static void main(String[] args) {
Student stu1 = new Student(11);
Student stu2 = new Student(12);
stu1.compareTo(stu2);
print(stu1, stu2);
News n1 = new News(1001);
News n2 = new News(1002);
n1.compareTo(n2);
print(n1, n2);
}
public static void print(Comparable o1, Comparable o2) {
if (o1 instanceof Student && o2 instanceof Student) {
Student s1 = (Student) o1;
Student s2 = (Student) o2;
if (s1.compareTo(s2) == 1) {
System.out.println("s1" + " " + "s2");
} else if (s1.compareTo(s2) == -1) {
System.out.println("s2" + " " + "s1");
} else {
System.out.println("s1" + "和" + "s2" + "一般大");
}
}else if(o1 instanceof News && o2 instanceof News){
News s1 = (News) o1;
News s2 = (News) o2;
if (s1.compareTo(s2) == 1) {
System.out.println("n2" + " " + "n1");
} else if (s1.compareTo(s2) == -1) {
System.out.println("n1" + " " + "n2");
} else {
System.out.println("n2" + "和" + "n1" + "一般大");
}
}
}
}
抽象类+接口+内部类作业答案
一、 选择题
1. C
2. B
3. D
4. AC
5. AB
6. AD
7. A
8. BC
9. AD
二、 判断题
1. √
2. √
3. ×
4. √
5. √
6. ×
7. √
8. √
9. ×
10. √
11. ×
12. √
13. ×
14. ×
15. ×
三、 简答题
答案略
四、 编码题
1. 编写程序描述兔子和青蛙
需求说明：使用面向对象的思想，设计自定义类描述兔子和青蛙。
/**
* 动物类
* @author Administrator
*/
public abstract class Animal {
private String name;//名字
private String color;//颜色
private String type;//类别（哺乳类、非哺乳类）
public Animal() {
super();
}
public Animal(String name, String color, String type) {
super();
this.name = name;
this.color = color;
this.type = type;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
public String getType() {
return type;
}
public void setType(String type) {
this.type = type;
}
/**
* 发出叫声
*/
public abstract void shout();
/**
* 吃饭
*/
public abstract void eat();
}
/**
* 游泳接口
* @author Administrator
*/
public interface Swimmable {
/**
* 游泳
*/
public void swim();
}
public class Frog extends Animal implements Swimmable{
public Frog() {
super();
}
public Frog(String name, String color, String type) {
super(name, color, type);
}
@Override
public void shout() {
System.out.println("那只"+super.getColor()+
"的，名字叫"+super.getName()+"的青蛙正在呱呱的叫");
}
@Override
public void eat() {
System.out.println("青蛙是"+super.getType()+",爱吃昆虫");
}
@Override
public void swim() {
System.out.println("虽然不是鱼，但是青蛙也是游泳高手");
}
}
public class Rabbit extends Animal{
public Rabbit() {
super();
}
public Rabbit(String name, String color, String type) {
super(name, color, type);
}
@Override
public void shout() {
System.out.println("那只"+super.getColor()+
"的，名字叫"+super.getName()+"的兔子正在叽叽的叫");
}
@Override
public void eat() {
System.out.println("兔子是"+super.getType()+",爱吃胡萝卜");
}
}
public class Test {
public static void main(String[] args) {
Animal rabbit = new Rabbit("美人", "黑色", "哺乳类");
rabbit.shout();
rabbit.eat();
System.out.println("====================");
Animal frog = new Frog("大兵", "绿色", "非哺乳类");
frog.shout();
frog.eat();
Swimmable swimer = (Swimmable)frog;
swimer.swim();
}
}
2. 编写程序描述影视歌三栖艺人
需求说明：请使用面向对象的思想，设计自定义类，描述影视歌三梄艺人。
/**
* 可演电影接口
* @author Administrator
*/
public interface Filmable {
/**
* 演电影
*/
public void actFilm();
}
/**
* 会唱歌接口
* @author Administrator
*/
public interface Singable {
/**
* 唱歌
*/
public void sing();
}
/**
* 会演电视剧接口
* @author Administrator
*/
public interface TVable {
/**
* 演电视剧
*/
public void showTV();
}
public class Star implements Filmable,TVable,Singable{
private String name;//姓名
public Star() {
super();
}
public Star(String name) {
super();
this.name = name;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public void sing() {
System.out.println("我会唱歌");
}
@Override
public void showTV() {
System.out.println("我能演电视剧");
}
@Override
public void actFilm() {
System.out.println("我能演电影");
}
public void introduce(){
System.out.println("大家好，我是"+name);
}
}
public class Test {
public static void main(String[] args) {
Star star = new Star("马素素");
star.introduce();
star.actFilm();
star.showTV();
star.sing();
}
}
3. 写一个方法对任意数据类型数组进行排序。具体要求如下:
1) 方法声明为public void sortArr(Object arr[]){ }
2) 方法中首先输出排序前数组内容，然后进行排序，最后输出排序后数组内容。
3) 可以是冒泡排序或其他算法实现，不直接调用Java提供的方法实现排序。
public void sort(Object [] arr){
//输出排序前数组
for(int i=0;i<arr.length;i++){
System.out.println(arr[i]);
}
//大循环，一共n个元素，达到最终有序，至多n-1趟比较
Object temp;
for(int i=0;i<arr.length-1 ;i++){
//定义一个符号量
boolean flag = true;//没有交换，有序
//小循环
for(int j=0;j<arr.length-1-i;j++){
//如果前一个大于后一个
Comparables c1 = (Comparables)arr[j];
Comparables c2 = (Comparables)arr[j+1];
if(c1.compareTo(c2)>0){
//交换
temp = arr[j];
arr[j]=arr[j+1];
arr[j+1]=temp;
//修改符号量
flag = false;//交换过，无序
}
}
//判断经过此趟循环后是否已经有序
if(flag){
break;//退出外层循环，省略后续趟循环
}
}
//输出排序后数组
for(int i=0;i<arr.length;i++){
System.out.println(arr[i]);
}
}
五、 可选题
1. 实现不同符合PCI规范的适配器
/**
* PCI接口
* @author Administrator
*
*/
public interface PCI {
/**
* 传输数据
*/
public void send();
}
public class VideoCard implements PCI{
@Override
public void send() {
System.out.println("使用PCI接口传输视频数据");
}
}
public class SoundCard implements PCI{
@Override
public void send() {
System.out.println("使用PCI接口传输声音数据");
}
}
public class NetCard implements PCI {
@Override
public void send() {
System.out.println("使用PCI接口传输网络数据");
}
}
public class Test {
public static void main(String[] args) {
PCI p1 = new VideoCard();
p1.send();
PCI p2 = new SoundCard();
p2.send();
PCI p3 = new NetCard();
p3.send();
}
}
2. 实现不同引用类型对象的大小比较
/**
* 比较接口
* @author Administrator
*
*/
public interface Comparable {
/**
* 比较
* @param obj 另外一个对象
* @return 比较的结果 >0 大于 =0 等于 <0 小于
*/
public int compareTo(Object obj);
}
public class News implements Comparable{
private int nid;//编号
private String title; //标题
private String contents;//内容
private String type;//新闻类别
public News() {
super();
}
public News(int nid, String title, String contents,String type) {
super();
this.nid = nid;
this.title = title;
this.contents = contents;
this.type = type;
}
/**
* 按照新闻编号正序排列
*/
public int compareTo(Object obj) {
News other =(News)obj;
return this.nid- other.nid;
}
@Override
public String toString() {
return "News [nid=" + nid + ", title=" + title + ", contents="
+ contents + ", type=" + type + "]";
}
}
public class Student implements Comparable{
private int id;
private String name;
private int age;
private double score;
public Student() {
super();
}
public Student(int id, String name, int age, double score) {
super();
this.id = id;
this.name = name;
this.age = age;
this.score = score;
}
/**
* 按照学生成绩降序排序
*/
public int compareTo(Object obj) {
Student other =(Student)obj;
if(this.score>other.score){
return -1;
}else if(this.score<other.score){
return 1;
}else{
return 0;
}
}
@Override
public String toString() {
return "Student [id=" + id + ", name=" + name + ", age=" + age
+ ", score=" + score + "]";
}
}
public class Test {
public static void main(String[] args) {
//
Student stu1 = new Student(11, "小红", 18, 97d);
Student stu2 = new Student(12, "小东", 20, 98d);
if(stu1.compareTo(stu2)>0){
System.out.println(stu2);
System.out.println(stu1);
}else{
System.out.println(stu1);
System.out.println(stu2);
}
//
News news1 = new News(33, "恒大亚冠", "恒大亚冠小组被淘汰", "体育");
News news2 = new News(44, "上海尚学堂", "请原谅我的姗姗来迟", "IT");
if(news1.compareTo(news2)>0){
System.out.println(news2);
System.out.println(news1);
}else{
System.out.println(news1);
System.out.println(news2);
}
}
}