Kfz - Händler Klasse. JUnit-Test gibt noch Fehler an, aber finde Ursache nicht

A

Alpinwhite

Aktives Mitglied
Hallo, wie in der Aufgabenbeschreibung soll ich ein Programm für einen Kfz-Händler erstellen und mit einem vorgegebenem JUnit-Test überprüfen. Der zeigt aber noch 3 Errors an, doch ich weiß nicht was sie genau bedeuten.
Daher zu meiner Frage, habe ich die Aufgabe überhaupt richtig verstanden und stimmt was ich gemacht habe in etwa? In Eclipse kommen soweit keine Fehlermeldungen.

"
Der KFZ-Händler hat Platz für 15 PKWs (Konstante VehicleType.PASSENGER_CAR) und 5 LKWs (VehicleType.TRUCK) und eine Tankstelle, deren Kapazität 250 Liter Diesel sowie 180 Liter Benzin beträgt.
Jeder PKW muss für einen erfolgreichen Verkauf mit 40 Litern Benzin betankt werden können und jeder LKW mit 80 Liter Diesel.
Funktionalität: sellVehicle: Verkauf einer Vehicle-Instanz mit Typ-definierendem Parameter byte vehicleType, falls möglich (richtiger Typus ist noch lagernd und genügend Treibstoff vorhanden) 
sellVehicles: Verkauf mehrerer Vehicles mit demselben Typus byte vehicleType und einer ganzzahligen Stückzahl (int) 
fillGas: Auffüllen der Tankstelle um float liters Benzin 
fillDiesel: Auffüllen der Tankstelle um float liters Diesel 
reorderVehicles: Das Lager wieder neu befüllen um n Vehicles eines Typus byte vehicleType. Hinweise:  Zu Beginn sind die Lager (private Felder float gasStockLiters, float dieselStockLiters, int passengerCarsStock, int trucksStock ) des KFZ-Händlers immer voll. Das Auffüllen von Lagerständen funktioniert (Rückgabetyp boolean) nur mit der richtigen Menge oder Anzahl, sodass die maximale Lagerkapazität nicht überschritten wird.  Der Typ des KFZs ist durch die byte-Konstanten der (vorgegebenen) Klasse VehicleType definiert. Nutzen sie diese Konstanten (nicht die Absolutwerte der Konstanten!) und überprüfen sie diese auch, wo angebracht.  Die lagernden Vehicles sind nur als Zähler mitzuspeichern. Wird aber ein Fahrzeug (bzw. mehrere) verkauft, dann soll als Methoden-Rückgabewert ein Objekt der Klasse Vehicle mit dem richtigen Treibstofffüllstand (Feld fuel) und Typus (Feld vehicleType) zurückgegeben werden.

Mögliche Lösung:

Code: 
public class CarTrader {

    public static final float CAPACITY_DIESEL_LITERS = 250.f;
    public static final float CAPACITY_GAS_LITERS = 180.f;
    public static final int CAPACITY_PASSENGER_CARS = 15;
    public static final int CAPACITY_TRUCKS = 5;
   
    float gasStockLiters=250.f;
    float dieselStockLiters=180.f;
    int passengerCarsStock=15;
    int trucksStock=5;

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

    public Vehicle sellVehicle(byte vehicleType){
           
    Vehicle soldVehicle=null;
       
       
        switch (vehicleType){
       
       
       
        case VehicleType.TRUCK:
           
            if(this.dieselStockLiters>=Vehicle.TANK_SIZE_TRUCK && this.trucksStock>=1){
               
                trucksStock = trucksStock - 1;
                dieselStockLiters = dieselStockLiters - Vehicle.TANK_SIZE_PASSENGER_CAR;
                soldVehicle = new Vehicle(VehicleType.TRUCK, Vehicle.TANK_SIZE_TRUCK);
                System.out.println("LKW erfolgreich verkauft");
               
            }
                else{
                    soldVehicle=null;
                }
           
            break;
           
        case VehicleType.PASSENGER_CAR:
           
            if(gasStockLiters>=Vehicle.TANK_SIZE_PASSENGER_CAR && this.passengerCarsStock>=1){
           
                passengerCarsStock = passengerCarsStock - 1;
                gasStockLiters = gasStockLiters - Vehicle.TANK_SIZE_PASSENGER_CAR;
               
                soldVehicle = new Vehicle(VehicleType.PASSENGER_CAR, Vehicle.TANK_SIZE_PASSENGER_CAR);
                System.out.println("PKW erfolgreich verkauft");
               
        }
            else{
                soldVehicle=null;
            }
       
        break;
       
        default:
           
            break;
    }
        return soldVehicle;
}

       

       
           
       
   
           
           
           
   
   
    public Vehicle[] sellVehicles(byte vehicleType, int amount){
       
        Vehicle[] soldVehicles = new Vehicle[amount];
       
       

        switch (vehicleType){


        case VehicleType.TRUCK:
           
            if(this.dieselStockLiters>=Vehicle.TANK_SIZE_TRUCK && this.trucksStock>=amount){
               
                trucksStock = trucksStock - amount;
                dieselStockLiters = dieselStockLiters - (Vehicle.TANK_SIZE_TRUCK * amount);
               
                for (int i=0; i<amount; i++){
                   
                    soldVehicles[i]=new Vehicle(VehicleType.PASSENGER_CAR, Vehicle.TANK_SIZE_PASSENGER_CAR);
                }


                System.out.println("LKW erfolgreich verkauft");
               
            }
                else{
                    soldVehicles=null;
                }
           
            break;
           
           
           
           
        case VehicleType.PASSENGER_CAR:
           
            if(gasStockLiters>=Vehicle.TANK_SIZE_PASSENGER_CAR && this.passengerCarsStock>=amount){
           
                passengerCarsStock = passengerCarsStock - amount;
                gasStockLiters = gasStockLiters - (Vehicle.TANK_SIZE_TRUCK * amount);
               
                for (int i=0; i<amount; i++){
                   
                    soldVehicles[i]=new Vehicle(VehicleType.PASSENGER_CAR, Vehicle.TANK_SIZE_PASSENGER_CAR);
                }
               
                System.out.println("PKW erfolgreich verkauft");
           
        }
            else{
                soldVehicles=null;
            }

        break;

        default:
            soldVehicles=null;
            break;
        }
       
       
        return soldVehicles;
    }
       
   
    void fillGas(float gas){
       
        if((gasStockLiters + gas)<=250){
       
            gasStockLiters = gasStockLiters + gas;
        }
            else{
                System.err.println("Die Kapazität beträgt höchstens 250 Liter");
            }
        }
   
    void fillDiesel(float diesel){
   
        if((dieselStockLiters + diesel)<=180){
           
            dieselStockLiters = dieselStockLiters + diesel;   
        }
       
            else{
                System.err.println("Die Kapazität beträgt höchstens 180 Liter");
            }
    }
   
    public boolean reorderVehicles(int vehicle, int amountVehicles){
       
        boolean full=false;
   
        if (vehicle==VehicleType.TRUCK){
           
            if ((trucksStock + amountVehicles)<=5){
       
                trucksStock = trucksStock + amountVehicles;
                full=true;
            }
           
        }
       
        if (vehicle==VehicleType.PASSENGER_CAR){
       
            if ((passengerCarsStock + amountVehicles)<=15){
               
                passengerCarsStock = passengerCarsStock + amountVehicles;
                full=true;
            }
           
        }
            else {
                System.out.println("Bitte 5 oder 7 wählen");
            }
        return full;
        }

    void statusOutput()
    {
        System.out.println("AutoHändler - Lagerbestand:");
        System.out.println("    PKW: " + passengerCarsStock);
        System.out.println("    - Benzin: " + gasStockLiters);
        System.out.println("    LKW: " + trucksStock);
        System.out.println("    - Diesel: " + dieselStockLiters);
    }

Code: 
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(){

    }

}

Code: 
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 VehicleType;
   
    public Vehicle(byte VehicleType, float fuel){
       
        this.VehicleType= VehicleType;
        this.fuel= fuel;
       
       
    }
}

JUnit Test:

Code: 
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

import static org.junit.Assert.*;


/**
* Einführung in die Softwareentwicklung 2 (ESE2), SS2018
* Vorführaufgabe 1
* <p>
* JUnit Tests
*
* @author Clemens Schartmüller, Technische Hochschule Ingolstadt (THI)
* @version 18.03.2018
* @email clemens.schartmueller@thi.de
*/
public class CarTraderJUnitTests {


    private static final double DELTA_FLOAT = 0.0000001f;
    CarTrader trader;

    @Before
    public void setUp() throws Exception {
        trader = new CarTrader();
    }

    @After
    public void tearDown() throws Exception {
        trader = null;
    }

    @Test
    public void testUnchangedConstants() {
        assertEquals(7, VehicleType.PASSENGER_CAR);
        assertEquals(5, VehicleType.TRUCK);
        assertEquals(250.f, CarTrader.CAPACITY_DIESEL_LITERS, DELTA_FLOAT);
        assertEquals(180.f, CarTrader.CAPACITY_GAS_LITERS, DELTA_FLOAT);
        assertEquals(15, CarTrader.CAPACITY_PASSENGER_CARS);
        assertEquals(5, CarTrader.CAPACITY_TRUCKS);

        assertEquals(40.f, Vehicle.TANK_SIZE_PASSENGER_CAR, DELTA_FLOAT);
        assertEquals(80.f, Vehicle.TANK_SIZE_TRUCK, DELTA_FLOAT);
    }

    @Test
    public void testInitialStock() {
        assertEquals(CarTrader.CAPACITY_PASSENGER_CARS, trader.getPassengerCarsStock());
        assertEquals(CarTrader.CAPACITY_TRUCKS, trader.getTrucksStock());
        assertEquals(CarTrader.CAPACITY_GAS_LITERS, trader.getGasStockLiters(), DELTA_FLOAT);
        assertEquals(CarTrader.CAPACITY_DIESEL_LITERS, trader.getDieselStockLiters(), DELTA_FLOAT);
    }

    @Test
    public void testSoldCarAttributes() {
        testSoldCarAttributes(VehicleType.PASSENGER_CAR, trader.sellVehicle(VehicleType.PASSENGER_CAR));
        testSoldCarAttributes(VehicleType.TRUCK, trader.sellVehicle(VehicleType.TRUCK));
    }


    @Test
    public void testTruckStocks() {
        for (int i = 0; i < 3; i++) {
            assertNotNull("A fresh trader needs to be able to sell 3 trucks (3*80 < 250l) without refill", trader.sellVehicle(VehicleType.TRUCK));
        }

        refillFuelAndCheckVehicleStock(VehicleType.TRUCK, 3);

        trader = new CarTrader();
        Vehicle[] multibuy = trader.sellVehicles(VehicleType.TRUCK, 3);
        assertEquals("A fresh trader needs to be able to sell 3 trucks (3*80 < 250l) without refill", 3, multibuy.length);
        assertNotNull("A fresh trader needs to be able to sell 3 trucks (3*80 < 250l) without refill", multibuy);
        for (Vehicle v : multibuy) {
            assertNotNull("A fresh trader needs to be able to sell 3 trucks (3*80 < 250l) without refill", v);
            testSoldCarAttributes(VehicleType.TRUCK, v);
        }
        refillFuelAndCheckVehicleStock(VehicleType.TRUCK, 3);
    }

    @Test
    public void testReorderVehiclesAboveCap() {
        assertFalse(trader.reorderVehicles(VehicleType.PASSENGER_CAR, 1));
        assertEquals(CarTrader.CAPACITY_PASSENGER_CARS, trader.getPassengerCarsStock());
        assertFalse(trader.reorderVehicles(VehicleType.TRUCK, 1));
        assertEquals(CarTrader.CAPACITY_TRUCKS, trader.getTrucksStock());
    }

    @Test
    public void testMixedBuy() {
        assertNotNull(trader.sellVehicles(VehicleType.TRUCK, 2));
        assertNotNull(trader.sellVehicles(VehicleType.PASSENGER_CAR, 1));
        assertEquals(CarTrader.CAPACITY_DIESEL_LITERS - 2 * Vehicle.TANK_SIZE_TRUCK, trader.getDieselStockLiters(), DELTA_FLOAT);
        assertEquals(CarTrader.CAPACITY_GAS_LITERS - 1 * Vehicle.TANK_SIZE_PASSENGER_CAR, trader.getGasStockLiters(), DELTA_FLOAT);
    }

    @Test
    public void testRestockingPassengerCar() {
        for (int i = 0; i < 3; i++) {
            assertNotNull(trader.sellVehicles(VehicleType.PASSENGER_CAR, 4));
            assertTrue(trader.fillGas(Vehicle.TANK_SIZE_PASSENGER_CAR * 4));
        }

        assertNotNull(trader.sellVehicles(VehicleType.PASSENGER_CAR, 3));
        assertTrue(trader.fillGas(Vehicle.TANK_SIZE_PASSENGER_CAR * 3));
        assertNull("Trader should not be able to sell more than 15 passenger cars without restocking", trader.sellVehicles(VehicleType.PASSENGER_CAR, 3));


        assertTrue(trader.reorderVehicles(VehicleType.PASSENGER_CAR, 3));
        assertNull("Trader should not be able to sell more than the restocked amount of cars (3) after being totally depleted and restock again.", trader.sellVehicles(VehicleType.PASSENGER_CAR, 4));

        assertFalse("Trader should not be able to restock more cars than the max stock capacity.", trader.reorderVehicles(VehicleType.PASSENGER_CAR, CarTrader.CAPACITY_PASSENGER_CARS - 3 + 1));

    }

    @Test
    public void testRestockingTrucks() {
        assertNotNull(trader.sellVehicles(VehicleType.TRUCK, 3));
        assertTrue(trader.fillDiesel(Vehicle.TANK_SIZE_TRUCK * 3));

        assertNotNull(trader.sellVehicles(VehicleType.TRUCK, 2)); // trader should be empty now, but enough diesel left to sell more
        assertTrue(trader.fillDiesel(Vehicle.TANK_SIZE_TRUCK * 2));
        assertNull("Trader should not be able to sell more than 5 trucks without restocking", trader.sellVehicles(VehicleType.TRUCK, 3));


        assertTrue(trader.reorderVehicles(VehicleType.TRUCK, 2));
        assertNull("Trader should not be able to sell more than the restocked amount of cars (2) after being totally depleted and restock again.", trader.sellVehicles(VehicleType.TRUCK, 3));

        assertFalse("Trader should not be able to restock more cars than the max stock capacity.", trader.reorderVehicles(VehicleType.TRUCK, CarTrader.CAPACITY_TRUCKS - 2 + 1));

    }


    @Test
    public void testPassengerCarStocks() {
        for (int i = 0; i < 4; i++) {
            assertNotNull("A fresh trader needs to be able to sell 4 passenger cars (4*40 < 180l) without refill", trader.sellVehicle(VehicleType.PASSENGER_CAR));
        }

        refillFuelAndCheckVehicleStock(VehicleType.PASSENGER_CAR, 4);

        trader = new CarTrader();
        Vehicle[] multibuy = trader.sellVehicles(VehicleType.PASSENGER_CAR, 4);
        assertEquals("A fresh trader needs to be able to sell 4 passenger cars (4*40 < 180l) without refill", 4, multibuy.length);
        assertNotNull("A fresh trader needs to be able to sell 4 passenger cars (4*40 < 180l) without refill", multibuy);
        for (Vehicle v : multibuy) {
            assertNotNull("A fresh trader needs to be able to sell 4 passenger cars (4*40 < 180l) without refill", v);
            testSoldCarAttributes(VehicleType.PASSENGER_CAR, v);
        }
        refillFuelAndCheckVehicleStock(VehicleType.PASSENGER_CAR, 4);
    }

    private void refillFuelAndCheckVehicleStock(byte vehicleType, int unitsSold) {
        float newFuelStock = getFuelStockCap(vehicleType) - unitsSold * getFuelByType(vehicleType);

        if (vehicleType == VehicleType.PASSENGER_CAR) {

            assertEquals(newFuelStock, trader.getGasStockLiters(), DELTA_FLOAT);
            assertTrue("Overfilling the gas stock should not be allowed, i.e., return false", !trader.fillGas((CarTrader.CAPACITY_GAS_LITERS - newFuelStock) * 3));
            assertTrue(trader.fillGas(CarTrader.CAPACITY_GAS_LITERS - newFuelStock - 10.f));
            assertEquals(CarTrader.CAPACITY_GAS_LITERS - 10.f, trader.getGasStockLiters(), DELTA_FLOAT);
            assertTrue("Filling the stock exactly to its capacity should be allowed (i.e., return true)", trader.fillGas(10.f));

            // buy cars in batches of 4 & refill until stock is empty
            for (int i = 0; i < 2; i++) {
                Vehicle[] vehicles = trader.sellVehicles(VehicleType.PASSENGER_CAR, 4);
                assertEquals(4, vehicles.length);
                assertTrue(trader.fillGas(Vehicle.TANK_SIZE_PASSENGER_CAR * 4));
            }
            // now we should have 12 cars sold, need 3 more until it should be disallowed

            assertNotNull(trader.sellVehicles(VehicleType.PASSENGER_CAR, 3));

            assertTrue(trader.fillGas(Vehicle.TANK_SIZE_PASSENGER_CAR * 3));
            assertNull("Should not be able to buy more than 15 cars total without refill, although gas stock would allow it", trader.sellVehicles(VehicleType.PASSENGER_CAR, 4));


        } else if (vehicleType == VehicleType.TRUCK) {

            assertEquals(newFuelStock, trader.getDieselStockLiters(), DELTA_FLOAT);
            assertEquals("Overfilling the diesel stock should not be allowed, i.e., return false", false, trader.fillDiesel((CarTrader.CAPACITY_DIESEL_LITERS - newFuelStock) * 3));
            assertTrue(trader.fillDiesel(CarTrader.CAPACITY_DIESEL_LITERS - newFuelStock - 10.f));
            assertEquals(CarTrader.CAPACITY_DIESEL_LITERS - 10.f, trader.getDieselStockLiters(), DELTA_FLOAT);
            assertTrue("Filling the stock exactly to its capacity should be allowed (i.e., return true)", trader.fillDiesel(10.f));

            // diesel is refilled, we should be able to buy another 2 trucks, but not more
            for (int i = 0; i < 2; i++) {
                testSoldCarAttributes(VehicleType.TRUCK, trader.sellVehicle(VehicleType.TRUCK));
            }
            // next should fail
            assertNull("You should not be able to buy more than 5 trucks without refilling the stock", trader.sellVehicle(VehicleType.TRUCK));
        }
    }

    private float getFuelByType(byte vehicleType) {
        switch (vehicleType) {
            case VehicleType.PASSENGER_CAR:
                return Vehicle.TANK_SIZE_PASSENGER_CAR;
            case VehicleType.TRUCK:
                return Vehicle.TANK_SIZE_TRUCK;
            default:
                throw new IllegalArgumentException();
        }
    }

    private float getFuelStockCap(byte vehicleType) {
        switch (vehicleType) {
            case VehicleType.PASSENGER_CAR:
                return CarTrader.CAPACITY_GAS_LITERS;
            case VehicleType.TRUCK:
                return CarTrader.CAPACITY_DIESEL_LITERS;
            default:
                throw new IllegalArgumentException();
        }
    }

    private void testSoldCarAttributes(byte vehicleType, final Vehicle v) {
        switch (vehicleType) {
            case VehicleType.PASSENGER_CAR:
                assertEquals(40.f, v.getFuel(), DELTA_FLOAT);
                assertEquals(VehicleType.PASSENGER_CAR, v.getVehicleType());
                break;
            case VehicleType.TRUCK:
                assertEquals(80.f, v.getFuel(), DELTA_FLOAT);
                assertEquals(VehicleType.TRUCK, v.getVehicleType());
        }

    }

}
 
Wenn man eine dieser Methoden aufruft:
Alpinwhite hat gesagt.:
Das Auffüllen von Lagerständen funktioniert (Rückgabetyp boolean) nur mit der richtigen Menge oder Anzahl, sodass die maximale Lagerkapazität nicht überschritten wird.
Zum Vergrößern anklicken....
kann das Auffüllen offenbar entweder funktionieren oder auch nicht. Was wäre denn die nützlichste ja/nein-Information, die man dem Aufrufer mitteilen könnte?
 
Habe die Sache mit dem Boolean nun integriert. Im JUnit Test habe ich jetzt nur noch einen Fehler. Und zwar in der Klasse "Vehicle" wird mir in 4 Zeilen "The primitive type byte of Vehicle does not have a field PASSENGER_CAR" angezeigt. Was bedeutet das?

Klasse CarTrader
Code: 
public class CarTrader {

    public static final float CAPACITY_DIESEL_LITERS = 250.f;
    public static final float CAPACITY_GAS_LITERS = 180.f;
    public static final int CAPACITY_PASSENGER_CARS = 15;
    public static final int CAPACITY_TRUCKS = 5;
 
 
    float gasStockLiters=180.f;
    float dieselStockLiters=250.f;
    int passengerCarsStock=15;
    int trucksStock=5;

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

    public Vehicle sellVehicle(byte vehicleType){
       
    Vehicle soldVehicle=null;
   
   
        switch (vehicleType){
   
   
   
        case 0: //VehicleType.TRUCK:
       
            if(this.dieselStockLiters>=Vehicle.TANK_SIZE_TRUCK && this.trucksStock>=1){
           
                trucksStock = trucksStock - 1;
                dieselStockLiters = dieselStockLiters - Vehicle.TANK_SIZE_PASSENGER_CAR;
                soldVehicle = new Vehicle(VehicleType.TRUCK);
                System.out.println("LKW erfolgreich verkauft");
           
            }
                else{
                    soldVehicle=null;
                }
       
            break;
       
        case 1://VehicleType.PASSENGER_CAR:
       
            if(gasStockLiters>=Vehicle.TANK_SIZE_PASSENGER_CAR && this.passengerCarsStock>=1){
       
                passengerCarsStock = passengerCarsStock - 1;
                gasStockLiters = gasStockLiters - Vehicle.TANK_SIZE_PASSENGER_CAR;
           
                soldVehicle = new Vehicle(VehicleType.PASSENGER_CAR);
                System.out.println("PKW erfolgreich verkauft");
           
        }
            else{
                soldVehicle=null;
            }
   
        break;
   
        default:
       
            break;
    }
        return soldVehicle;
}

   

   
       
   
 
       
       
       
 
 
    public Vehicle[] sellVehicles(byte vehicleType, int amount){
   
        Vehicle[] soldVehicles = new Vehicle[amount];
        float currentAmount=40*amount;
        float currentAmount2=80*amount;
   
   

        switch (vehicleType){


        case 0://VehicleType.TRUCK:
       
            if(this.dieselStockLiters>=currentAmount2 && this.trucksStock>=amount){
           
                trucksStock = trucksStock - amount;
                dieselStockLiters = dieselStockLiters - (currentAmount2);
           
                for (int i=0; i<amount; i++){
               
                    soldVehicles[i]=new Vehicle(VehicleType.TRUCK);
                }


                System.out.println("LKW erfolgreich verkauft");
           
            }
                else{
                    soldVehicles=null;
                }
       
            break;
       
       
       
       
        case 1://VehicleType.PASSENGER_CAR:
       
       
            if(this.gasStockLiters>=currentAmount && this.passengerCarsStock>=amount){
       
                passengerCarsStock = passengerCarsStock - amount;
                gasStockLiters = gasStockLiters - (currentAmount);
           
                for (int i=0; i<amount; i++){
               
                    soldVehicles[i]=new Vehicle(VehicleType.PASSENGER_CAR);
                }
           
                System.out.println("PKW erfolgreich verkauft");
       
        }
            else{
                soldVehicles=null;
            }

        break;

        default:
            soldVehicles=null;
            break;
        }
   
   
        return soldVehicles;
    }
   
 
    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 boolean reorderVehicles(byte vehicle, int amountVehicles){
   
        boolean full=false;
 
        if (vehicle==1){
       
            if ((trucksStock + amountVehicles)<=CarTrader.CAPACITY_TRUCKS){
   
                trucksStock = trucksStock + amountVehicles;
                full=true;
            }
       
        }
   
        if (vehicle==0){
   
            if ((passengerCarsStock + amountVehicles)<=CarTrader.CAPACITY_PASSENGER_CARS){
           
                passengerCarsStock = passengerCarsStock + amountVehicles;
                full=true;
            }
       
        }
            else {
                System.out.println("Bitte 5 oder 7 wählen");
            }
        return full;
        }

    void statusOutput()
    {
        System.out.println("AutoHändler - Lagerbestand:");
        System.out.println("    PKW: " + passengerCarsStock);
        System.out.println("    - Benzin: " + gasStockLiters);
        System.out.println("    LKW: " + trucksStock);
        System.out.println("    - Diesel: " + dieselStockLiters);
    }
}

Klasse Vehicle

Code: 
/**

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 VehicleType;
 
 
    public Vehicle(){
   
    }
[code=Java]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 VehicleType;
 
 
    public Vehicle(){
     
    }
 
    public Vehicle(byte VehicleType){
     
        this();
        if (VehicleType == VehicleType.PASSENGER_CAR){
            this.VehicleType= VehicleType.PASSENGER_CAR ;
            this.fuel= Vehicle.TANK_SIZE_PASSENGER_CAR;
        }
     
        if(VehicleType == VehicleType.TRUCK){
            this.VehicleType= VehicleType.TRUCK;
            this.fuel= Vehicle.TANK_SIZE_TRUCK;
        }
     
public float getFuel(){
            return fuel;
        }
        public byte getVehicleType(){
            return VehicleType;
           
       
        }


    }
}

Klasse VehicleType

Java: 
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(){

    }

}

CarTraderInteractive

Code: 
import java.io.BufferedReader;
import java.io.InputStreamReader;

public class CarTraderInteractive
{
    // symbolische Konstanten fuer die Befehlseingabe
    private static final int Ende = 0;
    private static final int FahrzeugVerkaufen = 1;
    private static final int Mehrere_Fahrzeuge_des_gleichen_Typs_verkaufen = 2;
    private static final int Tankstelle_Diesel_nachfüllen = 3;
    private static final int Tankstelle_Benzin_nachfüllen = 4;
    private static final int Fahrzeuge_nachbestellen = 5;
    private static final int Statusausgabe = 6;
    static BufferedReader keyboard = new BufferedReader(new InputStreamReader(System.in));

    // Erzeugung des Menüs und Einlesen des ausgewählten Befehls
    private static int printMenu() throws java.io.IOException
    {
        System.out.println("MENUE:\n------");
        System.out.println("Fahrzeug verkaufen:\t" + FahrzeugVerkaufen );
        System.out.println("Mehrere Fahrzeuge des gleichen Typs verkaufen:\t" + Mehrere_Fahrzeuge_des_gleichen_Typs_verkaufen);
        System.out.println("[Tankstelle] Diesel nachfüllen:\t" + Tankstelle_Diesel_nachfüllen);
        System.out.println("[Tankstelle] Benzin nachfüllen: " + Tankstelle_Benzin_nachfüllen);
        System.out.println("Fahrzeuge nachbestellen: " + Fahrzeuge_nachbestellen);
        System.out.println("Statusausgabe:\t\t" + Statusausgabe);
        System.out.println("Ende:\t\t\t" + Ende);

        return Integer.parseInt(keyboard.readLine());
    }

    public static void main(String[] args) throws java.io.IOException
    {
      
        int command;
        byte sellCar;
        byte multipleSellCar;
        int diesel;
        int gas;
        int carReorder;
        int amount;
        byte reorderTypeCar;
        CarTrader trader = new CarTrader();

        command = printMenu();
      
        while ( command != Ende )
        {
          
          
          
            switch ( command )
            {
            case FahrzeugVerkaufen :
                System.out.print("Fahrzeugtyp (0: LKW, 1: PKW) : ");
                sellCar = Byte.parseByte(keyboard.readLine());  
                trader.sellVehicle(sellCar);
                break;
              
            case Mehrere_Fahrzeuge_des_gleichen_Typs_verkaufen :
                 System.out.print("Fahrzeugtyp (0: LKW, 1: PKW) : ");
                 multipleSellCar = Byte.parseByte(keyboard.readLine());
                 System.out.println("Anzahl (1 ... n) :");
                 amount = Integer.parseInt(keyboard.readLine());
                 trader.sellVehicles(multipleSellCar, amount);
                 break;
               
            case Tankstelle_Diesel_nachfüllen :
                 System.out.print("Wieviel Diesel soll nachgefüllt werden?");
                 diesel = Integer.parseInt(keyboard.readLine());
                 trader.fillDiesel(diesel);
                break;
              
            case Tankstelle_Benzin_nachfüllen :
                 System.out.print("Wieviel Benzin soll nachgefüllt werden?");
                 gas = Integer.parseInt(keyboard.readLine());
                 trader.fillGas(gas);
                break;
              
            case Fahrzeuge_nachbestellen:
                 System.out.print("Fahrzeugtyp (0: PKW, 1: LKW) : ");
                 reorderTypeCar = Byte.parseByte(keyboard.readLine());
                 System.out.println("Anzahl (1 ... n) :");
                 amount = Integer.parseInt(keyboard.readLine());
                trader.reorderVehicles(reorderTypeCar, amount);
                break;
            case Statusausgabe :
                trader.statusOutput();
                break;
            default :
                System.err.println("Ungültige Eingabe");
                break;
            }

            command = printMenu();
        }
    }
}
 
Zuletzt bearbeitet:

Aktuelle Jobs

Neue Themen

Ähnliche Themen

welche Fehler gibt es noch? wie kann ich es noch vervollständigen
Antworten: 15
Fehler: Hauptklasse Main konnte nicht gefunden oder geladen werden Ursache: java.lang.ClassNotFoundException: Main
Antworten: 24
Mausklick-Handler über Mausklick-Handler
Antworten: 1
Bilderkennung - KFZ-Kennzeichen
Antworten: 4
JUnit wie Testergebnisse pro Test ("Test Report") erhalten?
Antworten: 1

Zurück
Oben