抽象类+接口+内部类作业题
⦁ 选择题
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. 没有错误A
4. 下列选项中，关于Java的抽象类和抽象方法说法正确的是（AC ）。（选择二项）
A 抽象类中可以含有0个或多个抽象方法
B. 抽象类中不可以有构造方法
C. 一个类中若有抽象方法，则这个类必为抽象类
D. 子类必须重写父类所有的抽象方法
5. 在Java中关于abstract关键字，以下说法正确的是（A B ）。（选择两项）
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. 匿名内部类可以实现多个接口，或者继承一个父t类
B. 匿名内部类不能是抽象类，必须实现它的抽象父类或者接口里包含的所有抽象方法
C. 匿名内部类没有类名，所以匿名内部类不能定义构造方法
D. 匿名内部类可以直接访问外部类的所有局部变量
⦁ 判断题（共20个题目，总计10分）
⦁ 声明为final的类不能是超类。（ true ）
⦁ 使用final修饰的变量将变成常量，其中不能再被改变；使用final修饰的方法将无法被子类重载；使用final修饰的类将无法再被其他类继承。（ true ）
⦁ 抽象方法不能含有方法体，并且必须定义在抽象类中。（ false ）
⦁ 抽象类是指在class前加使用abstract关键字修饰，且可以存在抽象方法和普通方法的类。（ true ）
⦁ 接口中只有常量，没有变量；只有抽象方法，并且全部都是public方法。（ true ）
⦁ 抽象类和接口都不能实例化，都没有构造方法。（false ）
⦁ 接口并不要求实现类和接口在概念本质上一致的，仅仅是实现了接口定义的约定或者能力而已。接口定义了“做什么”，而实现类负责完成“怎么做”，体现了功能（规范）和实现分离的原则。（true ）
⦁ 内部类作为外部类成员，权限修饰符和其他成员一样，可声明为private、默认、protected或public。( true )
⦁ 匿名内部类适合创建那种只需要使用一次的类，它可以实现一个或多个接口，或者继承一个父类。（ fale ）
⦁ 对于物理连接，比如数据库连接、输入流输出流、Socket连接等，垃圾回收机制无能为力，必须手动关闭才可以。( true )
⦁ 垃圾回收机制回收任何对象之前，总会先调用它gc( )方法，该方法是Object类提供的方法。不要主动调用某个对象的该方法，应该交给垃圾回收机制调用。（ false ）
⦁ 简答题
⦁ final和abstract关键字的作用。
final：使用final修饰的变量将变成常量，其中不能再被改变；使用final修饰的方法将无法被子类重写；使用final修饰的类将无法再被其他类继承。
abstract：使用abstract修饰的类将变成抽象类，无法实例化，必须通过继承多态实现自己的方法，与普通类的区别就是里面可以写抽象方法；使用abstract修饰的方法叫抽象方法，。没有方法体，本类被非抽象类继承后，该方法必须重写，被抽象类继承怎还是抽象方法。
⦁ 接口和抽象类的联系和区别。
A:成员区别
* 抽象类(和普通类相比,只是可以多定义了抽象方法而已)
* 成员变量：可以变量，也可以常量
* 构造方法：有
* 成员方法：可以抽象，也可以非抽象
* 接口:
* 成员变量:只可以常量
* 构造方法:无
* 成员方法:只可以抽象
* B:关系区别
* 类与类
* 继承,单继承,多层继承
* 类与接口:
* 实现,单实现,多实现
* 接口与接口多继承
* 继承,单继承,
* C:设计理念区别
* 抽象类 被继承体现的是:"is a"的关系.抽象类中定义的是该继承体系的共性功能
* 接口 被实现体现的是:"like a "的关系.接口中定义的是该继承体系的扩展功能.
⦁ 内部类的类型及其特点。
成员内部类
* a:内部类可以直接访问外部类的成员，包括私有。
* b:外部类要访问内部类的成员，必须创建对象。
* 外部类名.内部类名 对象名 = 外部类对象.内部类对象;
局部内部类
局部内部类访问局部变量必须用final修饰jdk1.7
匿名内部类
匿名内部类只针对重写一个方法的时候使用;如果需要重写多个方法,就用有名字的方法
⦁ 介绍Java垃圾回收机制。
垃圾回收机制只负责回收堆内存，不会回收任何物理资源
程序无法精确控制垃圾回收的进行，会在合适的时候进行
在垃圾回收机制回收的任何对象之前，总会先调用它的finalize()方法
注意：垃圾回收机制回收的是无任何引用的对象占据的内存空间而不是对象本身
⦁ 编码题
⦁ 编写程序描述兔子和青蛙
需求说明：使用面向对象的思想，设计自定义类描述兔子和青蛙。
实现思路及关键代码
⦁ 分析兔子和青蛙的共性
⦁ 根据共性，定义抽象的动物类
属性：名字、颜色、类别（哺乳类、非哺乳类）
方法：吃饭，发出叫声
⦁ 根据青蛙会游泳 抽象游泳的接口
方法：游泳
⦁ 定义兔子继承动物类，青蛙继承动物同时实现游泳接口
程序运行结果如图所示。
package com.zkc.test;
public class Demo7 {
public static void main(String[] args) {
Rabbit r = new Rabbit("美美","粉色");
r.eat();
r.speak();
Frog f = new Frog("大兵","绿色");
f.eat();
f.speak();
f.swim();
}
}
package com.zkc.test;
public class Rabbit extends Animal {
public Rabbit() {
setCategory("哺乳类");
}
public Rabbit(String name,String color) {
super(name,color);
setCategory("哺乳类");
}
public void eat() {
System.out.println("兔子是"+getCategory()+",爱吃胡萝卜");
}
public void speak() {
System.out.println("那只"+getColor()+"的，名叫"+getName()+"的兔子正在叽叽的叫");
}
}
package com.zkc.test;
public class Frog extends Animal implements Swim {
public Frog() {
setCategory("非哺乳类");
}
public Frog(String name,String color) {
super(name,color);
setCategory("非哺乳类");
}
public void eat() {
System.out.println("青蛙是"+getCategory()+",爱吃昆虫");
}
public void speak() {
System.out.println("那只"+getColor()+"的，名叫"+getName()+"的青蛙正在呱呱的叫");
}
public void swim() {
System.out.println("虽然不是鱼，但青蛙也是泳坛高手");
}
}
package com.zkc.test;
public abstract class Animal {
private String name;
private String color;
private String category;
public abstract void eat();
public abstract void speak();
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 getCategory() {
return category;
}
public void setCategory(String category) {
this.category = category;
}
public Animal() {
}
public Animal(String name,String color) {
this.name = name;
this.color = color;
}
}
package com.zkc.test;
public interface Swim {
public abstract void swim();
}
⦁ 编写程序描述影视歌三栖艺人
需求说明：请使用面向对象的思想，设计自定义类，描述影视歌三梄艺人。
实现思路及关键代码
⦁ 分析影视歌三栖艺人的特性
⦁ 可以演电影
⦁ 可以演电视剧
⦁ 可以唱歌
⦁ 定义多个接口描述特性
⦁ 演电影的接口-----方法：演电影
⦁ 演电视剧的接口-----方法：演电视剧
⦁ 唱歌的接口-----方法：唱歌
⦁ 定义艺人类实现多个接口
程序运行结果如图2所示。
package com.zkc.test;
public class Demo8 {
public static void main(String[] args) {
Actor a = new Actor("关之琳");
a.show();
a.movie();
a.drama();
a.sing();
}
}
package com.zkc.test;
public class Actor implements Movie,Drama,Sing {
private String name;
public Actor() {
}
public Actor(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public void movie() {
System.out.println("我能演电影");
}
public void drama() {
System.out.println("我能演电视剧");
}
public void sing() {
System.out.println("我会唱歌");
}
public void show() {
System.out.println("大家好，我的名字是"+getName());
}
}
package com.zkc.test;
public interface Movie {
public abstract void movie();
}
package com.zkc.test;
public interface Drama {
public abstract void drama();
}
package com.zkc.test;
public interface Sing {
public abstract void sing();
}
⦁ 可选题
⦁ 实现不同符合PCI规范的适配器
需求说明：PCI是一种规范，所有实现了该规范的适配器，必如显卡、声卡、网卡都可以安装到PCI插槽上并工作。模拟实现该功能。
实现思路及关键代码
⦁ 定义PCI接口，具有传送数据send()方法
⦁ 定义显卡VideaCard类，实现该接口
⦁ 定义声卡AudioCard类，实现PCI接口
⦁ 定义网卡NetCard类，实现PCI接口
⦁ 定义测试类，让显卡、声卡、网卡发送数据
package com.zkc.test;
public class Demo9 {
public static void main(String[] args) {
Videacard v = new Videacard();
v.send();
AudioCard a = new AudioCard();
a.send();
NetCard n = new NetCard();
n.send();
}
}
package com.zkc.test;
public class Videacard implements PCI{
public void send() {
System.out.println("我是一只显卡");
}
}
package com.zkc.test;
public class AudioCard implements PCI{
public void send() {
System.out.println("我是一只声卡");
}
}
package com.zkc.test;
public class NetCard implements PCI {
public void send() {
System.out.println("我是一只网卡");
}
}
package com.zkc.test;
public interface PCI {
public abstract void send();
}
⦁ 实现不同引用类型对象的大小比较
需求说明：学生类，新闻类，商品类虽然是完全不同的类，但是都具有比较的能力，比如可以比较两个学生的大小，但需要指定比较的依据是学号、姓名还是成绩等。
实现思路及关键代码：
将比较的能力定义为接口，让学生、新闻、商品类都实现该接口。
⦁ 定义接口Comparable，其中包含唯一的方法int compareTo(Object obj)；返回值>0，表示大于，返回值=0，表示等于，返回值<0，表示小于。
⦁ 定义学生类，包括学号、姓名、年龄和分数，实现Comparable接口，按照分数倒序排列；
⦁ 定义新闻类，包括编号（int类型）、标题、内容和点击数，实现Comparable接口，按照编号正序排列；
⦁ 定义测试类，分别创建两个学生对象、新闻对象，进行比较并输出结果。
package com.zkc.test;
public class Demo10 {
public static void main(String[] args) {
Student s = new Student("张三",1111,15,95);
Student ss = new Student("李四",2222,15,89);
System.out.println(s.comparable(ss));
News n = new News(2156,"七龙珠","布罗利",545445);
News nn = new News(552,"健康生活","早睡早起",5489);
System.out.println(n.comparable(nn));
}
}
package com.zkc.test;
public class Student implements Comparable{
private String name;
private int id;
private int age;
private int score;
public Student() {
}
public Student(String name,int id,int age,int score) {
this.name = name;
this.id = id;
this.age = age;
this.score = score;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public int getScore() {
return score;
}
public void setScore(int score) {
this.score = score;
}
public int comparable(Object o) {
Student s = (Student)o;
if(s.getScore() > score) {
return 1;
} else if(s.getScore() == score) {
return 0;
} else {
return -1;
}
}
}
package com.zkc.test;
public class News implements Comparable {
private int id;
private String name;
private String content;
private int num;
public News() {
}
public News(int id,String name,String content,int num) {
this.id = id;
this.name = name;
this.content = content;
this.num = num;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getContent() {
return content;
}
public void setContent(String content) {
this.content = content;
}
public int getNum() {
return num;
}
public void setNum(int num) {
this.num = num;
}
public int comparable(Object o) {
News n = (News)o;
return id-n.id;
}
}
package com.zkc.test;
public interface Comparable {
public abstract int comparable(Object o);
}