Java 习题5 参考答案及解析（1）

1.问答题

（1）子类可以有多个父类吗？
（2）java.lang包中的Object类是所有其他类的祖先吗？
（3）如果子类和父类不在同一个包中，子类是否继承父类的友好成员？
（4）子类怎样隐藏继承的成员变量？
（5）子类重写方法的规则是怎样的？重写方法的目的是什么？
（6）父类的final方法可以被子类重写吗？
（7）什么类中可以有abstract方法？
（8）对象的上转型对象有怎样的特点？
（9）一个类的各个子类是怎样体现多态的？
（10）面向抽象编程的目的和核心是什么？

---

问答题解析

1.不可以。Java是单继承的，只能继承一个父类。
2.是。
3.不继承。关于各个访问修饰符的访问权限可以看下表

访问修饰符	本类	同包	子类	其他
private	T
友好	T	T
protected	T	T	T
public	T	T	T	T

4.声明与父类同名的成员变量。
5.子类重写的方法的返回值类型，方法名，参数类型，顺序，个数都要与父类继承的方法相同，而且访问修饰符的限定范围大于等于父类方法。目的是可以父类的状态和行为改变为自身的状态和行为，实现多态。
6.不可以
7.abstract类。abstract方法必须在abstract类中，而abstract类中可以没有abstract方法
8.上转型对象不能操作子类新增的成员变量，不能调用子类新增的方法。上转型对象可以访问子类继承或隐藏的成员变量，可以调用子类继承的方法或子类重写的实例方法。
9.通过重写方法。
10.面向抽象编程目的是为了应对用户需求的变化，核心是让类中每种可能的变化对应地交给抽象类的一个子类去负责，从而让该类的设计者不去关心具体实现。

---

2.选择题

（1）下列哪个叙述是正确的？
A.子类继承父类的构造方法。
B.abstract类的子类必须是非abstract类。
C.子类继承的方法只能操作子类继承和隐藏的成员变量。
D.子类重写或新增的方法也能直接操作被子类隐藏的成员变量。

---

（2）下列哪个叙述是正确的？
A.final类可以有子类。
B.abstract类中只可以有abstract方法。
C.abstract类中可以有非abstract方法，但该方法不可以用final修饰。
D.不可以同时用final和abstract修饰同一个方法。
E.允许使用static修饰abstract方法。

---

（3）下列程序中注释的哪两个代码（A、B、C、D）是错误的？（无法通过编译）？

Java
class Father{
    private int money=12;
    float height;
    int seeMoney(){
        return money;//A
    }
}
class Son extends Father{
    int height;
    int lookMoney(){
        int m = seeMoney(); //B
        return m;
    }
}
class E{
    public static void main(String args[]){
        Son erzi = new Son();
        erzi.money = 300;   //C
        erzi.height = 1.78F;//D
    }
}

---

（4）假设C是B的子类，B是A的子类，cat是C类的一个对象，bird是B类的一个对象，下列哪个叙述是错误的？
A. cat instanceof B 的值是true。
B. bird instanceof A的值是true。
C. cat instanceof A的值是true。
D. bird instanceof C的值是true。

---

（5）下列程序中注释的哪个代码（A、B、C、D）是错误的（无法通过编译）？

Java
class A{
    static int m;
    static void f(){
        m = 20;    //A
    }
}
class B extends A{
    void f(){    //B
        m = 222;    //C
    }
}
class E{
    public static void main(String args[]){
        A.f();    //D
    }
}

---

（6）下列程序中注释的哪个代码（A、B、C、D）是错误的？

Java
abstract class Takecare{
    protected void speakHello(){}    //A
    public abstract static void cry();    //B
    static int f(){ return 0;}    //C
    abstract float g();    //D
}

---

（7）下列程序中注释的哪个代码（A、B、C、D）是错误的（无法通过编译）？

Java
abstract class A{
    abstract float getFloat();    //A
    void f()    //B
    { }
}
public class B extends A{
    private float m = 1.0f;    //C
    private float getFloat ()    //D
    {
        return m;
    }
}

---

（8）将下列哪个代码（A、B、C、D）放入程序中标注的【代码】处将导致编译错误？
A. public float getNum(){return 4.0f;}
B. public void getNum(){}
C.public void getNum(double d){}
D.public double getNum(float d){return 4.0d;}

class A{
    public float getNum(){
        return 3.0f;
    }
}
public class B extends A{
    【代码】
}

---

（9）对于下列代码，下列哪个叙述是正确的？
A.程序提示编译错误（原因是A类没有不带参数的构造方法）。
B.编译无错误，【代码】输出结果是0。
C.编译无错误，【代码】输出结果是1。
D.编译无错误，【代码】输出结果是2。

Java
class A{
    public int i = 0;
    A(int m){
        i=1;
    }
}
public class B extends A{
    B(int m){
        i=2;
    }
    public static void main(String args[]){
        B b = new B(100);
        System.out.println(b.i);//【代码】
    }
}

选择题解析

9.A
父类的构造方法不允许被继承，不允许被重写，但在子类的构造过程中必须调用其父类的构造方法，如果子类的构造方法中没有显式的调用父类的构造方法(super关键字)，则系统默认调用父类无参的构造方法。如果子类构造方法中既没有显式调用父类的构造方法，而父类又没有无参的构造方法，则编译出错。

---

8.B
方法重写要求方法名，返回值类型，参数完全相同，所以A符合，B返回值类型不同，编译错误。而C和D不仅返回值类型不同，参数也不同，不属于方法重写，而是属于子类自己新增的方法。

---

7.D
方法重写要求重写的方法的访问权限大于等于被重写的方法，父类该方法权限为友好，子类中为私有，所以是错误的。

---

6.B
abstract方法不能用static和private修饰；对于类，不能同时用final和abstract修饰，因为final关键字使得类不可继承，而abstract修饰的类如果不可以继承将没有任何意义。

---

5.B
实例方法是不能重写静态方法的，所以静态方法重写必须是静态方法。

---

4.D
instanceof运算符判断左面的对象是否是右面的类或其子类所创建的。
cat是C类的对象，而C是B的子类，所以A正确
bird是B类的对象而B是A的子类，所以B正确
cat是C类的对象，而C是B的子类，B又是A的子类，所以C正确
bird是B类的对象，而B是C的父类，所以D错误

---

3.CD
程序声明了Son的对象erzi，去调用money属性赋值，虽然Son继承了Father，但是money是Father的私有变量，是无法继承的，不能够赋值。而且在Son类中声明了一个与Father同名的属性height，此时子类就隐藏了继承的成员变量，调用的时候就是在调用子类自己的成员变量height，因为是int型，无法被赋值给float型，所以C和D是错误的。

---

2.D
用final修饰的类是不允许被继承的，A错误
abstract类中也可以有普通成员方法，B错误
abstract类中的非abstract方法是可以用final修饰的，而abstract方法是不可以被final修饰的，C错误
D同上，所以正确
不允许使用static修饰abstract方法，E错误。

---

1.C
子类是不继承父类的构造方法的，而是必须调用其父类的构造方法。
abstract类的子类可以是abstract类，如果是非abstract类，就必须重写父类中所有的abstract方法。
D中子类新增的方法是不能直接操作被子类隐藏的成员变量的。