Java Can´；t在我的车辆交易程序中销售卡车，1个JUnit错误（缺少抽象方法）
在我的交易车辆（汽车或卡车）程序中，您可以销售单个或多个车辆并重新订购。一辆售出的汽车交付40升汽油，一辆卡车交付80升汽油。您还可以为车辆加油 -问题：它不再允许我销售卡车（以前是这样）。当我运行交互式文件并尝试销售卡车时，什么都没有发生。但对于汽车来说，它是有效的，尽管它的代码与汽车相同 我还发现教授给我们的JUnit有两个JUnit错误。以下是错误：Java Can´；t在我的车辆交易程序中销售卡车，1个JUnit错误（缺少抽象方法）,java,Java,在我的交易车辆（汽车或卡车）程序中，您可以销售单个或多个车辆并重新订购。一辆售出的汽车交付40升汽油，一辆卡车交付80升汽油。您还可以为车辆加油 -问题：它不再允许我销售卡车（以前是这样）。当我运行交互式文件并尝试销售卡车时，什么都没有发生。但对于汽车来说，它是有效的，尽管它的代码与汽车相同 我还发现教授给我们的JUnit有两个JUnit错误。以下是错误： public void testParentClass(){ CarTrader trader1 = passengerCarTra
public void testParentClass(){
CarTrader trader1 = passengerCarTrader;
trader1.checkAvailability(VehicleBrand.AUDI, 1);
trader1.isSoldVehicleType(VehicleType.PASSENGER_CAR);
trader1.reorderVehicles(VehicleBrand.AUDI, 1);
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;
}
}
公共抽象类CarTrader{
公共静态最终浮子容量柴油升=350.f；
公共静态最终浮子容量\气体\升=180.f；
公共静态最终整容乘用车=15；
公共静态最终整备能力=8辆卡车；
浮子气体贮存器=180.f；
浮式柴油机升=250.f；
int passengerCarsStock=15；
int truckstock=8；
int-mANStock=4；
int scaniaStock=4；
int audiStock=4；
int bMWStock=4；
int opelStock=4；
int-mercedesStock=3；
公共CarTrader（）{
}
真空设置气体储罐（浮子气体储罐）{
这个.gasStockLiters=gasStockLiters；
}
无效设定柴油储备升（浮动柴油储备升）{
这个。柴油机燃料升=柴油机燃料升；
}
作废设置passengerCarsStock（int passengerCarsStock）{
this.passengercastock=passengercastock；
}
作废SetTruckStock（int TruckStock）{
this.truckstock=truckstock；
}
int getPassengerCarsStock（）{
归还旅客股票；
}
int gettruckstock（）{
归还卡车库存；
}
float getGasStockLiters（）{
返回气体贮存器；
}
浮式柴油机（升）{
回油柴油机；
}
卡特拉德（INTA）{
这个.audiStock=a；
}
公共车辆销售车辆（字节车辆类型，国际品牌）{
车辆soldCar=零；
开关（车辆类型）{
案例0：
如果（此气体储罐>=车辆油箱尺寸乘用车）{
开关（品牌）{
案例车辆品牌奥迪：
如果（this.audiStock>=1）{
this.auditock=this.auditock-1；
this.gasStockLiters=this.gasStockLiters-车辆.油箱尺寸\乘用车；
this.passengercarstock=this.passengercarstock-1；
soldCar=新车（车型：乘用车）；
}否则{
系统错误println（“Nicht GEUNG AUDI ORDER BEZIN vorhanden”）；
}
打破
案例车辆品牌宝马：
如果（此.bMWStock>=1）{
this.bMWStock=this.bMWStock-1；
this.gasStockLiters=this.gasStockLiters-车辆.油箱尺寸\乘用车；
this.passengercarstock=this.passengercarstock-1；
soldCar=新车（车型：乘用车）；
}否则{
系统错误打印（“Nicht GEUNG BMW ORDER BEZIN vorhanden”）；
}
打破
案例车辆品牌梅赛德斯：
如果（this.mercedesStock>=1）{
this.mercedestock=this.mercedestock-1；
this.gasStockLiters=this.gasStockLiters-车辆.油箱尺寸\乘用车；
this.passengercarstock=this.passengercarstock-1；
soldCar=新车（车型：乘用车）；
}否则{
系统错误打印（“Nicht genug Mercedes Order Benzin vorhanden”）；
}
打破
案例车辆品牌.欧宝：
如果（此.opelStock>=1）{
this.opelStock=this.opelStock-1；
this.gasStockLiters=this.gasStockLiters-车辆.油箱尺寸\乘用车；
this.passengercarstock=this.passengercarstock-1；
soldCar=新车（车型：乘用车）；
}否则{
系统错误println（“Nicht genug Opel Order Benzin vorhanden”）；
}
打破
默认值：soldCar=null；
打破
}
}否则{
soldCar=null；
}
System.out.println（“Fahrzeug（e）erfolgreich verkauft”）；
打破
case VehiclerBrand.MAN：
如果（此柴油机容量>=车辆油箱尺寸\卡车）{
开关（品牌）{
案例1://男子
如果（this.mANStock>=1）{
this.mANStock=（this.mANStock-1）；
卡车库存=卡车库存-1；
柴油储备升=柴油储备升-车辆、油箱和卡车尺寸；
soldCar=新车（车辆类型卡车）；
System.out.println（“Fahrzeug（e）erfolgreich verkauft”）；
}否则{
soldCar=null；
系统错误打印（“Nicht genug MAN卡车订购柴油vorhanden”）；
}
打破
案例车辆品牌：斯堪尼亚：
如果（this.scaniaStock>=1）{
this.scaniaStock=this.scaniaStock-1；
卡车库存=卡车库存-1；
柴油储备升=柴油储备升-车辆、油箱和卡车尺寸；
System.out.pr
public boolean checkAvailability(int brand, int amount) {
// .....
}
public abstract void checkAvailability();
public abstract boolean checkAvailability(int brand, int amount);
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;
}
}