Question

我确定以前已经有人问过这个问题，但是我找不到我的问题的明确答案。假设我们有以下两个课程：

public abstract class Vehicle {
    private int gasTank;
    private int milesDriven;

    void Vehicle(int gas, int milesDriven) {
        gasTank = gas;
        this.milesDriven = milesDriven;
    }

    void move(int miles) {
        gasTank -= subclass.getMileage() * miles;  // I know this doesn't work but bear with me
        milesDriven += miles;
    }
}

public class HyundaiSonata extends Vehicle {
    private int mileage;

    void HyundaiSonata () { super(40, 5000); }

    int getMileage() {return mileage;}
}

本质上，我的问题在第11行上。由于继承只会不断上升，因此无法访问子类方法或字段，因此我将如何构造它呢？

编辑：请注意，该解决方案应适用于我拥有数百种扩展Vehicle类的不同车辆的一般情况

Answer 1

添加

protected abstract int getMileage();

在超类和子类中需要覆盖它

Answer 2

您需要在子类中重写move方法。在父类中使您的move方法变得抽象。

我可以争论的一种方法是让Vehicle类具有许多子类，在这种情况下，您将无法在Vehicle类中编写move方法，因为您不知道要乘哪个子类里程请参阅。

这是更正的代码。

public abstract class Vehicle {
    private int gasTank;
    private int milesDriven;

    void Vehicle(int gas, int milesDriven) {
        gasTank = gas;
        this.milesDriven = milesDriven;
    }
    // make this function abstract
    abstract void move(int miles); 

}

public class Hyundai Sonata extends Vehicle {
    private int mileage;

    void Hyundai Sonata () { super(40, 5000); }

    void getMileage() {return mileage;}
    //override it here
    @Override
    public void move(int miles){
    gasTank -=this.getMileage() * miles;
        milesDriven += miles; 
    }

}

编辑1：-

正如您在评论中指出的那样，这是一种解决问题的方法。

让里程变量成为车辆类别的实体。

所以您的车辆类别看起来像

public abstract class Vehicle {
    private int gasTank;
    private int milesDriven;
    private int mileage;
    void Vehicle(int gas, int milesDriven,int mileage) {
        gasTank = gas;
        this.milesDriven = milesDriven;
        this.mileage=mileage;
    }
    public void move(int miles){
     gasTank -=mileage * miles;
    milesDriven += miles; 
}


}

您的子类将如下所示。

 public class Hyundai Sonata extends Vehicle {
        private int mileage;

        void Hyundai Sonata () { super(40, 5000,mileage); }



        }

}

Answer 3

应该是：

public abstract class Vehicle {
    private int gasTank;
    private int milesDriven;

    void Vehicle(int gas, int milesDriven) {
        gasTank = gas;
        this.milesDriven = milesDriven;
    }

    protected abstract int getMileage(); // Introduce this abstract method

    void move(int miles) {
        gasTank -= subclass.getMileage() * miles;  
        milesDriven += miles;
    }
}

public class HyundaiSonata extends Vehicle {
    private int mileage;

    void HyundaiSonata () { super(40, 5000); }

    @Override 
    public int getMileage() {return mileage;}
}

Answer 4

您可以通过使子类成为getMileage来强制子类实现abstract方法。这样，子类仅需要实现Vehicle类所不知道的行为，而无需与move方法的逻辑分离。看起来应该像这样。

public abstract class Vehicle {
    private int gasTank;
    private int milesDriven;

    Vehicle(int gas, int milesDriven) {
        gasTank = gas;
        this.milesDriven = milesDriven;
    }

    void move(int miles) {
        gasTank -= this.getMileage() * miles;
        milesDriven += miles;
    }

    abstract int getMileage()
}

public class HyundaiSonata extends Vehicle {
    HyundaiSonata () { super(40, 5000); }

    @Override
    int getMileage() {
        return 5;
    }
}

私有变量的继承

4 个答案: