《Java编程入门官方教程》第七章练习答案

【练习7-1(TruckDemo.java)】扩展Vehicle类

为演示继承的强大功能，我们将扩展在第4章中最先开发的Vehicle类。它封装了汽车的信息，包括乘载人数、油箱容量和燃油利用率。我们可以把Vehicle类作为起点来创建更具体的类。例如，卡车是汽车的一种。卡车的一个重要属性就是它的运载能力。因此要创建Truck类，可扩展Vehicle类，添加存储运载能力的实例变量。下面的Truck类实现了这一点。在实现过程中，Vehicle类中的实例变量将被设为private，并提供访问器方法来获取或设置它们的值。

java 复制代码

package javaone.a.beginners.guide.chapterseven;

// Try This 7-1
//
// Build a subclass of Vehicle for trucks/
class Vehicle{
    private int passengers; // number of passengers
    private int fuelcap;    // fuel capacity in gallons
    private int mpg;        // fuel consumption in miles per gallon

    // This is a constructor for Vehicle
    Vehicle(int p, int f, int m){
        passengers = p;
        fuelcap = f;
        mpg = m;
    }

    // Return the range
    int range(){
        return mpg * fuelcap;
    }

    // Compute fuel needed for a given distance
    double fuelneeded(int miles){
        return (double) miles / mpg;
    }

    // Accessor methods for instance variables.

    public int getPassengers() {
        return passengers;
    }

    public void setPassengers(int passengers) {
        this.passengers = passengers;
    }

    public int getFuelcap() {
        return fuelcap;
    }

    public void setFuelcap(int fuelcap) {
        this.fuelcap = fuelcap;
    }

    public int getMpg() {
        return mpg;
    }

    public void setMpg(int mpg) {
        this.mpg = mpg;
    }
}

// Extend Vehicle to create a Truck specialization
class Truck extends Vehicle{
    private int cargocap;   // cargo capacity in pounds

    // This is a constructor for Truck
    Truck(int p, int f, int m, int c){
        /*
            Initialize Vehicle members using Vehicle's constructor.
         */
        super(p,f,m);

        cargocap = c;
    }

    // Accessor methods for cargocap.
    int getCargo(){
        return cargocap;
    }
    void putCargo(int c){
        cargocap = c;
    }
}

public class ChapterSevenProgramOne {

    public static void main(String[] args) {
        // construct some trucks
        Truck semi = new Truck(2, 200, 7, 44000);
        Truck pickup = new Truck(3, 28, 15, 2000);
        double gallons;
        int dist = 252;
        gallons = semi.fuelneeded(dist);
        System.out.println("Semi can carry " + semi.getCargo() + " pounds.");
        System.out.println("To go " + dist + " miles semi needs " + gallons + " gallons of fuel.\n");

        gallons = pickup.fuelneeded(dist);
        System.out.println("Pickup can carry " + pickup.getCargo() + " pounds.");
        System.out.println("To go " + dist + " miles pick up needs " + gallons + " gallons of fuel.\n");
    }

}

7.15 自测题

超类有权访问子类的成员吗?子类有权访问超类的成员吗?

答案：没有，超类不知道子类的存在。子类可以访问超类的任何非私有成员。

创建一个名为Circle的TwoDShape的子类，它包括一个计算圆面积的area方法和一个使用super初始化TwoDShape部分的构造函数。

java 复制代码

package javaone.a.beginners.guide.chapterseven;

class TwoDShapeTen{
    private double width;
    private double height;
    private String name;

    // A default constructor.
    TwoDShapeTen(){
        width = height = 0.0;
        name = "none";
    }

    // Parameterized constructor.
    TwoDShapeTen(double w, double h, String n){
        width = w;
        height = h;
        name = n;
    }

    // Construct object with equal width and height.
    TwoDShapeTen(double x, String n){
        width = height = x;
        name = n;
    }

    // Construct an object from an object.
    TwoDShapeTen(TwoDShapeTen ob){
        width = ob.width;
        height = ob.height;
        name = ob.name;
    }

    // Accessor methods for width and height.
    public double getWidth() {
        return width;
    }

    public void setWidth(double width) {
        this.width = width;
    }

    public double getHeight() {
        return height;
    }

    public void setHeight(double height) {
        this.height = height;
    }

    String getName() {
        return name;
    }

    void showDim(){
        System.out.println("Width and height are " + width + " and " + height);
    }

    double area(){
        System.out.println("area() must be overridden");
        return 0.0;
    }
}

// A subclass of TwoDShape for circles.
class Circle extends TwoDShapeTen{
    // A default constructor.
    Circle(){
        super();
    }
    
    // Construct Circle
    Circle(double x){
        super(x, "circle"); // call superclass constructor
    }
    
    // Construct an object from an object.
    Circle(Circle ob){
        super(ob);  // pass object to TwoDShape constructor
    }
    
    double area(){
        return (getWidth() / 2) * (getWidth() / 2) * 3.14;
    }
}

public class ChapterSevenExerciseTwo {
}

如何防止子类访问超类的成员?

答案：可以把超类的成员声明为私有的。

描述本章中两个super版本的目的及用法。

答案：super关键字具有两种形式。第一种用来调用超类的构造函数，其基本形式如下：

super(param-list);

第二种用来访问超类的成员，其基本形式如下：

super.member

已知层次结构如下：

class Alpha { ...

class Beta extends Alpha { ...

class Gamma extends Beta { ...

当初始化一个Gamma对象时，这些类的构造函数的调用顺序是什么?

答案：构造函数总是按照派生的顺序被调用，因此，当创建Gamma对象时，调用顺序是Alpha、Beta、Gamma。

超类引用可以引用一个子类对象。解释为什么当它与方法重写相关时，这一点变得特别有用?

答案：当重写的方法通过超类引用调用时，可通过被引用的对象的类型来判断调用哪一个版本的方法。

什么是抽象类?

答案：

有时，需要创建一个这样的超类：该超类只定义一个为所有子类共享的一般形式，至于细节则交给每个子类去填充。

Java对于这一问题的解决方法是抽象方法(abstract method）。抽象方法是通过指定abstract类型修饰符来创建的。

包含一个或多个抽象方法的类必须通过在其class声明前添加abstract修饰符来将其声明为抽象类。

如何使方法不被重写? 如何使类不被继承?

答案：要防止方法被重写，可将它声明为final。要防止类被继承，也可将它声明为final。

解释继承、方法重写和抽象类是如何支持多态的。

答案：继承、方法重写和抽象类是这样支持多态的：允许创建可由各种类实现的通用类结构。这样，抽象类就可以定义由所有实现的类共享一致的接口。这样做就实现了"一个接口，多个方法。"

什么类是其他所有类的超类?

答案：Object类。

包含至少一个抽象方法的类必须声明为抽象类，对吗?

答案：是的。

用于创建已命名常量的关键字是什么?

答案：final。