Java toString（）方法不是从其超类继承的

我正在进行一项任务，该任务包括以下几类：

Vehicle.java

（抽象类）

NewVehicle.java

Vehicle.java的子类

UsedVehicle.java

Vehicle.java的子类

VehicleParser.java

用作解析器

驱动器

用作主驱动器的类

在

VehicleParser

I类中，确定它是哪个对象。它是

新车

对象或

二手车

。并在

驱动器

I类中，用

车辆

对象填充

阵列列表

现在，当我尝试

System.out.println

一个

Arraylist

时，drive类只是调用

toString

方法，该方法在

UsedVehicle

/

NewVehicle

中声明，而不是调用

Vehicle.java

类中声明的方法。我需要它首先调用Vehicle的方法

toString

，然后使用它连接

UsedVehicle的
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;
    }
}

DriveClass

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

您正在重写
toString（）
方法。Java在这里没有任何特殊的魔力。如果希望调用super类的方法，则需要显式地使用
super
关键字：

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

您正在重写
toString（）
方法。Java在这里没有任何特殊的魔力。如果希望调用super类的方法，则需要显式地使用
super
关键字：

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

只考虑这个例子：
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";
    }
}

基本上，这里的情况是，当您继承父类时，您正在重写父类方法中的所有内容，并为其提供新的定义。通过重写父类的方法，您的意思是：

我给这个方法一个新的定义。从现在起，对于我的所有对象和我孩子的对象，这将只是将要考虑的定义，任何父对象的方法定义都是无效的

现在，如果希望在调用此方法定义之前调用父方法定义，则必须在代码中明确声明使用
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";
    }
}

只考虑这个例子：
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";
    }
}

基本上，这里的情况是，当您继承父类时，您正在重写父类方法中的所有内容，并为其提供新的定义。通过重写父类的方法，您的意思是：

我给这个方法一个新的定义。从现在起，对于我的所有对象和我孩子的对象，这将只是将要考虑的定义，任何父对象的方法定义都是无效的

现在，如果希望在调用此方法定义之前调用父方法定义，则必须在代码中明确声明使用
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";
    }
}

当您调用子类方法时，将调用被重写的方法，父方法中的所有定义都将被重写，并且您将只获得被重写的方法定义。因此，为了使用父类的方法定义，您需要在子类方法中使用
super（）
方法

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

当您调用子类方法时，将调用被重写的方法，父方法中的所有定义都将被重写，并且您将只获得被重写的方法定义。因此，为了使用父类的方法定义，您需要在子类方法中使用
super（）
方法

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