在我的交易车辆(汽车或卡车)程序中，您可以出售单辆或多辆车辆并重新订购。出售的汽车交付时配备 40 升汽油，卡车交付时配备 80 升汽油。您还可以补充车辆和燃料。
-问题:它不允许我再销售卡车(以前可以)。当我运行交互式文件并尝试出售卡车时，没有任何反应。但对于汽车来说，即使它与汽车的代码相同，它也能工作。
此外，我在教授给我们的 JUnit 中遇到了 2 个 JUnit 错误。以下是错误:
public void testParentClass(){
CarTrader trader1 = passengerCarTrader;
trader1.checkAvailability(VehicleBrand.AUDI, 1);
trader1.isSoldVehicleType(VehicleType.PASSENGER_CAR);
trader1.reorderVehicles(VehicleBrand.AUDI, 1);
- CarTrader 类型的方法 checkAvailability(int, int) 未定义 - CarTrader 类型的方法 isSoldVehicleType(byte) 未定义 -CarTrader 类型的方法 reorderVehicles(int, int) 未定义
所以我认为这意味着抽象类没有在父类(super class)中实现。但我该如何实现呢？
公共(public)抽象无效checkAvailability(); 不起作用
它还说“PassengerCarTrader 类型必须实现继承的抽象方法 isSoldVehicle、checkAvailabilty、reorderVehicles。
public abstract class CarTrader {
public static final float CAPACITY_DIESEL_LITERS = 350.f;
public static final float CAPACITY_GAS_LITERS = 180.f;
public static final int CAPACITY_PASSENGER_CARS = 15;
public static final int CAPACITY_TRUCKS = 8;
float gasStockLiters=180.f;
float dieselStockLiters=250.f;
int passengerCarsStock=15;
int trucksStock=8;
int mANStock=4;
int scaniaStock=4;
int audiStock=4;
int bMWStock=4;
int opelStock=4;
int mercedesStock=3;
public CarTrader(){
}
void setGasStockLiters(float gasStockLiters){
this.gasStockLiters=gasStockLiters;
}
void setDieselStockLiters(float dieselStockLiters){
this.dieselStockLiters=dieselStockLiters;
}
void setPassengerCarsStock(int passengerCarsStock){
this.passengerCarsStock=passengerCarsStock;
}
void setTrucksStock(int trucksStock){
this.trucksStock=trucksStock;
}
int getPassengerCarsStock(){
return passengerCarsStock;
}
int getTrucksStock(){
return trucksStock;
}
float getGasStockLiters(){
return gasStockLiters;
}
float getDieselStockLiters(){
return dieselStockLiters;
}
CarTrader(int a){
this.audiStock=a;
}
public Vehicle sellVehicle(byte vehicleType, int brand){
Vehicle soldCar=null;
switch (vehicleType){
case 0:
if (this.gasStockLiters>=Vehicle.TANK_SIZE_PASSENGER_CAR){
switch (brand) {
case VehicleBrand.AUDI:
if (this.audiStock>=1){
this.audiStock = this.audiStock - 1;
this.gasStockLiters = this.gasStockLiters - Vehicle.TANK_SIZE_PASSENGER_CAR;
this.passengerCarsStock = this.passengerCarsStock - 1;
soldCar = new Vehicle(VehicleType.PASSENGER_CAR);
} else {
System.err.println("Nicht genug AUDI oder Benzin vorhanden");
}
break;
case VehicleBrand.BMW:
if(this.bMWStock>=1){
this.bMWStock = this.bMWStock -1;
this.gasStockLiters = this.gasStockLiters - Vehicle.TANK_SIZE_PASSENGER_CAR ;
this.passengerCarsStock = this.passengerCarsStock - 1;
soldCar = new Vehicle(VehicleType.PASSENGER_CAR);
} else {
System.err.println("Nicht genug BMW oder Benzin vorhanden");
}
break;
case VehicleBrand.MERCEDES:
if (this.mercedesStock>=1){
this.mercedesStock = this.mercedesStock - 1;
this.gasStockLiters = this.gasStockLiters - Vehicle.TANK_SIZE_PASSENGER_CAR;
this.passengerCarsStock = this.passengerCarsStock - 1;
soldCar = new Vehicle(VehicleType.PASSENGER_CAR);
} else {
System.err.println("Nicht genug Mercedes oder Benzin vorhanden");
}
break;
case VehicleBrand.OPEL:
if(this.opelStock>=1){
this.opelStock = this.opelStock -1;
this.gasStockLiters = this.gasStockLiters - Vehicle.TANK_SIZE_PASSENGER_CAR;
this.passengerCarsStock = this.passengerCarsStock - 1;
soldCar = new Vehicle(VehicleType.PASSENGER_CAR);
} else {
System.err.println("Nicht genug Opel oder Benzin vorhanden");
}
break;
default: soldCar=null;
break;
}
} else {
soldCar=null;
}
System.out.println("Fahrzeug(e) erfolgreich verkauft");
break;
case VehicleBrand.MAN:
if (this.dieselStockLiters>=Vehicle.TANK_SIZE_TRUCK){
switch (brand) {
case 1://MAN
if (this.mANStock>=1){
this.mANStock = (this.mANStock-1);
trucksStock = trucksStock - 1;
dieselStockLiters = dieselStockLiters - Vehicle.TANK_SIZE_TRUCK;
soldCar = new Vehicle(VehicleType.TRUCK);
System.out.println("Fahrzeug(e) erfolgreich verkauft");
} else {
soldCar=null;
System.err.println("Nicht genug MAN-Trucks oder Diesel vorhanden");
}
break;
case VehicleBrand.SCANIA:
if(this.scaniaStock>=1){
this.scaniaStock = this.scaniaStock -1;
trucksStock = trucksStock - 1;
dieselStockLiters = dieselStockLiters - Vehicle.TANK_SIZE_TRUCK;
System.out.println("Fahrzeug(e) erfolgreich verkauft");
soldCar = new Vehicle(VehicleType.TRUCK);
} else {
soldCar=null;
System.err.println("Nicht genug Scania-Trucks oder Diesel vorhanden");
}
break;
default: soldCar=null;
}
break;
}
else {
soldCar=null;
}
}
return soldCar;
}
public Vehicle[] sellVehicles(byte vehicleType, int brand, int amount){
Vehicle[] soldCar= new Vehicle[amount];
boolean sold=false;
switch (vehicleType){
case 0:
if(this.dieselStockLiters>=Vehicle.TANK_SIZE_TRUCK*amount){
switch (brand) {
case VehicleBrand.MAN://MAN
if (this.mANStock>=amount){
this.mANStock = this.mANStock - amount;
trucksStock = trucksStock - amount;
dieselStockLiters = dieselStockLiters - Vehicle.TANK_SIZE_TRUCK*amount;
sold=true;
} else {
System.err.println("Nicht genug MAN-Trucks oder Diesel vorhanden");
}
break;
case VehicleBrand.SCANIA://Scania
if(this.scaniaStock>=amount){
this.scaniaStock = this.scaniaStock -amount;
trucksStock = trucksStock - amount;
dieselStockLiters = dieselStockLiters - Vehicle.TANK_SIZE_TRUCK*amount;
sold=true;
} else {
System.err.println("Nicht genug Scania-Trucks oder Diesel vorhanden");
}
if (sold=true){
for (int i=0; i<amount; i++){
soldCar[i]=new Vehicle(VehicleType.TRUCK);
}
System.out.println("Fahrzeug(e) erfolgreich verkauft");
}
if (sold=false) {
for (int i=0; i<amount; i++){
soldCar[i]=null;
}
}
}
}
case 1:
if (this.gasStockLiters>=Vehicle.TANK_SIZE_PASSENGER_CAR*amount){
switch (brand){
case VehicleBrand.AUDI://AUDI
if (this.audiStock>=amount){
this.audiStock = this.audiStock - amount;
this.gasStockLiters = this.gasStockLiters - Vehicle.TANK_SIZE_PASSENGER_CAR*amount;
this.passengerCarsStock = this.passengerCarsStock - amount;
sold=true;
} else {
System.err.println("Nicht genug AUDI oder Benzin vorhanden");
}
break;
case VehicleBrand.BMW://BMW
if(this.bMWStock>=amount){
this.bMWStock = this.bMWStock -amount;
this.gasStockLiters = this.gasStockLiters - Vehicle.TANK_SIZE_PASSENGER_CAR*amount;
this.passengerCarsStock = this.passengerCarsStock - amount;
sold=true;
} else {
System.err.println("Nicht genug BMW oder Benzin vorhanden");
}
break;
case VehicleBrand.MERCEDES://MERCEDES
if (this.mercedesStock>=amount){
this.mercedesStock = this.mercedesStock - amount;
this.gasStockLiters = this.gasStockLiters - Vehicle.TANK_SIZE_PASSENGER_CAR*amount;
this.passengerCarsStock = this.passengerCarsStock - amount;
sold=true;
} else {
System.err.println("Nicht genug Mercedes oder Benzin vorhanden");
}
break;
case VehicleBrand.OPEL://OPEL
if(this.opelStock>=amount){
this.opelStock = this.opelStock -amount;
this.gasStockLiters = this.gasStockLiters - Vehicle.TANK_SIZE_PASSENGER_CAR *amount;
this.passengerCarsStock = this.passengerCarsStock - amount;
sold=true;
} else {
System.err.println("Nicht genug Opel oder Benzin vorhanden");
}
break;
}
if (sold=true){
for (int i=0; i<amount; i++){
soldCar[i]=new Vehicle(VehicleType.PASSENGER_CAR);
}
System.out.println("Fahrzeug(e) erfolgreich verkauft");
}
if (sold=false) {
for (int i=0; i<amount; i++){
soldCar[i]=null;
}
}
}
}
return soldCar;
}
public boolean fillGas(float gas){
boolean filled=false;
if((gasStockLiters + gas)<=CarTrader.CAPACITY_GAS_LITERS){
gasStockLiters = gasStockLiters + gas;
filled=true;
}
else{
System.err.println("Die Kapazität beträgt höchstens 180 Liter");
}
return filled;
}
public boolean fillDiesel(float diesel){
boolean filled2=false;
if((dieselStockLiters + diesel)<=CarTrader.CAPACITY_DIESEL_LITERS){
dieselStockLiters = dieselStockLiters + diesel;
filled2=true;
}
else{
System.err.println("Die Kapazität beträgt höchstens 250 Liter");
}
return filled2;
}
public abstract void isSoldVehicle();
void statusOutput()
{
System.out.println("AutoHändler - Lagerbestand:");
System.out.println(" PKW: " + passengerCarsStock);
System.out.println("Audi: " +this.audiStock);
System.out.println("BMW: "+ this.bMWStock);
System.out.println("Mercedes: "+ this.mercedesStock);
System.out.println("Opel: "+ this.opelStock);
System.out.println("LKWHändler - Lagerbestand");
System.out.println(" LKW: " + trucksStock);
System.out.println("MAN: "+ this.mANStock);
System.out.println("Scania "+this.scaniaStock);
System.out.println("Kraftstoff Lagerbestand:");
System.out.println(" - Diesel: " + dieselStockLiters);
System.out.println(" - Benzin: " + gasStockLiters);
}
}
PassengerCarTrader
public class PassengerCarTrader extends CarTrader {
public static final int CAPACITY_AUDI = 4;
public static final int CAPACITY_BMW = 4;
public static final int CAPACITY_OPEL = 4;
public static final int CAPACITY_MERCEDES = 3;
void setGasStockLiters(float gasStockLiters){
this.gasStockLiters=gasStockLiters;
}
void setPassengerCarsStock(int passengerCarsStock){
this.passengerCarsStock=passengerCarsStock;
}
int getPassengerCarsStock(){
return passengerCarsStock;
}
float getGasStockLiters(){
return gasStockLiters;
}
void setMercedesStock(int mercedesStock){
this.mercedesStock=mercedesStock;
}
void setBMWStock(int bMWStock){
this.bMWStock=bMWStock;
}
void setAudiStock(int audistock){
this.audiStock=audistock;
}
void setOpelStock(int opelstock){
this.opelStock=opelstock;
}
int getMercedesStock(){
return mercedesStock;
}
int getBMWStock(){
return bMWStock;
}
int getOpelStock(){
return opelStock;
}
int getAudiStock(){
return audiStock;
}
public boolean reorderVehicles(int amountVehicles, int brand){
boolean full=false;
if((passengerCarsStock+amountVehicles)<=CAPACITY_PASSENGER_CARS){
switch (brand){
case VehicleBrand.AUDI:
if ((this.audiStock+amountVehicles)<=CAPACITY_AUDI){
this.audiStock += amountVehicles;
}
break;
case VehicleBrand.BMW:
if((this.bMWStock+amountVehicles)<=CAPACITY_BMW){
this.bMWStock += amountVehicles;
}
break;
case VehicleBrand.MERCEDES:
if((this.mercedesStock+amountVehicles)<=CAPACITY_MERCEDES){
this.mercedesStock += amountVehicles;
}
break;
case VehicleBrand.OPEL:
if((this.opelStock+amountVehicles)<=CAPACITY_OPEL){
this.opelStock += amountVehicles;
}
break;
default:
System.err.println("Ungültige Eingabe");
break;
}
passengerCarsStock += amountVehicles;
full=true;
}
return full;
}
public void isSoldVehicleType(byte type){
if (type==VehicleType.TRUCK){
System.out.println("Es handelt sich um einen Truck");
}
if (type==VehicleType.PASSENGER_CAR){
System.out.println("Es handelt sich um einen PKW");
}
}
public boolean checkAvailability (int brand, int amount){
boolean available=false;
switch (brand){
case VehicleBrand.AUDI: if(this.audiStock>=amount){
System.out.println("Die gewünschte Menge ist verfügbar");
available=true;
} else {
System.out.println("Die gewünschte Menge ist nicht verfügbar");
}
case VehicleBrand.BMW: if(this.bMWStock>=amount){
System.out.println("Die gewünschte Menge ist verfügbar");
available=true;
} else {
System.out.println("Die gewünschte Menge ist nicht verfügbar");
}
case VehicleBrand.MERCEDES: if(this.mercedesStock>=amount){
System.out.println("Die gewünschte Menge ist verfügbar");
available=true;
} else {
System.out.println("Die gewünschte Menge ist nicht verfügbar");
}
case VehicleBrand.OPEL: if(this.opelStock>=amount){
System.out.println("Die gewünschte Menge ist verfügbar");
available=true;
} else {
System.out.println("Die gewünschte Menge ist nicht verfügbar");
}
default:
System.err.println("Bitte wählen Sie 1 bis 4");
}
return available;
}
}
TruckTrader
public class TruckTrader extends CarTrader{
public static final int CAPACITY_MAN = 4;
public static final int CAPACITY_SCANIA = 4;
void setDieselStockLiters(int dieselStockLiters){
this.dieselStockLiters=dieselStockLiters;
}
void setTrucksStock(int trucksStock){
this.trucksStock=trucksStock;
}
void setMANStock(int mANStock){
this.mANStock=mANStock;
}
void setScaniaStock(int scaniaStock){
this.scaniaStock=scaniaStock;
}
float getDieselStockLiters(){
return dieselStockLiters;
}
int getTrucksStock(){
return trucksStock;
}
int getMANStock(){
return mANStock;
}
int getScaniaStock(){
return scaniaStock;
}
public boolean reorderVehicles(int amountVehicles, int brand){
boolean full=false;
if((trucksStock+amountVehicles)<=CAPACITY_TRUCKS){
switch (brand){
case VehicleBrand.MAN:
if ((this.mANStock+amountVehicles)<=CAPACITY_MAN){
this.mANStock += amountVehicles;
}
break;
case VehicleBrand.SCANIA:
if((this.scaniaStock+amountVehicles)<=CAPACITY_SCANIA){
this.scaniaStock += amountVehicles;
}
break;
default:
System.err.println("Ungültige Eingabe");
break;
}
trucksStock += amountVehicles;
full=true;
}
return full;
}
public void isSoldVehicleType(byte type){
if (type==VehicleType.TRUCK){
System.out.println("Es handelt sich um einen Truck");
}
if (type==VehicleType.PASSENGER_CAR){
System.out.println("Es handelt sich um einen PKW");
}
}
public boolean checkAvailability (int brand, int amount){
boolean available=false;
switch (brand){
case VehicleBrand.MAN: if(this.mANStock>=amount){
System.out.println("Die gewünschte Menge ist verfügbar");
available=true;
} else {
System.out.println("Die gewünschte Menge ist nicht verfügbar");
}
case VehicleBrand.SCANIA: if(this.scaniaStock>=amount){
System.out.println("Die gewünschte Menge ist verfügbar");
available=true;
} else {
System.out.println("Die gewünschte Menge ist nicht verfügbar");
}
}
return available;
}
}
VehicleBrand
public final class VehicleBrand {
public static final int AUDI = 1;
public static final int BMW = 2;
public static final int OPEL = 3;
public static final int MERCEDES = 4;
public static final int MAN = 1;
public static final int SCANIA = 2;
//This class is just an organizer for the above constants; Not instantiable.
private VehicleBrand(){
}
}
VehicleType
public final class VehicleType {
public static final byte PASSENGER_CAR = 7;
public static final byte TRUCK = 5;
/**
* This class is just an organizer for the above constants; Not instantiable.
*/
private VehicleType(){
}
}
Vehicle
public class Vehicle {
public static final float TANK_SIZE_PASSENGER_CAR = 40.f;
public static final float TANK_SIZE_TRUCK = 80.f;
public float fuel;
public byte mVehicleType;
public int brand;
public Vehicle(){}
public Vehicle(byte vehicleType){
this();
if (vehicleType == VehicleType.PASSENGER_CAR){
this.mVehicleType= VehicleType.PASSENGER_CAR ;
this.fuel= Vehicle.TANK_SIZE_PASSENGER_CAR;
}
if(vehicleType == VehicleType.TRUCK){
this.mVehicleType= VehicleType.TRUCK;
this.fuel= Vehicle.TANK_SIZE_TRUCK;
}
}
public float getFuel(){
return this.fuel;
}
public byte getVehicleType(){
return this.mVehicleType;
}
}
最佳答案
两个子类都有一个如下所示的方法:
public boolean checkAvailability(int brand, int amount) {
// .....
}
如果你想使用父类的变量并让它们调用这个方法，那么父抽象类也必须声明这个方法。它可以是一个抽象方法，因为子类已经实现了它，但它必须存在，并且还要理解这是不够的:
public abstract void checkAvailability();
因为方法签名必须完全匹配，包括返回类型和参数。你的父类中必须有这样的东西:
public abstract boolean checkAvailability(int brand, int amount);
你看到区别了吗，包括返回类型和参数？您的编译器是严格且无情的，因此您编码器也必须如此。
完成此操作后，在您的子类上方添加一个 @Override 注释，以确保覆盖正确完成。
还有这个:
CarTrader trader1 = passengerCarTrader;
无法编译。它需要更像是:
CarTrader trader1 = New PassengerCarTrader();
同样，您的编译器不会容忍马虎，因此您必须努力在编码和问题中避免马虎。
<小时/>将来，请尝试将您的代码和问题简化到最低限度以演示您的问题。对于这个问题，您所需要的只是:
public class TestCars {
public static void main(String[] args) {
CarTrader trader1 = new PassengerCarTrader();
if (trader1.checkAvailability(3, 1));
}
}
public abstract class CarTrader {
public abstract void checkAvailability();
}
public class PassengerCarTrader extends CarTrader {
public boolean checkAvailability(int brand, int amount) {
boolean availability = false;
// .....
return availability;
}
}
这显然不能编译，而这个可以:
public class TestCars {
public static void main(String[] args) {
CarTrader trader1 = new PassengerCarTrader();
if (trader1.checkAvailability(3, 1));
}
}
abstract class CarTrader {
public abstract boolean checkAvailability(int brand, int amount);
}
class PassengerCarTrader extends CarTrader {
@Override
public boolean checkAvailability(int brand, int amount) {
boolean availability = false;
// .....
return availability;
}
}
关于java - 无法在我的车辆交易程序中销售卡车和 1 个 JUnit 错误(缺少抽象方法)，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/49949662/