toString() 方法没有继承自它的 super class

Question

我正在处理具有以下 classes 的任务：

Vehicle.java（摘要Class）
NewVehicle.java Vehicle.java
UsedVehicle.java Vehicle.java
VehicleParser.java 用作解析器
Drive Class 用作 main

在VehicleParserclass中我判断是哪个对象。它要么是 NewVehicle 对象，要么是 UsedVehicle。在 Drive class 中，我用 Vehicle 个对象填充 ArrayList。

现在，当我尝试 System.out.println 一个 Arraylist 时，驱动器 class 只是调用 toString 在 UsedVehicle/[=22 中声明的方法=] 但不调用 Vehicle.java class 中声明的方法。我需要它首先调用 Vehicle 的方法 toString，然后用它连接 UsedVehicle/NewVehicle 的 toString。

这是代码：

车辆

public abstract class Vehicle {

    protected String make;
    protected int modelYear;
    protected String motivePower;
    protected double licenseFee;

    public Vehicle(String make,int modeYear,String motivePower) {
        this.make = make;
        this.modelYear= modeYear;
        this.motivePower = motivePower;
        this.licenseFee = 0.0;
    }

    public String getMake() {
        return make;
    }

    public void setMake(String make) {
        this.make = make;
    }

    public int getModelYear() {
        return modelYear;
    }

    public void setModelYear(int modelYear) {
        this.modelYear = modelYear;
    }

    public String getMotivePower() {
        return motivePower;
    }

    public void setMotivePower(String motivePower) {
        this.motivePower = motivePower;
    }

    public double getLicenseFee() {
        return licenseFee;
    }

    public void setLicenseFee(double licenseFee) {
        this.licenseFee = licenseFee;
    }

    public abstract void computeLicenseFee();

    public String toString()
    {
        return "\nMake:\t\t"+getMake()+
                "\nModel Year:\t"+getModelYear()+
                "\n Motive Power:\t"+getMotivePower()+
                "\nLicense Fee:\t"+getLicenseFee();
    }

    public static class UsedVehicle extends Vehicle
    {
        public String previousLicenseState;
        public int currentYear;
        int yearsOld = 0;

        public UsedVehicle(String make, int modelYear, String power, String previousState, int currentYear)
        {
            super(make,modelYear,power);
            this.previousLicenseState = previousState;
            this.currentYear = currentYear;
        }


        public String getPreviousLicenseState() {
            return previousLicenseState;
        }


        public void setPreviousLicenseState(String previousLicenseState) {
            this.previousLicenseState = previousLicenseState;
        }


        public int getCurrentYear() {
            return currentYear;
        }


        public void setCurrentYear(int currentYear) {
            this.currentYear = currentYear;
        }


        public void computeLicenseFee() {
            double baseFee = 100.00;
            double titleTransferFee = 15.00;
            double smogWaiverFee = 0.00;
            double smogAbatement = 0.00;

            yearsOld = getCurrentYear() - getModelYear();
            if(yearsOld > 5)
            {
                smogWaiverFee = 8.00;
            }

            if("gas".equalsIgnoreCase(getMotivePower()))
            {
                smogAbatement = 20.00;
            }

            licenseFee = baseFee + smogAbatement + titleTransferFee + smogWaiverFee; 
        }

        public String toString()
        {
            return "\n Years Old:\t"+yearsOld+
                    "\n Previous State:\t"+getPreviousLicenseState();
        }
    }

    public static class NewVehicle extends Vehicle
    {
        public double vehiclePrice;

        public NewVehicle(String make, int modeYear, String motivePower,double price) {
            super(make, modeYear, motivePower);
            this.vehiclePrice = price;
        }


        public double getVehiclePrice() {
            return vehiclePrice;
        }


        public void setVehiclePrice(double vehiclePrice) {
            this.vehiclePrice = vehiclePrice;
        }


        public void computeLicenseFee() {

            double baseFee = 150.00;
            double smogAbatement = 0.00;
            double priceFee = 0.00;

            if("gas".equalsIgnoreCase(getMotivePower()))
            {
                smogAbatement = 20.0;
                priceFee = getVehiclePrice()*0.15;
            }

            licenseFee = baseFee + smogAbatement + priceFee; 
        }

        public String toString()
        {
            return "Price:\t\t$"+getVehiclePrice();
        }
    }
}

解析器

public class VehicleParser {

    public static Vehicle parseStringToVehicle(String lineToParse)
    {
        Vehicle vehicleObj = null;

        Vehicle.UsedVehicle usedVeh = new Vehicle.UsedVehicle(make, modelYear, power, previousState, currentYear);

        return vehicleObj;
    }
}

驱动器Class

 Vehicle obj = VehicleParser.parseStringToVehicle(inputInfo);
 vehicleList.add(obj);
 System.out.println(vehicleList.get(i));

Answer 1

您正在覆盖 toString() 方法。 Java 在这里没有做任何特殊的魔法。如果你想调用 super class' 方法，你需要使用 super 关键字明确地这样做：

@Override
public String toString()
{
    return super.toString() + // Here
            "\n Years Old:\t"+yearsOld+
            "\n Previous State:\t"+getPreviousLicenseState();
}

Answer 2

仅考虑这个例子：

public class A {
    public String someMethod() {
        return "A method";
    }
}

public class B extends A {
    @Override
    public String someMethod() {
        return "B method";
    }
}

public class C extends B {
    @Override
    public String someMethod() {
        return "C method";
    }
}

基本上这里发生的事情是，当您继承父 class 时，您将覆盖父 class 方法中的所有内容，并且您正在提供新的方法 通过 重写父 class 的方法 ，你是说：

I'm giving a new fresh definition to this method. From now onward, for all of my objects and my child's object, this is only going to be the definition that would be considered and any of parent's method definition is void.

现在，如果您希望在调用此方法定义之前调用父方法定义，那么您必须在代码中使用 super.methodName() 明确声明。

public class A {
    public String someMethod() {
        return "A method";
    }
}

public class B extends A {
    @Override
    public String someMethod() {
        return super.someMethod() + "B method";
    }
}

public class C extends B {
    @Override
    public String someMethod() {
        return super.someMethod() + "C method";
    }
}

Answer 3

当您调用 subclass 方法时，将调用被覆盖的方法并且 parent 的方法中的所有定义都将被覆盖，您将仅获得被覆盖的方法定义。因此，要使用 parents 的方法定义，您还需要在 child class 方法中使用 super() 方法...

return super.toString() + " is a new car!";

toString() 方法没有继承自它的 super class

toString() method is not inherting from its super class

java

oop

inheritance

tostring