0717作业

一、选择题

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. 以下代码中错误的语句是（ B ）。（选择一项）
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而不产生编译错误的是（ BD ）。（选择二项）
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接口中，下列选项中属于有效的方法声明是（ AB ）。（选择二项）

A public void aMethod( );
B. final void aMethod( );
C. void aMethod(){ }
D. private void aMethod( );

8. 以下选项中关于匿名内部类的说法正确的是（ AB ）。（选择二项）

A. 匿名内部类可以实现多个接口，或者继承一个父类
B. 匿名内部类不能是抽象类，必须实现它的抽象父类或者接口里包含的所有抽象方法
C. 匿名内部类没有类名，所以匿名内部类不能定义构造方法
D. 匿名内部类可以直接访问外部类的所有局部变量

二、判断题（共20个题目，总计10分）
1.声明为final的类不能是超类。（ T ）
2.使用final修饰的变量将变成常量，其中不能再被改变；使用final修饰的方法将无法被子类重载；使用final修饰的类将无法再被其他类继承。（ F ）
3.抽象方法不能含有方法体，并且必须定义在抽象类中。（T ）
4.抽象类是指在class前加使用abstract关键字修饰，且可以存在抽象方法和普通方法的类。（ T ）
5.接口中只有常量，没有变量；只有抽象方法，并且全部都是public方法。（ T ）
6.抽象类和接口都不能实例化，都没有构造方法。（ F ）
7.接口并不要求实现类和接口在概念本质上一致的，仅仅是实现了接口定义的约定或者能力而已。接口定义了“做什么”，而实现类负责完成“怎么做”，体现了功能（规范）和实现分离的原则。（ F ）
8.内部类作为外部类成员，权限修饰符和其他成员一样，可声明为private、默认、protected或public。(T )
9.匿名内部类适合创建那种只需要使用一次的类，它可以实现一个或多个接口，或者继承一个父类。（T ）
10.对于物理连接，比如数据库连接、输入流输出流、Socket连接等，垃圾回收机制无能为力，必须手动关闭才可以。( F )
11.垃圾回收机制回收任何对象之前，总会先调用它gc( )方法，该方法是Object类提供的方法。不要主动调用某个对象的该方法，应该交给垃圾回收机制调用。（ T ）

三、简答题
1.final和abstract关键字的作用。
final 作为修饰符,用来定义类,方法和变量.定义变量后,变量就成为了常量,不能再改变;定义类后,类不能再被继承;定义方法后,方法不能被子类重写.
abstract 作为修饰符,定义抽象类,方法.定义类后,类就是抽象类,抽象类多用于接口;定义方法后,方法就是抽象方法,抽象方法不能有方法体,而且强制要求子类重写本方法
2.接口和抽象类的联系和区别。
接口一定是抽象类,抽象类不一定是接口.
接口中的成员变量只能是常量,没有构造方法,只能是抽象方法
抽象类中的成员变量既可以是变量,也可以是常量,有构造方法,方法中即可以有抽象方法,也可以没有抽象方法
3.内部类的类型及其特点。
内部类就是定义在类中的一个类,它可以直接访问外部类的成员,包括私有.
外部类要想访问内部类,必须先创建对象
4.介绍Java垃圾回收机制。

四、编码题
1.编写程序描述兔子和青蛙
需求说明：使用面向对象的思想，设计自定义类描述兔子和青蛙。
实现思路及关键代码
1)分析兔子和青蛙的共性
2)根据共性，定义抽象的动物类
属性：名字、颜色、类别（哺乳类、非哺乳类）
方法：吃饭，发出叫声
3)根据青蛙会游泳 抽象游泳的接口
方法：游泳
4)定义兔子继承动物类，青蛙继承动物同时实现游泳接口
程序运行结果如图所示。

class Demo6_Animal 
{
    public static void main(String[] args) 
    {
        Rabbit r1 = new Rabbit("美人","黑色","哺乳类");
        r1.call();
        r1.eat();
        System.out.println("---------------------------------");
        Frog f1 = new Frog("大兵","绿色","非哺乳类");
        f1.call();
        f1.eat();
        f1.swim();
    }
}
/*
定义 一个父类 抽象类
*/
abstract class Animal
{    // 属性
    private String name;
    private String color;
    private String kind;

    //构造方法
    public Animal() {
        super();
    }
    public Animal(String name,String color,String kind) {
            super();
            this.name = name;
            this.color = color;
            this.kind = kind;
    }

    // setXxx  getXxx方法
    public void setName(String name) {
        this.name = name;
    }
    public String getName() {
        return name;
    }
    public void setColor(String color) {
        this.color =color;
    }
    public String getColor() {
        return color;
    }
    public void setKind(String kind) {
        this.kind = kind;
    }
    public String getKind() {
        return kind;
    }

    //抽象方法
    public abstract void eat();
    public abstract void call();
}

/*
定义 一个子类  兔子
*/

class Rabbit extends Animal
{
    public Rabbit() {
        super();
    }
    public Rabbit(String name,String color,String kind) {
        super(name,color,kind);
    }
    public void eat() {
        System.out.println("兔子是"+getKind()+",爱吃胡萝卜");
    }
    public void call() {
        System.out.println("那只"+getColor()+"的,名叫"+getName()+"的兔子"+"正在叽叽的叫");
    }
}
/*
定义 一个子类  青蛙
*/
class Frog extends Animal implements Swimming
{
    public Frog() {
        super();
    }
    public Frog(String name,String color,String kind) {
        super(name,color,kind);
    }
    public void eat() {
        System.out.println("青蛙是"+getKind()+",爱吃昆虫");
    }
    public void call() {
        System.out.println("那只"+getColor()+"的,名叫"+getName()+"的青蛙"+"正在呱呱的叫");
    }
    public void swim() {
        System.out.println("虽然不是鱼,但青蛙也是泳坛高手");
    }

}
/*
定义 一个接口   青蛙的游泳接口
*/
interface Swimming 
{
    public abstract void swim();
}

2.编写程序描述影视歌三栖艺人
需求说明：请使用面向对象的思想，设计自定义类，描述影视歌三梄艺人。
实现思路及关键代码
1)分析影视歌三栖艺人的特性
a)可以演电影
b)可以演电视剧
c)可以唱歌
2)定义多个接口描述特性
a)演电影的接口-----方法：演电影
b)演电视剧的接口-----方法：演电视剧
c)唱歌的接口-----方法：唱歌
3)定义艺人类实现多个接口
程序运行结果如图2所示。

class Demo1_Star 
{
    public static void main(String[] args) 
    {
        Star s1 = new Star("马素素");
        s1.show();
        s1.movie();
        s1.television();
        s1.song();
    }
}
interface Movie    //接口 演电影
{
    public void movie();
}

interface Television  //接口 演电视剧
{
    public void television();
}

interface Song   //接口 唱歌
{
    public void song();
}

/*
 定义一个艺人类
*/
class Star implements Movie,Television,Song
{
    private String name;

    public Star() {
        super();
    }
    public Star(String name) {
        super();
        this.name = name;
    }

      // 定义setXxx方法 getXxx方法
    public void setName() {
        this.name = name;
    }
    public String getName() {
        return name;
    }
    
    public void show() {
        System.out.println("大家好!我是" + getName());
    }

    public void movie() {
        System.out.println("我能演电影");
    }
    public void television() {
        System.out.println("我能演电视剧");
    }
    public void song() {
        System.out.println("我会唱歌");
    }

}

五、可选题
1.实现不同符合PCI规范的适配器
需求说明：PCI是一种规范，所有实现了该规范的适配器，必如显卡、声卡、网卡都可以安装到PCI插槽上并工作。模拟实现该功能。

实现思路及关键代码
1)定义PCI接口，具有传送数据send()方法
2)定义显卡VideaCard类，实现该接口
3)定义声卡AudioCard类，实现PCI接口
4)定义网卡NetCard类，实现PCI接口
5)定义测试类，让显卡、声卡、网卡发送数据

class Demo1_PCI
{
    public static void main(String[] args) 
    {
        VideaCard v1 = new VideaCard();
        v1.send();
        AudioCard a1 = new AudioCard();
        a1.send();
        NetCard n1 = new NetCard();
        n1.send();
    }
}
// 定义PCI接口
interface PCI
{
    public abstract void send();
}

class VideaCard implements PCI
{
    public void send() {
        System.out.println("显卡发送数据");
    }
}

class AudioCard implements PCI
{
    public void send() {
        System.out.println("声卡发送数据");
    }
}

class NetCard implements PCI
{
    public void send() {
        System.out.println("网卡发送数据");
    }
}

2.实现不同引用类型对象的大小比较
需求说明：学生类，新闻类，商品类虽然是完全不同的类，但是都具有比较的能力，比如可以比较两个学生的大小，但需要指定比较的依据是学号、姓名还是成绩等。
实现思路及关键代码：
将比较的能力定义为接口，让学生、新闻、商品类都实现该接口。
1)定义接口Comparable，其中包含唯一的方法int compareTo(Object obj)；返回值>0，表示大于，返回值=0，表示等于，返回值<0，表示小于。
2)定义学生类，包括学号、姓名、年龄和分数，实现Comparable接口，按照分数倒序排列；
3)定义新闻类，包括编号（int类型）、标题、内容和点击数，实现Comparable接口，按照编号正序排列；
4)定义测试类，分别创建两个学生对象、新闻对象，进行比较并输出结果。